From 6c29aa013b97756dfdb9d090fa56e1778209a5be Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 8 Jan 2024 14:26:58 -0500 Subject: [PATCH 001/128] set up new branch with LO circuit cut finder --- .../LO_circuit_cut_optimizer/__init__.py | 0 .../best_first_search.py | 366 ++++++++ .../circuit_interface.py | 496 ++++++++++ .../cut_optimization.py | 298 ++++++ .../cutting_actions.py | 849 ++++++++++++++++++ .../disjoint_subcircuits_state.py | 487 ++++++++++ .../lo_cuts_optimizer.py | 173 ++++ .../optimization_settings.py | 179 ++++ .../quantum_device_constraints.py | 36 + .../search_space_generator.py | 228 +++++ .../LO_circuit_cut_optimizer/utils.py | 130 +++ .../cutting/cut_finding/__init__.py | 0 .../tutorials/LO_circuit_cut_finder.ipynb | 408 +++++++++ 13 files changed, 3650 insertions(+) create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py create mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py create mode 100644 circuit_knitting/cutting/cut_finding/__init__.py create mode 100644 docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py new file mode 100644 index 000000000..b261400d8 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py @@ -0,0 +1,366 @@ +"""File containing the classes required to implement Dijkstra's (best-first) search algorithm.""" +import heapq +import numpy as np +from itertools import count + + +class BestFirstPriorityQueue: + + """Class that implements priority queues for best-first search. + + The tuples that are pushed onto the priority queues have the form: + + (, , , , ) + + (numeric or tuple) is a numeric cost or tuple of numeric + lexically-ordered costs that are to be minimized. + + (int) is the negative of the search depth of the + search state represented by the tuple. Thus, if several search states + have identical costs, priority is given to the deepest states to + encourage depth-first behavior. + + is a pseudo-random number that randomly break ties in a + stable manner if several search states have identical costs at identical + search depths. + + is a sequential count of push operations that is used to + break further ties just in case two states with the same costs and + depths are somehow assigned the same pseudo-random numbers. + + is a state object generated by the optimization process. + Because of the design of the tuple entries that precede it, state objects + never get evaluated in the heap-managment comparisons that are performed + internally by the priority-queue implementation. + + Member Variables: + + rand_gen is a Numpy random number generator. + + unique is a Python sequence counter. + + pqueue is a Python priority queue (currently heapq, with plans to move to + queue.PriorityQueue if parallelization is ultimately required). + """ + + def __init__(self, rand_seed): + """A BestFirstPriorityQueue object must be initialized with a + specification of a random seed (int) for the pseudo-random number + generator. If None is used as the random seed, then a seed is + obtained using an operating-system call to achieve a randomized + initialization. + """ + + self.rand_gen = np.random.default_rng(rand_seed) + self.unique = count() + self.pqueue = list() # queue.PriorityQueue() + + def put(self, state, depth, cost): + """Push state onto the priority queue. The search depth and cost + of the state must also be provided as input. + """ + + heapq.heappush( + self.pqueue, + (cost, (-depth), self.rand_gen.random(), next(self.unique), state), + ) + + def get(self): + """Pop and return the lowest cost state currently on the + queue, along with the search depth of that state and its cost. + None, None, None is returned if the priority queue is empty. + """ + + if self.qsize() == 0: + return None, None, None + + best = heapq.heappop(self.pqueue) + + return best[-1], (-best[1]), best[0] + + def qsize(self): + """Return the size of the priority queue.""" + + return len(self.pqueue) + + def clear(self): + """Clear all entries in the priority queue.""" + + self.pqueue.clear() + + +class BestFirstSearch: + + """Class that implements best-first search. The search proceeds by + choosing the deepest, lowest-cost state in the search frontier and + generating next states. Successive calls to the optimizationPass() + method will resume the search at the next deepest, lowest-cost state + in the search frontier. The costs of goal states that are returned + are used to constrain subsequent searches. None is returned if no + (additional) feasible solutions can be found, or when no (additional) + solutions can be found without exceeding the lowest upper-bound cost + across the goal states previously returned. + + Member Variables: + + rand_seed (int) is the seed to use when initializing Numpy random number + generators in the bounded best-first priority-queue objects. + + cost_func (lambda state, *args) is a function that computes cost values + from search states. Input arguments to the optimizationPass() method are + also passed to the cost_func. The cost returned can be numeric or tuples + of numerics. In the latter case, lexicographical comparisons are + performed per Python semantics. + + next_state_func (lambda state, *args) is a function that returns a list + of next states generated from the input state. Input arguments to the + optimizationPass() method are also passed to the next_state_func. + + goal_state_func (lambda state, *args) is a function that returns True if + the input state is a solution state of the search. Input arguments to the + optimizationPass() method are also passed to the goal_state_func. + + upperbound_cost_func (lambda goal_state, *args) can either be None or a + function that returns an upper bound to the optimal cost given a goal_state + as input. The upper bound is used to prune next-states from the search in + subsequent calls to the optimizationPass() method. If upperbound_cost_func + is None, the cost of the goal_state as determined by cost_func is used as + an upper bound to the optimal cost. Input arguments to the + optimizationPass() method are also passed to the upperbound_cost_func. + + mincost_bound_func (lambda *args) can either be None or a function that + returns a cost bound that is compared to the minimum cost across all + vertices in a search frontier. If the minimum cost exceeds the min-cost + bound, the search is terminated even if a goal state has not yet been found. + Returning None is equivalent to returning an infinite min-cost bound. A + mincost_bound_func that is None is likewise equivalent to an infinite + min-cost bound. + + stop_at_first_min (Boolean) is a flag that indicates whether or not to + stop the search after the first minimum-cost goal state has been reached. + + max_backjumps (int or None) is the maximum number of backjump operations that + can be performed before the search is forced to terminate. None indicates + that no restriction is placed in the number of backjump operations. + + pqueue (BestFirstPriorityQueue) is a best-first priority-queue object. + + upperbound_cost (numeric or tuple) is the cost bound obtained by applying + the upperbound_cost_func to the goal states that are encountered. + + mincost_bound (numeric or tuple) is the cost bound imposed on the minimum + cost across all vertices in the search frontier. The search is forced to + terminate when the minimum cost exceeds this cost bound. + + minimum_reached (Boolean) is a flag that indicates whether or not the + first minimum-cost goal state has been reached. + + num_states_visited (int) is the number of states that have been dequeued + and processed in the search. + + num_next_states (int) is the number of next-states generated from the + states visited. + + num_enqueues (int) is the number of next-states pushed onto the search + priority queue after cost pruning. + + num_backjumps (int) is the number of times a backjump operation is + performed. In the case of best-first search, a backjump occurs when the + depth of the lowest-cost state in the search frontier is less than or + equal to the depth of the previous lowest-cost state. + """ + + def __init__( + self, optimization_settings, search_functions, stop_at_first_min=False + ): + """A BestFirstSearch object must be initialized with a list of + initial states, a random seed for the numpy pseudo-random number + generators that are used to break ties, together with an object + that holds the various functions that are used by the search + engine to generate and explore the search space. A Boolean flag + can optionally be provided to indicate whether to stop the search + after the first minimum-cost goal state has been reached (True), + or whether subsequent calls to the optimizationPass() method should + return any additional minimum-cost goal states that might exist + (False). The default is not to stop at the first minimum. A limit + on the maximum number of backjumps can also be optionally provided + to terminate the search if the number of backjumps exceeds the + specified limit without finding the (next) optimal goal state. + """ + + self.rand_seed = optimization_settings.getRandSeed() + self.cost_func = search_functions.cost_func + self.next_state_func = search_functions.next_state_func + self.goal_state_func = search_functions.goal_state_func + self.upperbound_cost_func = search_functions.upperbound_cost_func + self.mincost_bound_func = search_functions.mincost_bound_func + + self.stop_at_first_min = stop_at_first_min + self.max_backjumps = optimization_settings.getMaxBackJumps() + + self.pqueue = BestFirstPriorityQueue(self.rand_seed) + + self.upperbound_cost = None + self.mincost_bound = None + self.minimum_reached = False + self.num_states_visited = 0 + self.num_next_states = 0 + self.num_enqueues = 0 + self.num_backjumps = 0 + self.penultimate_stats = None + + def initialize(self, initial_state_list, *args): + self.pqueue.clear() + + self.upperbound_cost = None + self.mincost_bound = None + self.minimum_reached = False + self.num_states_visited = 0 + self.num_next_states = 0 + self.num_enqueues = 0 + self.num_backjumps = 0 + self.penultimate_stats = self.getStats() + + self.put(initial_state_list, 0, args) + + def optimizationPass(self, *args): + """Perform best-first search until either a goal state is found and + returned, or cost-bounds are reached or no further goal states can be + found, in which case None is returned. The cost of the returned state + is also returned. Any input arguments to optimizationPass() are passed + along to the search-space functions employed. + """ + + if self.mincost_bound_func is not None: + self.mincost_bound = self.mincost_bound_func(*args) + + prev_depth = None + + while ( + self.pqueue.qsize() > 0 + and (not self.stop_at_first_min or not self.minimum_reached) + and (self.max_backjumps is None or self.num_backjumps < self.max_backjumps) + ): + state, depth, cost = self.pqueue.get() + + self.updateMinimumReached(cost) + + if cost is None or self.costBoundsExceeded(cost, args): + return None, None + + self.num_states_visited += 1 + + if prev_depth is not None and depth <= prev_depth: + self.num_backjumps += 1 + + prev_depth = depth + + if self.goal_state_func(state, *args): + self.penultimate_stats = self.getStats() + self.updateUpperBoundGoalState(state, *args) + self.updateMinimumReached(cost) + + return state, cost + + next_state_list = self.next_state_func(state, *args) + self.put(next_state_list, depth + 1, args) + + # If all states have been explored, then the minimum has been reached + if self.pqueue.qsize() == 0: + self.minimum_reached = True + + return None, None + + def minimumReached(self): + """Return True if the optimization reached a global minimum.""" + + return self.minimum_reached + + def getStats(self, penultimate=False): + """Return a Numpy array containing the number of states visited + (dequeued), the number of next-states generated, the number of + next-states that are enqueued after cost pruning, and the number + of backjumps performed. Numpy arrays are employed to facilitate + the aggregation of search statisitcs. + """ + + if penultimate: + return self.penultimate_stats + + return np.array( + ( + self.num_states_visited, + self.num_next_states, + self.num_enqueues, + self.num_backjumps, + ), + dtype=int, + ) + + def getUpperBoundCost(self): + """Return the current upperbound cost""" + + return self.upperbound_cost + + def updateUpperBoundCost(self, cost_bound): + """Update the cost upper bound based on an + input cost bound. + """ + + if cost_bound is not None and ( + self.upperbound_cost is None or cost_bound < self.upperbound_cost + ): + self.upperbound_cost = cost_bound + + def updateUpperBoundGoalState(self, goal_state, *args): + """Update the cost upper bound based on a + goal state reached in the search. + """ + + if self.upperbound_cost_func is not None: + bound = self.upperbound_cost_func(goal_state, *args) + else: + bound = self.cost_func(goal_state, *args) + + if self.upperbound_cost is None or bound < self.upperbound_cost: + self.upperbound_cost = bound + + def put(self, state_list, depth, args): + """Push a list of (next) states onto the + best-first priority queue. + """ + + self.num_next_states += len(state_list) + + for state in state_list: + cost = self.cost_func(state, *args) + + if self.upperbound_cost is None or cost <= self.upperbound_cost: + self.pqueue.put(state, depth, cost) + self.num_enqueues += 1 + + # if (bfs_debug > 2): + # print() + # state.print(simple=True) + + def updateMinimumReached(self, min_cost): + """Update the minimum_reached flag indicating + that a global optimum has been reached. + """ + + if min_cost is None or ( + self.upperbound_cost is not None and self.upperbound_cost <= min_cost + ): + self.minimum_reached = True + + return self.minimum_reached + + def costBoundsExceeded(self, cost, args): + """Return True if any cost bounds + have been exceeded. + """ + + return cost is not None and ( + (self.mincost_bound is not None and cost > self.mincost_bound) + or (self.upperbound_cost is not None and cost > self.upperbound_cost) + ) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py new file mode 100644 index 000000000..95a055279 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py @@ -0,0 +1,496 @@ +"""File containing the classes required to represent quantum circuits in a format + native to the circuit cutting optimizer.""" +import copy +import string +import numpy as np +from abc import ABC, abstractmethod + + +class CircuitInterface(ABC): + + """Base class for accessing and manipulating external circuit + representations, and for converting external circuit representations + to the internal representation used by the circuit cutting optimization code. + + Derived classes must override the default implementations of the abstract + methods defined in this base class. + """ + + @abstractmethod + def getNumQubits(self): + """Derived classes must override this function and return the number + of qubits in the input circuit.""" + + assert False, "Derived classes must override getNumQubits()" + + @abstractmethod + def getMultiQubitGates(self): + """Derived classes must override this function and return a list that + specifies the multiqubit gates in the input circuit. + + The returned list is of the form: + [ ... [ ] ...] + + The can be any object that uniquely identifies the gate + in the circuit. The can be used as an argument in other + member functions implemented by the derived class to replace the gate + with the decomposition determined by the optimizer. + + The must of the form + (, , ..., ) + + The must be a hashable identifier that can be used to + look up cutting rules for the specified gate. Gate names are typically + the Qiskit names of the gates. + + The must be a non-negative integer with qubits numbered + starting with zero. Derived classes are responsible for constructing the + mappings from external qubit identifiers to the corresponding qubit IDs. + + The can be of the form + None + [] + [None] + [, ..., ] + + A cut constraint of None indicates that no constraints are placed + on how or whether cuts can be performed. An empty list [] or the + list [None] indicates that no cuts are to be performed and the gate + is to be applied without cutting. A list of cut types of the form + [ ... ] indicates precisely which types of + cuts can be considered. In this case, the cut type None must be + explicitly included to indicate the possibilty of not cutting, if + not cutting is to be considered. In the current version of the code, + the allowed cut types are 'None', 'GateCut', 'WireCut', and 'AbsorbGate'. + """ + + assert False, "Derived classes must override getMultiQubitGates()" + + @abstractmethod + def insertGateCut(self, gate_ID, cut_type): + """Derived classes must override this function and mark the specified + gate as being cut. The cut type can be "LO", "LOCCWithAncillas", + or "LOCCNoAncillas".""" + + assert False, "Derived classes must override insertGateCut()" + + @abstractmethod + def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): + """Derived classes must override this function and insert a wire cut + into the output circuit just prior to the specified gate on the wire + connected to the specified input of that gate. Gate inputs are + numbered starting from 1. The wire/qubit ID of the wire to be cut + is also provided as input to allow the wire choice to be verified. + The ID of the new wire/qubit is also provided, which can then be used + internally in derived classes to create new wires/qubits as needed. + The cut type can be "LO", "LOCCWithAncillas", or "LOCCNoAncillas".""" + + assert False, "Derived classes must override insertWireCut()" + + @abstractmethod + def insertParallelWireCut(self, list_of_wire_cuts): + """Derived classes must override this function and insert a parallel + LOCC wire cut without ancillas into the circuit. The + list_of_wire_cuts must be a list of wire-cut quadruples of the form: + [..., (, , , ), ...] + + The assumed cut type is "LOCCNoAncillas".""" + + assert False, "Derived classes must override insertParallelWireCut()" + + @abstractmethod + def defineSubcircuits(self, list_of_list_of_wires): + """Derived classes must override this function. The input is a + list of subcircuits where each subcircuit is specified as a + list of wire IDs.""" + + assert False, "Derived classes must override defineSubcircuits()" + + +class SimpleGateList(CircuitInterface): + + """Derived class that converts a simple list of gates into + the form needed by the circuit-cutting optimizer code. + + Elements of the list must be of the form: + 'barrier' + ('barrier' ) + ( ... ) + + Qubit names can be any hashable objects. Gate names can also be any + hashable objects, but they must be consistent with the names used by the + optimizer to look up cutting rules for the specified gates. + + The constructor can be supplied with a list of qubit names to force a + preferred ordering in the assignment of numeric qubit IDs to each name. + + Member Variables: + + qubit_names (NameToIDMap) is an object that maps qubit names to + numerical qubit IDs. + + num_qubits (int) is the number of qubits in the input circuit. Qubit IDs + whose values are greater than or equal to num_qubits represent qubits + that were introduced as the result of wire cutting. These qubits are + assigned generated names of the form ('cut', ) in the + qubit_names object, where is the name of the wire/qubit + that was cut to create the new wire/qubit. + + circuit (list) is the internal representation of the circuit, which is + a list of the following form: + + [ ... [, None] ...] + + where the qubit names have been replaced with qubit IDs in the gate + specifications. + + new_circuit (list) is a list of gate specifications that define + the cut circuit. As with circuit, qubit IDs are used to identify + wires/qubits. + + cut_type (list) is a list that assigns cut-type annotations to gates + in new_circuit to indicate which quasiprobability decomposition to + use for the corresponding gate/wire cut. + + new_gate_ID_map (list) is a list that maps the positions of gates + in circuit to their new positions in new_circuit. + + output_wires (list) maps qubit IDs in circuit to the corresponding + output wires of new_circuit so that observables defined for circuit + can be remapped to new_circuit. + + subcircuits (list) is a list of list of wire IDs, where each list of + wire IDs defines a subcircuit. + """ + + def __init__(self, input_circuit, init_qubit_names=[]): + self.qubit_names = NameToIDMap(init_qubit_names) + + self.circuit = list() + self.new_circuit = list() + self.cut_type = list() + + for gate in input_circuit: + self.cut_type.append(None) + if not isinstance(gate, list) and not isinstance(gate, tuple): + self.circuit.append([copy.deepcopy(gate), None]) + self.new_circuit.append(copy.deepcopy(gate)) + + else: + gate_spec = [gate[0]] + [self.qubit_names.getID(x) for x in gate[1:]] + self.circuit.append([copy.deepcopy(gate_spec), None]) + self.new_circuit.append(copy.deepcopy(gate_spec)) + + self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) + self.num_qubits = self.qubit_names.getArraySizeNeeded() + self.output_wires = np.arange(self.num_qubits, dtype=int) + + # Initialize the list of subcircuits assuming no cutting + self.subcircuits = list(list(range(self.num_qubits))) + + # Initialize the graph of strongly connected subcircuits + # assuming LO decompositions (i.e., no communication between + # subcircuits) + self.scc_subcircuits = [(s,) for s in range(len(self.subcircuits))] + self.scc_order = np.zeros( + (len(self.scc_subcircuits), len(self.scc_subcircuits)), dtype=bool + ) + + def getNumQubits(self): + """Return the number of qubits in the input circuit""" + + return self.num_qubits + + def getNumWires(self): + """Return the number of wires/qubits in the cut circuit""" + + return self.qubit_names.getNumItems() + + def getMultiQubitGates(self): + """Extract the multiqubit gates from the circuit and prepends the + index of the gate in the circuits to the gate specification. + + The elements of the resulting list therefore have the form + [ ] + + The and have the forms + described above. + + The is the list index of the corresponding element in + self.circuit + """ + + subcircuit = list() + for k, gate in enumerate(self.circuit): + if isinstance(gate[0], list): + if len(gate[0]) > 2 and gate[0][0] != "barrier": + subcircuit.append([k] + gate) + + return subcircuit + + def insertGateCut(self, gate_ID, cut_type): + """Mark the specified gate as being cut. The cut type can + be "LO", "LOCCWithAncillas", or "LOCCNoAncillas". + """ + + gate_pos = self.new_gate_ID_map[gate_ID] + self.cut_type[gate_pos] = cut_type + + def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): + """Insert a wire cut into the output circuit just prior to the + specified gate on the wire connected to the specified input of + that gate. Gate inputs are numbered starting from 1. The + wire/qubit ID of the source wire to be cut is also provided as + input to allow the wire choice to be verified. The ID of the + (new) destination wire/qubit must also be provided. The cut + type can be "LO", "LOCCWithAncillas", or "LOCCNoAncillas". + """ + + gate_pos = self.new_gate_ID_map[gate_ID] + new_gate_spec = self.new_circuit[gate_pos] + + assert src_wire_ID == new_gate_spec[input_ID], ( + f"Input wire ID {src_wire_ID} does not match " + + f"new_circuit wire ID {new_gate_spec[input_ID]}" + ) + + # If the new wire does not yet exist, then define it + if self.qubit_names.getName(dest_wire_ID) is None: + wire_name = self.qubit_names.getName(src_wire_ID) + self.qubit_names.defineID(dest_wire_ID, ("cut", wire_name)) + + # Replace src_wire_ID with dest_wire_ID in the part of new_circuit that + # follows the wire-cut insertion point + wire_map = np.arange(self.qubit_names.getArraySizeNeeded(), dtype=int) + wire_map[src_wire_ID] = dest_wire_ID + self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) + + # Insert a move operator + self.new_circuit.insert(gate_pos, ["move", src_wire_ID, dest_wire_ID]) + self.cut_type.insert(gate_pos, cut_type) + self.new_gate_ID_map[gate_ID:] += 1 + + # Update the output wires + qubit = self.circuit[gate_ID][0][input_ID] + self.output_wires[qubit] = dest_wire_ID + + def insertParallelWireCut(self, list_of_wire_cuts): + """Insert a parallel LOCC wire cut without ancillas into the circuit. + The list_of_wire_cuts must be a list of wire-cut quadruples of + the form: + [..., (, , , ), ...] + """ + + assert False, "insertParallelWireCut() not yet implemented" + + def defineSubcircuits(self, list_of_list_of_wires): + """Assign subcircuits where each subcircuit is + specified as a list of wire IDs. + """ + + self.subcircuits = list_of_list_of_wires + + def getWireNames(self): + """Return a list of the internal wire names used in the circuit, + which consists of the original qubit names together with additional + names of form ("cut", ) introduced to represent cut wires. + """ + + return list(self.qubit_names.getItems()) + + def exportCutCircuit(self, name_mapping="default"): + """Return a list of gates representing the cut circuit. If None + is provided as the name_mapping, then the original qubit names are + used with additional names of form ("cut", ) introduced as + needed to represent cut wires. If "default" is used as the mapping + then the defaultWireNameMapping() method defines the name mapping. + Otherwise, the name_mapping is assumed to be a dictionary that maps + internal wire names to desired names. + """ + + wire_map = self.makeWireMapping(name_mapping) + out = copy.deepcopy(self.new_circuit) + + self.replaceWireIDs(out, wire_map) + + return out + + def exportOutputWires(self, name_mapping="default"): + """Return a dictionary that maps output qubits in the input circuit + to the corresponding output wires/qubits in the cut circuit. If None + is provided as the name_mapping, then the original qubit names are + used with additional names of form ("cut", ) introduced as + needed to represent cut wires. If "default" is used as the mapping + then the defaultWireNameMapping() method defines the name mapping. + Otherwise, the name_mapping is assumed to be a dictionary that maps + internal wire names to desired names. + """ + + wire_map = self.makeWireMapping(name_mapping) + out = dict() + for in_wire, out_wire in enumerate(self.output_wires): + out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] + + return out + + def exportSubcircuitsAsString(self, name_mapping="default"): + """Return a string that maps qubits/wires in the output circuit + to subcircuits per the Circuit Knitting Toolbox convention. This + method only works with mappings to numeric qubit/wire names, such + as provided by "default" or a custom name_mapping. + """ + + wire_map = self.makeWireMapping(name_mapping) + + out = list(range(self.getNumWires())) + alphabet = string.ascii_uppercase + string.ascii_lowercase + + for k, subcircuit in enumerate(self.subcircuits): + for wire in subcircuit: + out[wire_map[wire]] = alphabet[k] + + return "".join(out) + + def makeWireMapping(self, name_mapping): + """Return a wire-mapping array given an input specification of a + name mapping. If None is provided as the input name_mapping, then + the original qubit names are mapped to themselves. If "default" + is used as the name_mapping, then the defaultWireNameMapping() + method is used to define the name mapping. Otherwise, name_mapping + itself is assumed to be the dictionary to use. + """ + + if name_mapping is None: + name_mapping = dict() + for name in self.getWireNames(): + name_mapping[name] = name + + elif name_mapping == "default": + name_mapping = self.defaultWireNameMapping() + + wire_mapping = [None for x in range(self.qubit_names.getArraySizeNeeded())] + + for k in self.qubit_names.getIDs(): + wire_mapping[k] = name_mapping[self.qubit_names.getName(k)] + + return wire_mapping + + def defaultWireNameMapping(self): + """Return a dictionary that maps wire names in self.qubit_names to + default numeric output qubit names when exporting a cut circuit. Cut + wires are assigned numeric names that are adjacent to the numeric + name of the wire prior to cutting so that Move operators are then + applied against adjacent qubits. + """ + + name_pairs = [(name, self.sortOrder(name)) for name in self.getWireNames()] + + name_pairs.sort(key=lambda x: x[1]) + + name_map = dict() + for k, pair in enumerate(name_pairs): + name_map[pair[0]] = k + + return name_map + + def sortOrder(self, name): + if isinstance(name, tuple): + if name[0] == "cut": + x = self.sortOrder(name[1]) + x_int = int(x) + x_frac = x - x_int + return x_int + 0.5 * x_frac + 0.5 + + return self.qubit_names.getID(name) + + def replaceWireIDs(self, gate_list, wire_map): + """Iterate through a list of gates and replaces wire IDs with the + values defined by the wire_map. + """ + + for gate in gate_list: + for k in range(1, len(gate)): + gate[k] = wire_map[gate[k]] + + +class NameToIDMap: + + """Class used to map hashable items (e.g., qubit names) to natural numbers + (e.g., qubit IDs)""" + + def __init__(self, init_names=[]): + """Allow the name dictionary to be initialized with the names + in init_names in the order the names appear in order to force a + preferred ordering in the assigment of item IDs to those names. + """ + + self.next_ID = 0 + self.item_dict = dict() + self.ID_dict = dict() + + for name in init_names: + self.getID(name) + + def getID(self, item_name): + """Return the numeric ID associated with the specified hashable item. + If the hashable item does not yet appear in the item dictionary, a new + item ID is assigned. + """ + + if not item_name in self.item_dict: + while self.next_ID in self.ID_dict: + self.next_ID += 1 + + self.item_dict[item_name] = self.next_ID + self.ID_dict[self.next_ID] = item_name + self.next_ID += 1 + + return self.item_dict[item_name] + + def defineID(self, item_ID, item_name): + """Assign a spefiic ID number to an item name.""" + + assert not item_ID in self.ID_dict, f"item ID {item_ID} already assigned" + assert ( + not item_name in self.item_dict + ), f"item name {item_name} already assigned" + + self.item_dict[item_name] = item_ID + self.ID_dict[item_ID] = item_name + + def getName(self, item_ID): + """Return the name associated with the specified item ID. + None is returned if item_ID does not (yet) exist. + """ + + if item_ID not in self.ID_dict: + return None + + return self.ID_dict[item_ID] + + def getNumItems(self): + """Return the number of hashable items loaded thus far.""" + + return len(self.item_dict) + + def getArraySizeNeeded(self): + """Return one plus the maximum item ID assigned thus far, + or zero if no items have been assigned. The value returned + is thus the minimum size needed to construct a Python/Numpy + array that maps item IDs to other values. + """ + + if self.getNumItems() <= 0: + return 0 + + return 1 + max(self.ID_dict.keys()) + + def getItems(self): + """Return an iterator over the hashable items loaded thus far.""" + + return self.item_dict.keys() + + def getIDs(self): + """Return an iterator over the hashable items loaded thus far.""" + + return self.ID_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py new file mode 100644 index 000000000..c70f19b4a --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py @@ -0,0 +1,298 @@ +""" File containing the classes required to search for optimal cut locations.""" +import numpy as np +from .utils import selectSearchEngine, greedyBestFirstSearch +from .cutting_actions import disjoint_subcircuit_actions +from .search_space_generator import ( + getActionSubset, + SearchFunctions, + SearchSpaceGenerator, +) +from .disjoint_subcircuits_state import ( + DisjointSubcircuitsState, + PrintActionListWithNames, +) + + +class CutOptimizationFuncArgs: + + """Class for passing relevant arguments to the CutOptimization + search-space generating functions. + """ + + def __init__(self): + self.entangling_gates = None + self.search_actions = None + self.max_gamma = None + self.qpu_width = None + self.greedy_multiplier = None + + +def CutOptimizationCostFunc(state, func_args): + """Return the cost function. The cost function aims to minimize the + gamma bound while giving preference to circuit partionings that balance the + sizes of the resulting partitions. + """ + + return (state.lowerBoundGamma(), state.getMaxWidth()) + + +def CutOptimizationUpperBoundCostFunc(goal_state, func_args): + """Return the gamma upper bound.""" + + return (goal_state.upperBoundGamma(), np.inf) + + +def CutOptimizationMinCostBoundFunc(func_args): + """Return an a priori min-cost bound defined in the optimization settings.""" + + if func_args.max_gamma is None: + return None + + return (func_args.max_gamma, np.inf) + + +def CutOptimizationNextStateFunc(state, func_args): + """Generate a list of next states from the input state.""" + + # Get the entangling gate spec that is to be processed next based + # on the search level of the input state + gate_spec = func_args.entangling_gates[state.getSearchLevel()] + + # Determine which search actions can be performed, taking into + # account any user-specified constraints that might have been + # placed on how the current entangling gate is to be handled + # in the search + if len(gate_spec[1]) <= 3: # change to ==3 + action_list = func_args.search_actions.getGroup("TwoQubitGates") + else: + action_list = func_args.search_actions.getGroup("MultiqubitGates") + + action_list = getActionSubset(action_list, gate_spec[2]) + + # Apply the search actions to generate a list of next states + next_state_list = [] + for action in action_list: + next_state_list.extend(action.nextState(state, gate_spec, func_args.qpu_width)) + + return next_state_list + + +def CutOptimizationGoalStateFunc(state, func_args): + """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy + the device constraints and the optimization settings). + """ + + return state.getSearchLevel() >= len(func_args.entangling_gates) + + +### Global variable that holds the search-space functions for generating +### the cut optimization search space +cut_optimization_search_funcs = SearchFunctions( + cost_func=CutOptimizationCostFunc, + upperbound_cost_func=CutOptimizationUpperBoundCostFunc, + next_state_func=CutOptimizationNextStateFunc, + goal_state_func=CutOptimizationGoalStateFunc, + mincost_bound_func=CutOptimizationMinCostBoundFunc, +) + + +def greedyCutOptimization( + circuit_interface, + optimization_settings, + device_constraints, + search_space_funcs=cut_optimization_search_funcs, + search_actions=disjoint_subcircuit_actions, +): + func_args = CutOptimizationFuncArgs() + func_args.entangling_gates = circuit_interface.getMultiQubitGates() + func_args.search_actions = search_actions + func_args.max_gamma = optimization_settings.getMaxGamma() + func_args.qpu_width = device_constraints.getQPUWidth() + func_args.greedy_multiplier = optimization_settings.getGreedyMultiplier() + + start_state = DisjointSubcircuitsState( + circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) + ) + + return greedyBestFirstSearch(start_state, search_space_funcs, func_args) + + +################################################################################ + + +class CutOptimization: + + """Class that implements cut optimization whereby qubits are not reused + via circuit folding (i.e., when mid-circuit measurement and active + reset are not available). + + CutOptimization focuses on using circuit cutting to create disjoint subcircuits. + It then uses upper and lower bounds on the resulting + gamma in order to decide where and how to cut while deferring the exact + choices of quasiprobability decompositions to Stage Two. + + Member Variables: + + circuit (CircuitInterface) is the interface object for the circuit + to be cut. + + settings (OptimizationSettings) is an object that contains the settings + that control the optimization process. + + constraints (DeviceConstraints) is an object that contains the device + constraints that solutions must obey. + + search_funcs (SearchFunctions) is an object that holds the functions + needed to generate and explore the cut optimization search space. + + func_args (CutOptimizationFuncArgs) is an object that contains the + necessary device constraints and optimization settings parameters that + aree needed by the cut optimization search-space function. + + search_actions (ActionNames) is an object that contains the allowed + actions that are used to generate the search space. + + search_engine (BestFirstSearch) is an object that implements the + search algorithm. + """ + + def __init__( + self, + circuit_interface, + optimization_settings, + device_constraints, + search_engine_config={ + "CutOptimization": SearchSpaceGenerator( + functions=cut_optimization_search_funcs, + actions=disjoint_subcircuit_actions, + ) + }, + ): + """A CutOptimization object must be initialized with + a specification of all of the parameters of the optimization to be + performed: i.e., the circuit to be cut, the optimization settings, + the target-device constraints, the functions for generating the + search space, and the allowed search actions. + """ + + generator = search_engine_config["CutOptimization"] + search_space_funcs = generator.functions + search_space_actions = generator.actions + + # Extract the subset of allowed actions as defined in the settings object + cut_groups = optimization_settings.getCutSearchGroups() + cut_actions = search_space_actions.copy(cut_groups) + + self.circuit = circuit_interface + self.settings = optimization_settings + self.constraints = device_constraints + self.search_funcs = search_space_funcs + self.search_actions = cut_actions + + self.func_args = CutOptimizationFuncArgs() + self.func_args.entangling_gates = self.circuit.getMultiQubitGates() + self.func_args.search_actions = self.search_actions + self.func_args.max_gamma = self.settings.getMaxGamma() + self.func_args.qpu_width = self.constraints.getQPUWidth() + self.func_args.greedy_multiplier = self.settings.getGreedyMultiplier() + + # Perform an initial greedy best-first search to determine an upper + # bound for the optimal gamma + self.greedy_goal_state = greedyCutOptimization( + self.circuit, + self.settings, + self.constraints, + search_space_funcs=self.search_funcs, + search_actions=self.search_actions, + ) + ################################################################################ + + # Use the upper bound for the optimal gamma to determine the maximum + # number of wire cuts that can be performed when allocating the + # data structures in the actual state. + max_wire_cuts = maxWireCutsCircuit(self.circuit) + + if self.greedy_goal_state is not None: + mwc = maxWireCutsGamma(self.greedy_goal_state.upperBoundGamma()) + max_wire_cuts = min(max_wire_cuts, mwc) + + elif self.func_args.max_gamma is not None: + mwc = maxWireCutsGamma(self.func_args.max_gamma) + max_wire_cuts = min(max_wire_cuts, mwc) + + # Push the start state onto the search_engine + start_state = DisjointSubcircuitsState( + self.circuit.getNumQubits(), max_wire_cuts + ) + + sq = selectSearchEngine( + "CutOptimization", + self.settings, + self.search_funcs, + stop_at_first_min=False, + ) + + sq.initialize([start_state], self.func_args) + + # Use the upper bound for the optimal gamma to constrain the search + if self.greedy_goal_state is not None: + sq.updateUpperBoundGoalState(self.greedy_goal_state, self.func_args) + + self.search_engine = sq + self.goal_state_returned = False + + def optimizationPass(self): + """Produce, at each call, a goal state representing a distinct + set of cutting decisions. The first goal state returned corresponds + to cutting decisions that minimize the lower bound on the resulting gamma. + None is returned once no additional choices of cuts can be made without + exceeding the minimum upper bound across all cutting decisions previously + returned and the optimization settings. + """ + + state, cost = self.search_engine.optimizationPass(self.func_args) + + if state is None and not self.goal_state_returned: + state = self.greedy_goal_state + cost = self.search_funcs.cost_func(state, self.func_args) + + self.goal_state_returned = True + + return state, cost + + def minimumReached(self): + """Return True if the optimization reached a global minimum.""" + + return self.search_engine.minimumReached() + + def getStats(self, penultimate=False): + """Return the search-engine statistics.""" + + return self.search_engine.getStats(penultimate=penultimate) + + def getUpperBoundCost(self): + """Return the current upperbound cost.""" + + return self.search_engine.getUpperBoundCost() + + def updateUpperBoundCost(self, cost_bound): + """Update the cost upper bound based on an input cost bound.""" + + self.search_engine.updateUpperBoundCost(cost_bound) + + +def maxWireCutsCircuit(circuit_interface): + """Calculate an upper bound on the maximum number of wire cuts + that can be made given the total number of inputs to multiqubit + gates in the circuit. + """ + + return sum([len(x[1]) - 1 for x in circuit_interface.getMultiQubitGates()]) + + +def maxWireCutsGamma(max_gamma): + """Calculate an upper bound on the maximum number of wire cuts + that can be made given the maximum allowed gamma. + """ + + return int(np.ceil(np.log2(max_gamma + 1) - 1)) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py new file mode 100644 index 000000000..70236c0fd --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py @@ -0,0 +1,849 @@ +""" File containing classes needed to implement the actions involved in circuit cutting.""" +import numpy as np +from abc import ABC, abstractmethod +from .search_space_generator import ActionNames + +### This is an object that holds action names for constructing disjoint subcircuits +disjoint_subcircuit_actions = ActionNames() + + +class DisjointSearchAction(ABC): + + """Base class for search actions for constructing disjoint subcircuits.""" + + @abstractmethod + def getName(self): + """Derived classes must return the look-up name of the action""" + + assert False, "Derived classes must override getName()" + + @abstractmethod + def getGroupNames(self): + """Derived classes must return a list of group names""" + + assert False, "Derived classes must override getGroupNames()" + + @abstractmethod + def nextStatePrimitive(self, state, gate_spec, max_width): + """Derived classes must return a list of search states that + result from applying all variations of the action to gate_spec + in the specified DisjointSubcircuitsState state, subject to the + constraint that the number of resulting qubits (wires) in each + subcircuit cannot exceed max_width""" + + assert False, "Derived classes must override nextState()" + + def nextState(self, state, gate_spec, max_width): + """Return a list of search states that result from applying the + action to gate_spec in the specified DisjointSubcircuitsState + state, subject to the constraint that the number of resulting + qubits (wires) in each subcircuit cannot exceed max_width. + """ + + next_list = self.nextStatePrimitive(state, gate_spec, max_width) + + for next_state in next_list: + next_state.setNextLevel(state) + + return next_list + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Derived classes must register the action in the specified + AssignmentSettings object, where the action was applied to gate_spec + with the action arguments cut_args""" + + assert False, "Derived classes must override registerCut()" + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Derived classes must initialize the action in the specified + AssignmentSettings object, where the action was applied to gate_spec + with the action arguments cut_args. Intialization is performed after + all actions have been registered.""" + + assert False, "Derived classes must override initializeCut()" + + def nextAssignment( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + """Return a list of next assignment states that result from + applying assignment actions to the input assignment state. + """ + + next_list = self.nextAssignmentPrimitive( + assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ) + + for next_state in next_list: + next_state.setNextLevel(assign_state) + + return next_list + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + """Derived classes must retrieve the appropriate group of QPD + assignment actions from assign_actions, and then collect and + return the combined list of next assignment states that result + from applying those actions to the input assignment state, with + the constraint object, gate_spec, and cut_args provided as inputs + to the nextState() methods of those assignment actions.""" + + assert False, "Derived classes must override initializeCut()" + + +class ActionApplyGate(DisjointSearchAction): + + """Action class that implements the action of + applying a two-qubit gate without decomposition""" + + def getName(self): + """Return the look-up name of ActionApplyGate.""" + + return None + + def getGroupNames(self): + """Return the group name of ActionApplyGate.""" + + return [None, "TwoQubitGates", "MultiqubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionApplyGate to state given the two-qubit gate + specification: gate_spec. + """ + + if len(gate_spec[1]) > 3: + # The function multiqubitNextState handles + # gates that act on 3 or more qubits. + return self.multiqubitNextState(state, gate_spec, max_width) + + gate = gate_spec[1] # extract the gate from gate specification. + r1 = state.findQubitRoot(gate[1]) # extract the root wire for the first qubit + # acted on by the given 2-qubit gate. + r2 = state.findQubitRoot(gate[2]) # extract the root wire for the second qubit + # acted on by the given 2-qubit gate. + + # If applying the gate would cause the number of qubits to exceed + # the qubit limit, then do not apply the gate + if r1 != r2 and state.width[r1] + state.width[r2] > max_width: + return list() + + # If the gate cannot be applied because it would violate the + # merge constraints, then do not apply the gate + if state.checkDoNotMergeRoots(r1, r2): + return list() + + new_state = state.copy() + + if r1 != r2: + new_state.mergeRoots(r1, r2) + + new_state.addAction(self, gate_spec) + + return [new_state] + + def multiqubitNextState(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionApplyGate to state given a multiqubit gate specification: gate_spec. + """ + + gate = gate_spec[1] + roots = list(set([state.findQubitRoot(q) for q in gate[1:]])) + new_width = sum([state.width[r] for r in roots]) + + # If applying the gate would cause the number of qubits to exceed + # the qubit limit, then do not apply the gate + if new_width > max_width: + return list() + + new_state = state.copy() + + r0 = roots[0] + for r in roots[1:]: + new_state.mergeRoots(r, r0) + r0 = new_state.findWireRoot(r0) + + # If the gate cannot be applied because it would violate the + # merge constraints, then do not apply the gate + if not new_state.verifyMergeConstraints(): + return list() + + new_state.addAction(self, gate_spec) + + return [new_state] + + +### Adds ActionApplyGate to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionApplyGate()) + + +class ActionCutTwoQubitGate(DisjointSearchAction): + + """Action class that implements the action of + cutting a two-qubit gate. + . + + TODO: The list of supported gates needs to be expanded. + """ + + def __init__(self): + """The values in gate_dict are tuples in (gamma_LB, num_bell_pairs, gamma_UB) format. + lowerBoundGamma is computed from gamma_LB using the DisjointSubcircuitsState.lowerBoundGamma() method. + """ + + self.gate_dict = { + "cx": (1, 1, 3), + "swap": (1, 2, 7), + "iswap": (1, 2, 7), + "crx": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1] / 2)), + 0, + 1 + 2 * np.abs(np.sin(t[1] / 2)), + ) + ), + "cry": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1] / 2)), + 0, + 1 + 2 * np.abs(np.sin(t[1] / 2)), + ) + ), + "crz": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1] / 2)), + 0, + 1 + 2 * np.abs(np.sin(t[1] / 2)), + ) + ), + "rxx": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1])), + 0, + 1 + 2 * np.abs(np.sin(t[1])), + ) + ), + "ryy": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1])), + 0, + 1 + 2 * np.abs(np.sin(t[1])), + ) + ), + "rzz": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[1])), + 0, + 1 + 2 * np.abs(np.sin(t[1])), + ) + ), + } + + def getName(self): + """Return the look-up name of ActionCutTwoQubitGate.""" + + return "CutTwoQubitGate" + + def getGroupNames(self): + """Return the group name of ActionCutTwoQubitGate.""" + + return ["GateCut", "TwoQubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionCutTwoQubitGate to state given the gate_spec. + """ + + # If the gate is not a two-qubit gate, then return the empty list + if len(gate_spec[1]) != 3: + return list() + + gamma_LB, num_bell_pairs, gamma_UB = self.getCostParams(gate_spec) + + if gamma_LB is None: + return list() + + gate = gate_spec[1] + q1 = gate[1] + q2 = gate[2] + w1 = state.getWire(q1) + w2 = state.getWire(q2) + r1 = state.findQubitRoot(q1) + r2 = state.findQubitRoot(q2) + + if r1 == r2: + return list() + + new_state = state.copy() + + new_state.assertDoNotMergeRoots(r1, r2) + + new_state.gamma_LB *= gamma_LB + + for k in range(num_bell_pairs): + new_state.bell_pairs.append((r1, r2)) + + new_state.gamma_UB *= gamma_UB + + new_state.addAction(self, gate_spec, (1, w1), (2, w2)) + + return [new_state] + + def getCostParams(self, gate_spec): + return lookupCostParams(self.gate_dict, gate_spec, (None, None, None)) + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Register the gate cuts made by a ActionCutTwoQubitGate action + in an AssignmentSettings object. + """ + + assignment_settings.registerGateCut(gate_spec, cut_args[0][0]) + assignment_settings.registerGateCut(gate_spec, cut_args[1][0]) + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Initialize the gate cuts made by a ActionCutTwoQubitGate action + in an AssignmentSettings object. + """ + + assignment_settings.initGateCut(gate_spec, cut_args[0][0]) + assignment_settings.initGateCut(gate_spec, cut_args[1][0]) + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + action_list = assign_actions.getGroup("TwoQubitGateCut") + + new_list = list() + for action in action_list: + new_list.extend( + action.nextState(assign_state, constraint_obj, gate_spec, cut_args) + ) + + return new_list + + def exportCuts(self, circuit_interface, wire_map, gate_spec, args): + """Insert an LO gate cut into the input circuit for the specified gate + and cut arguments. + """ + + circuit_interface.insertGateCut(gate_spec[0], "LO") + + +### Adds ActionCutTwoQubitGate to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionCutTwoQubitGate()) + + +def lookupCostParams(gate_dict, gate_spec, default_value): + gate_name = gate_spec[1][0] + + if gate_name in gate_dict: + return gate_dict[gate_name] + + elif isinstance(gate_name, tuple) or isinstance(gate_name, list): + if gate_name[0] in gate_dict: + return gate_dict[gate_name[0]](gate_name) + + return default_value + + +class ActionCutLeftWire(DisjointSearchAction): + + """Action class that implements the action of + cutting the left (first) wire of a two-qubit gate""" + + def getName(self): + """Return the look-up name of ActionCutLeftWire.""" + + return "CutLeftWire" + + def getGroupNames(self): + """Return the group name of ActionCutLeftWire.""" + + return ["WireCut", "TwoQubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionCutLeftWire to state given the gate_spec. + """ + + # If the gate is not a two-qubit gate, then return the empty list + if len(gate_spec[1]) != 3: + return list() + + # If the wire-cut limit would be exceeded, return the empty list + if not state.canAddWires(1): + return list() + + gate = gate_spec[1] + q1 = gate[1] + q2 = gate[2] + w1 = state.getWire(q1) + w2 = state.getWire(q2) + r1 = state.findQubitRoot(q1) + r2 = state.findQubitRoot(q2) + + if r1 == r2: + return list() + + if not state.canExpandSubcircuit(r2, 1, max_width): + return list() + + new_state = state.copy() + + rnew = new_state.newWire(q1) + new_state.mergeRoots(rnew, r2) + new_state.assertDoNotMergeRoots(r1, r2) # Because r2 < rnew + + new_state.bell_pairs.append((r1, r2)) + new_state.gamma_UB *= 4 + + new_state.addAction(self, gate_spec, (1, w1, rnew)) + + return [new_state] + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Register the wire cuts made by a ActionCutLeftWire action + in an AssignmentSettings object. + """ + + registerAllWireCuts(assignment_settings, gate_spec, cut_args) + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Initialize the wire cuts made by a ActionCutLeftWire action + in an AssignmentSettings object. + """ + + for gate_input in [pair[0] for pair in cut_args]: + assignment_settings.initWireCut(gate_spec, gate_input) + + assignment_settings.initApplyGate(gate_spec) + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + action_list = assign_actions.getGroup("WireCut") + + return assignWireCuts( + action_list, assign_state, constraint_obj, gate_spec, cut_args + ) + + def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + """Insert an LO wire cut into the input circuit for the specified + gate and cut arguments. + """ + + insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + + +### Adds ActionCutLeftWire to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) + + +def registerAllWireCuts(assignment_settings, gate_spec, cut_args): + """Register a list of wire cuts in an AssignmentSettings object.""" + + for cut_triple in cut_args: + assignment_settings.registerWireCut(gate_spec, cut_triple) + + +def assignWireCuts(action_list, assign_state, constraint_obj, gate_spec, tuple_list): + if len(tuple_list) <= 0: + return [ + assign_state, + ] + + wire_cut = tuple_list[0] + new_states = list() + for action in action_list: + new_states.extend( + action.nextState(assign_state, constraint_obj, gate_spec, wire_cut) + ) + + final_states = list() + for state in new_states: + final_states.extend( + assignWireCuts( + action_list, state, constraint_obj, gate_spec, tuple_list[1:] + ) + ) + + return final_states + + +def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): + """Insert LO wire cuts into the input circuit for the specified + gate and all cut arguments. + """ + + gate_ID = gate_spec[0] + for input_ID, wire_ID, new_wire_ID in cut_args: + circuit_interface.insertWireCut( + gate_ID, input_ID, wire_map[wire_ID], wire_map[new_wire_ID], "LO" + ) + + +class ActionCutRightWire(DisjointSearchAction): + + """Action class that implements the action of + cutting the right (second) wire of a two-qubit gate""" + + def getName(self): + """Return the look-up name of ActionCutRightWire.""" + + return "CutRightWire" + + def getGroupNames(self): + """Return the group name of ActionCutRightWire.""" + + return ["WireCut", "TwoQubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionCutRightWire to state given the gate_spec. + """ + + # If the gate is not a two-qubit gate, then return the empty list + if len(gate_spec[1]) != 3: + return list() + + # If the wire-cut limit would be exceeded, return the empty list + if not state.canAddWires(1): + return list() + + gate = gate_spec[1] + q1 = gate[1] + q2 = gate[2] + w1 = state.getWire(q1) + w2 = state.getWire(q2) + r1 = state.findQubitRoot(q1) + r2 = state.findQubitRoot(q2) + + if r1 == r2: + return list() + + if not state.canExpandSubcircuit(r1, 1, max_width): + return list() + + new_state = state.copy() + + rnew = new_state.newWire(q2) + new_state.mergeRoots(r1, rnew) + new_state.assertDoNotMergeRoots(r1, r2) # Because r1 < rnew + + new_state.bell_pairs.append((r1, r2)) + new_state.gamma_UB *= 4 + + new_state.addAction(self, gate_spec, (2, w2, rnew)) + + return [new_state] + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Register the wire cuts made by a ActionCutRightWire action + in an AssignmentSettings object. + """ + + registerAllWireCuts(assignment_settings, gate_spec, cut_args) + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Initialize the wire cuts made by a ActionCutRightWire action + in an AssignmentSettings object. + """ + + for gate_input in [pair[0] for pair in cut_args]: + assignment_settings.initWireCut(gate_spec, gate_input) + + assignment_settings.initApplyGate(gate_spec) + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + action_list = assign_actions.getGroup("WireCut") + + return assignWireCuts( + action_list, assign_state, constraint_obj, gate_spec, cut_args + ) + + def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + """Insert an LO wire cut into the input circuit for the specified + gate and cut arguments. + """ + + insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + + +### Adds ActionCutRightWire to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionCutRightWire()) + + +class ActionCutBothWires(DisjointSearchAction): + + """Action class that implements the action of + cutting both wires of a two-qubit gate""" + + def getName(self): + """Return the look-up name of ActionCutBothWires.""" + + return "CutBothWires" + + def getGroupNames(self): + """Return the group name of ActionCutBothWires.""" + + return ["WireCut", "TwoQubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionCutBothWires to state given the gate_spec. + """ + + # If the gate is not a two-qubit gate, then return the empty list + if len(gate_spec[1]) != 3: + return list() + + # If the wire-cut limit would be exceeded, return the empty list + if not state.canAddWires(2): + return list() + + # If the maximum width is less than two, return the empty list + if max_width < 2: + return list() + + gate = gate_spec[1] + q1 = gate[1] + q2 = gate[2] + w1 = state.getWire(q1) + w2 = state.getWire(q2) + r1 = state.findQubitRoot(q1) + r2 = state.findQubitRoot(q2) + + new_state = state.copy() + + rnew_1 = new_state.newWire(q1) + rnew_2 = new_state.newWire(q2) + new_state.mergeRoots(rnew_1, rnew_2) + new_state.assertDoNotMergeRoots(r1, rnew_1) # Because r1 < rnew_1 + new_state.assertDoNotMergeRoots(r2, rnew_2) # Because r2 < rnew_2 + + new_state.bell_pairs.append((r1, rnew_1)) + new_state.bell_pairs.append((r2, rnew_2)) + new_state.gamma_UB *= 16 + + new_state.addAction(self, gate_spec, (1, w1, rnew_1), (2, w2, rnew_2)) + + return [new_state] + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Register the wire cuts made by a ActionCutBothWires action + in an AssignmentSettings object. + """ + + registerAllWireCuts(assignment_settings, gate_spec, cut_args) + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Initialize the wire cuts made by a ActionCutBothWires action + in an AssignmentSettings object. + """ + + for gate_input in [pair[0] for pair in cut_args]: + assignment_settings.initWireCut(gate_spec, gate_input) + + assignment_settings.initApplyGate(gate_spec) + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + action_list = assign_actions.getGroup("WireCut") + + return assignWireCuts( + action_list, assign_state, constraint_obj, gate_spec, cut_args + ) + + def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + """Insert an LO wire cut into the input circuit for the specified + gate and cut arguments. + """ + + insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + + +### Adds ActionCutBothWires to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionCutBothWires()) + + +class ActionMultiWireCut(DisjointSearchAction): + + """Action class that implements search over wire cuts + for gates (protected subcircuits) with more that two inputs""" + + def getName(self): + """Return the look-up name of ActionMultiWireCut.""" + + return "MultiWireCut" + + def getGroupNames(self): + """Return the group name of ActionMultiWireCut.""" + + return ["WireCut", "MultiqubitGates"] + + def nextStatePrimitive(self, state, gate_spec, max_width): + """Return the new state that results from applying + ActionMultiWireCut to state given the gate_spec. + """ + + gate = gate_spec[1] + + # If the gate is applied to two or fewer qubits, return the empty list + if len(gate) <= 3: + return list() + + input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate[1:])] + subcircuits = list(set([pair[1] for pair in input_pairs])) + + return self.nextStateRecurse( + state, gate_spec, max_width, input_pairs, subcircuits + ) + + def nextStateRecurse( + self, state, gate_spec, max_width, input_pairs, subcircuits, cuts=[], merges=[] + ): + """Recursive implementation of nextState()""" + + # If the limit on the total number of wire cuts would + # be exceeded, then return the empty list + if not state.canAddWires(len(cuts)): + return list() + + # Base case of the recursion + if len(subcircuits) <= 0: + # If there are no wire cuts, then return the empty list + if len(cuts) <= 0: + return list() + + # Case: all wires are cut + elif len(merges) <= 0: + new_state = state.copy() + + gate = gate_spec[1] + r0 = None + + cut_triples = self.addCutsToNewState(new_state, gate, cuts, r0) + + new_state.addAction(self, gate_spec, *cut_triples) + + return [new_state] + + # Case: at least one wire is not cut + else: + new_width = len(cuts) + sum([state.width[r] for r in merges]) + + # If applying the gate would cause the number of qubits to + # exceed the qubit limit even with the wire cuts, then + # return the empty list + if new_width > max_width: + return list() + + new_state = state.copy() + + r0 = merges[0] + for r in merges[1:]: + new_state.mergeRoots(r0, r) + + # If the gate cannot be applied because it would violate the + # merge constraints, then do not apply the gate + if not new_state.verifyMergeConstraints(): + return list() + + gate = gate_spec[1] + r0 = new_state.findWireRoot(r0) + + cut_triples = self.addCutsToNewState(new_state, gate, cuts, r0) + + new_state.addAction(self, gate_spec, *cut_triples) + + return [new_state] + + # Recursive step + else: + root = subcircuits[0] + + # Case A: all input wires from subcircuit root are cut + new_cuts = [pair for pair in input_pairs if (pair[1] == root)] + + cut_case = self.nextStateRecurse( + state, + gate_spec, + max_width, + input_pairs, + subcircuits[1:], + cuts + new_cuts, + merges, + ) + + # Case B: all input wires from subcircuit root are left uncut + uncut_case = self.nextStateRecurse( + state, + gate_spec, + max_width, + input_pairs, + subcircuits[1:], + cuts, + merges + [root], + ) + + return cut_case + uncut_case + + def addCutsToNewState(self, new_state, gate, cuts, downstream_root): + """Updates the new_state to incorporate a list of wire cuts""" + + cut_triples = list() + + for i, root in cuts: + qubit = gate[i] + wire = new_state.getWire(qubit) + rnew = new_state.newWire(qubit) + cut_triples.append((i, wire, rnew)) + if downstream_root is None: + downstream_root = rnew + else: + new_state.mergeRoots(rnew, downstream_root) + new_state.assertDoNotMergeRoots(root, downstream_root) + new_state.bell_pairs.append((root, downstream_root)) + new_state.gamma_UB *= 4 + + return cut_triples + + def registerCut(self, assignment_settings, gate_spec, cut_args): + """Register the wire cuts made by a ActionMultiWireCut action + in an AssignmentSettings object. + """ + + registerAllWireCuts(assignment_settings, gate_spec, cut_args) + + def initializeCut(self, assignment_settings, gate_spec, cut_args): + """Initialize the wire cuts made by a ActionMultiWireCut action + in an AssignmentSettings object. + """ + + for gate_input in [pair[0] for pair in cut_args]: + assignment_settings.initWireCut(gate_spec, gate_input) + + assignment_settings.initApplyGate(gate_spec) + + def nextAssignmentPrimitive( + self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions + ): + action_list = assign_actions.getGroup("WireCut") + + return assignWireCuts( + action_list, assign_state, constraint_obj, gate_spec, cut_args + ) + + def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + """Insert an LO wire cut into the input circuit for the specified + gate and cut arguments. + """ + + insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + + +### Adds ActionMultiWireCut to the object disjoint_subcircuit_actions +disjoint_subcircuit_actions.defineAction(ActionMultiWireCut()) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py new file mode 100644 index 000000000..29517eaf2 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py @@ -0,0 +1,487 @@ +"""File containing the class needed for representing search-space states when cutting circuits.""" +import copy +import numpy as np +from collections import Counter, namedtuple + + +class DisjointSubcircuitsState: + + """Class for representing search-space states when cutting + circuits to construct disjoint subcircuits. Only minimally + sufficient information is stored in order to minimize the + memory footprint. + + Each wire cut introduces a new wire. A mapping from qubit IDs + in QASM-like statements to wire IDs is therefore created + and maintained. Groups of wires form subcircuits, and these + subcircuits can then be merged via search actions. The mapping + from wires to subcircuits is represented using an up-tree data + structure over wires. The number of wires (width) in each + subcircuit is also tracked to ensure subcircuits will fit on + target quantum devices. + + Member Variables: + + wiremap (int Numpy array) provides the mapping from qubit IDs + to wire IDs. + + num_wires (int) is the number of wires in the cut circuit. + + uptree (int Numpy array) contains the uptree data structure that + defines groups of wires that form subcircuits. The uptree array + map wire IDs to parent wire IDs in a subcircuit. If a wire points + to itself, then that wire is the root wire in the corresponding + subcircuit. Otherwise, you need to follow the parent links to find + the root wire that corresponds to that subcircuit. + + width (int Numpy array) contains the number of wires in each + subcircuit. The values of width are valid only for root wire IDs. + + bell_pairs (list) is a list of pairs of subcircuits (wires) that + define the virtual Bell pairs that would need to be constructed in + order to implement optimal LOCC wire and gate cuts using ancillas. + + gamma_LB (float) is the cumulative lower-bound gamma for circuit cuts + that cannot be constructed using Bell pairs, such as LO gate cuts + for small-angled rotations. + + gamma_UB (float) is the cumulative upper-bound gamma for all circuit + cuts assuming all cuts are LO. + + no_merge (list) contains a list of subcircuit merging constaints. + Each constraint can either be a pair of wire IDs or a list of pairs + of wire IDs. In the case of a pair of wire IDs, the constraint is + that the subcircuits that contain those wire IDs cannot be merged + by subsequent search actions. In the case of a list of pairs of + wire IDs, the constraint is that at least one pair of corresponding + subcircuits cannot be merged. + + actions (list) contains a list of circuit-cutting actions that have + been performed on the circuit. Elements of the list have the form + + [, , (, ..., )] + + The is the object that was used to generate the + circuit cut. The is the specification of the + cut gate using the format defined in the CircuitInterface class + description. The trailing entries are the arguments needed by the + to apply further search-space generating objects + in Stage Two in order to explore the space of QPD assignments to + the circuit-cutting action. + + level (int) is the level in the search tree at which this search + state resides, with 0 being the root of the search tree. + """ + + def __init__(self, num_qubits=None, max_wire_cuts=None): + """A DisjointSubcircuitsState object must be initialized with + a specification of the number of qubits in the circuit and the + maximum number of wire cuts that can be performed.""" + + if not ( + num_qubits is None or (isinstance(num_qubits, int) and num_qubits >= 0) + ): + raise ValueError("num_qubits must be either be None or a positive integer.") + + if not ( + max_wire_cuts is None + or (isinstance(max_wire_cuts, int) and max_wire_cuts >= 0) + ): + raise ValueError( + "max_wire_cuts must be either be None or a positive integer." + ) + + if num_qubits is None or max_wire_cuts is None: + self.wiremap = None + self.num_wires = None + + self.uptree = None + self.width = None + + self.bell_pairs = None + self.gamma_LB = None + self.gamma_UB = None + + self.no_merge = None + self.actions = None + self.level = None + + else: + max_wires = num_qubits + max_wire_cuts + + self.wiremap = np.arange(num_qubits) + self.num_wires = num_qubits + + self.uptree = np.arange(max_wires) + self.width = np.ones(max_wires, dtype=int) + + self.bell_pairs = list() + self.gamma_LB = 1.0 + self.gamma_UB = 1.0 + + self.no_merge = list() + self.actions = list() + self.level = 0 + + def __copy__(self): + new_state = DisjointSubcircuitsState() + + new_state.wiremap = self.wiremap.copy() + new_state.num_wires = self.num_wires + + new_state.uptree = self.uptree.copy() + new_state.width = self.width.copy() + + new_state.bell_pairs = self.bell_pairs.copy() + new_state.gamma_LB = self.gamma_LB + new_state.gamma_UB = self.gamma_UB + + new_state.no_merge = self.no_merge.copy() + new_state.actions = self.actions.copy() + new_state.level = None + + return new_state + + def copy(self): + """Make shallow copy.""" + + return copy.copy(self) + + def print(self, simple=False): + """Print the various properties of a DisjointSubcircuitState.""" + + # cut_actions = PrintActionListWithNames(self.actions) + # cut_actions_sublist = [] + # Cut = namedtuple("Cut", ["Action", "Gate"]) + + # for i in range(len(cut_actions)): + # if cut_actions[i][0] == "CutTwoQubitGate": + # cut_actions_sublist.append( + # Cut( + # Action=cut_actions[i][0], + # Gate=[cut_actions[i][1][0], cut_actions[i][1][1]], + # ) + # ) + + cut_actions = PrintActionListWithNames(self.actions) + cut_actions_sublist = [] + + # Output formatting for LO gate and wire cuts. + # Temporary and needs to be updated later on. + + for i in range(len(cut_actions)): + if cut_actions[i][0] == ("CutLeftWire" or "CutRightWire"): + cut_actions_sublist.append( + { + "Cut action": cut_actions[i][0], + "Cut location:": { + "Gate": [cut_actions[i][1][0], cut_actions[i][1][1]] + }, + "Input wire": cut_actions[i][2][0][0], + } + ) + elif cut_actions[i][0] == "CutTwoQubitGate": + cut_actions_sublist.append( + { + "Cut action": cut_actions[i][0], + "Cut Gate": [cut_actions[i][1][0], cut_actions[i][1][1]], + } + ) + + if simple: # print only a subset of properties. + # print(self.lowerBoundGamma(), self.gamma_UB, self.getMaxWidth()) + # print(debugActionListWithNames(self.actions)) + # print(self.no_merge) + print(cut_actions_sublist) + else: + print("wiremap", self.wiremap) + print("num_wires", self.num_wires) + print("uptree", self.uptree) + print("width", self.width) + print("bell_pairs", self.bell_pairs) + print("gamma_LB", self.gamma_LB) + print("lowerBound", self.lowerBoundGamma()) + print("gamma_UB", self.gamma_UB) + print("no_merge", self.no_merge) + print("actions", PrintActionListWithNames(self.actions)) + print("level", self.level) + + def getNumQubits(self): + """Return the number of qubits in the circuit.""" + + if not (self.wiremap is None): + return self.wiremap.shape[0] + + def getMaxWidth(self): + """Return the maximum width across subcircuits.""" + + if not (self.width is None): + return np.amax(self.width) + + def getSubCircuitIndices(self): + """Return a list of root indices for the subcircuits in + the current cut circuit. + """ + + if not (self.uptree is None): + return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] + + def getWireRootMapping(self): + """Return a list of root wires for each wire in + the current cut circuit. + """ + + return [self.findWireRoot(i) for i in range(self.num_wires)] + + def findRootBellPair(self, bell_pair): + """Find the root wires for a Bell pair (represented as a pair + of wires) and returns a sorted tuple representing the Bell pair. + """ + + r0 = self.findWireRoot(bell_pair[0]) + r1 = self.findWireRoot(bell_pair[1]) + return (r0, r1) if (r0 < r1) else (r1, r0) + + def lowerBoundGamma(self): + """Calculate a lower bound for gamma using the current + counts for the different types of circuit cuts. + """ + + root_bell_pairs = map(lambda x: self.findRootBellPair(x), self.bell_pairs) + + return self.gamma_LB * calcRootBellPairsGamma(root_bell_pairs) + + def upperBoundGamma(self): + """Calculate an upper bound for gamma using the current + counts for the different types of circuit cuts. + """ + + return self.gamma_UB + + def canAddWires(self, num_wires): + """Return True if an additional num_wires can be cut + without exceeding the maximum allowed number of wire cuts. + """ + + return self.num_wires + num_wires <= self.uptree.shape[0] + + def canExpandSubcircuit(self, root, num_wires, max_width): + """Return True if num_wires can be added to subcircuit root + without exceeding the maximum allowed number of qubits. + """ + + return self.width[root] + num_wires <= max_width + + def newWire(self, qubit): + """Cut the wire associated with qubit and returns + the ID of the new wire now associated with qubit. + """ + + assert self.num_wires < self.uptree.shape[0], ( + "Max new wires exceeded " + f"{self.num_wires}, {self.uptree.shape[0]}" + ) + + self.wiremap[qubit] = self.num_wires + self.num_wires += 1 + + return self.wiremap[qubit] + + def getWire(self, qubit): + """Return the ID of the wire currently associated with qubit.""" + + return self.wiremap[qubit] + + def findWireRoot(self, wire): + """Return the ID of the root wire in the subcircuit + that contains wire and collapses the path to the root. + """ + + # Find the root wire in the subcircuit + root = wire + while root != self.uptree[root]: + root = self.uptree[root] + + # Collapse the path to the root + while wire != root: + parent = self.uptree[wire] + self.uptree[wire] = root + wire = parent + + return root + + def findQubitRoot(self, qubit): + """Return the ID of the root wire in the subcircuit currently + associated with qubit and collapses the path to the root. + """ + + return self.findWireRoot(self.wiremap[qubit]) + + def checkDoNotMergeRoots(self, root_1, root_2): + """Return True if the subcircuits represented by + root wire IDs root_1 and root_2 should not be merged. + """ + + assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( + f"Arguments must be roots: " + + f"{root_1} != {self.uptree[root_1]} " + + f"or {root_2} != {self.uptree[root_2]}" + ) + + for clause in self.no_merge: + if isinstance(clause[0], tuple) or isinstance(clause[0], list): + constraint = False + for pair in clause: + r1 = self.findWireRoot(pair[0]) + r2 = self.findWireRoot(pair[1]) + if r1 != r2 and not ( + (r1 == root_1 and r2 == root_2) + or (r1 == root_2 and r2 == root_1) + ): + constraint = True + break + if not constraint: + return True + + else: + r1 = self.findWireRoot(clause[0]) + r2 = self.findWireRoot(clause[1]) + + assert r1 != r2, "Do-Not-Merge clauses must not be identical" + + if (r1 == root_1 and r2 == root_2) or (r1 == root_2 and r2 == root_1): + return True + + return False + + def verifyMergeConstraints(self): + """Return True if all merge constraints are satisfied.""" + + for clause in self.no_merge: + if isinstance(clause[0], tuple) or isinstance(clause[0], list): + constraint = False + for pair in clause: + r1 = self.findWireRoot(pair[0]) + r2 = self.findWireRoot(pair[1]) + if r1 != r2: + constraint = True + break + if not constraint: + return False + + else: + r1 = self.findWireRoot(clause[0]) + r2 = self.findWireRoot(clause[1]) + if r1 == r2: + return False + + return True + + def assertDoNotMergeRoots(self, wire_1, wire_2): + """Add a constraint that the subcircuits associated + with wires IDs wire_1 and wire_2 should not be merged. + """ + + assert self.findWireRoot(wire_1) != self.findWireRoot( + wire_2 + ), f"{wire_1} cannot be the same subcircuit as {wire_2}" + + self.no_merge.append((wire_1, wire_2)) + + def assertDoNotMergeRootPairs(self, pair_list): + """Add a constraint that at least one of the pairs of + subcircuits defined in pair_list should not be merged. + """ + + self.no_merge.append(pair_list) + + def mergeRoots(self, root_1, root_2): + """Merge the subcircuits associated with root wire IDs root_1 + and root_2, and updates the statistics (i.e., width) + associated with the newly merged subcircuit. + """ + + assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( + f"Arguments must be roots: " + + f"{root_1} != {self.uptree[root_1]} " + + f"or {root_2} != {self.uptree[root_2]}" + ) + + assert root_1 != root_2, f"Cannot merge root {root_1} with itself" + + merged_root = min(root_1, root_2) + other_root = max(root_1, root_2) + self.uptree[other_root] = merged_root + self.width[merged_root] += self.width[other_root] + + def addAction(self, action_obj, gate_spec, *args): + """Append the specified action to the list of search-space + actions that have been performed. + """ + + if action_obj.getName() is not None: + self.actions.append([action_obj, gate_spec, args]) + + def getSearchLevel(self): + """Return the search level.""" + + return self.level + + def setNextLevel(self, state): + """Set the search level of self to one plus the search + level of the input state. + """ + + self.level = state.level + 1 + + def exportCuts(self, circuit_interface): + """Export LO cuts into the input circuit_interface for each of + the cutting decisions made. + """ + + # This wire map assumes no reuse of measured qubits that + # result from wire cuts + wire_map = np.arange(self.num_wires) + + for action, gate_spec, cut_args in self.actions: + action.exportCuts(circuit_interface, wire_map, gate_spec, cut_args) + + root_list = self.getSubCircuitIndices() + wires_to_roots = self.getWireRootMapping() + + subcircuits = [ + list({wire_map[w] for w, r in enumerate(wires_to_roots) if r == root}) + for root in root_list + ] + + circuit_interface.defineSubcircuits(subcircuits) + + scc_subcircuits = [(s,) for s in range(len(subcircuits))] + scc_order = np.zeros((len(scc_subcircuits), len(scc_subcircuits)), dtype=bool) + + + +def calcRootBellPairsGamma(root_bell_pairs): + """Calculate the minimum-achievable LOCC gamma for circuit + cuts that utilize virtual Bell pairs. The input can be a list + or iterator over hashable identifiers that represent Bell pairs + across disconnected subcircuits in a cut circuit. There must be + a one-to-one mapping between identifiers and pairs of subcircuits. + Repeated identifiers are interpreted as mutiple Bell pairs across + the same pair of subcircuits, and the counts of such repeats are + used to calculate gamma. + """ + + gamma = 1.0 + for n in Counter(root_bell_pairs).values(): + gamma *= 2 ** (n + 1) - 1 + + return gamma + + +def PrintActionListWithNames(action_list): + """Replace the action objects that appear in action lists + in DisjointSubcircuitsState objects with the corresponding + action names for readability and print. + """ + + return [[x[0].getName()] + x[1:] for x in action_list] diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py new file mode 100644 index 000000000..39a5fd645 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py @@ -0,0 +1,173 @@ +"""File containing the wrapper class for optimizing LO gate and wire cuts.""" +from itertools import count +from .cut_optimization import CutOptimization +from .cut_optimization import disjoint_subcircuit_actions +from .cut_optimization import CutOptimizationNextStateFunc +from .cut_optimization import CutOptimizationGoalStateFunc +from .cut_optimization import CutOptimizationMinCostBoundFunc +from .cut_optimization import CutOptimizationUpperBoundCostFunc +from .search_space_generator import SearchFunctions, SearchSpaceGenerator + + +### Functions for generating the cut optimization search space +cut_optimization_search_funcs = SearchFunctions( + cost_func=CutOptimizationUpperBoundCostFunc, # Change to CutOptimizationCostFunc with LOCC + # or after the new LO QPD's are incorporated into CKT. + upperbound_cost_func=CutOptimizationUpperBoundCostFunc, + next_state_func=CutOptimizationNextStateFunc, + goal_state_func=CutOptimizationGoalStateFunc, + mincost_bound_func=CutOptimizationMinCostBoundFunc, +) + + +class LOCutsOptimizer: + + """Wrapper class for optimizing circuit cuts for the case in which + only LO quasiprobability decompositions are employed. + + The search_engine_config dictionary that configures the optimization + algorithms must be specified in the constructor. For flexibility, the + circuit_interface, optimization_settings, and device_constraints can + be specified either in the constructor or in the optimize() method. In + the latter case, the values provided overwrite the previous values. + + The circuit_interface object that is passed to the optimize() + method is updated to reflect the optimized circuit cuts that were + identified. + + Member Variables: + + circuit_interface (CircuitInterface) defines the circuit to be cut. + + optimization_settings (OptimizationSettings) defines the settings + to be used for the optimization. + + device_constraints (DeviceConstraints) defines the capabilties of + the target quantum hardware. + + search_engine_config (dict) maps names of stages of optimization to + the corresponding SearchSpaceGenerator functions and actions that + are used to perform the search for each stage. + + cut_optimization (CutOptimization) is the object created to + perform the circuit cutting optimization. + + best_result (DisjointSubcircuitsState) is the lowest-cost + DisjointSubcircuitsState object identified in the search. + """ + + def __init__( + self, + circuit_interface=None, + optimization_settings=None, + device_constraints=None, + search_engine_config={ + "CutOptimization": SearchSpaceGenerator( + functions=cut_optimization_search_funcs, + actions=disjoint_subcircuit_actions, + ) + }, + ): + self.circuit_interface = circuit_interface + self.optimization_settings = optimization_settings + self.device_constraints = device_constraints + self.search_engine_config = search_engine_config + + self.cut_optimization = None + self.best_result = None + + def optimize( + self, + circuit_interface=None, + optimization_settings=None, + device_constraints=None, + ): + """Method to optimize the cutting of a circuit. + + Input Arguments: + + circuit_interface (CircuitInterface) defines the circuit to be + cut. This object is then updated with the optimized cuts that + were identified. + + optimization_settings (OptimizationSettings) defines the settings + to be used for the optimization. + + device_constraints (DeviceConstraints) defines the capabilties of + the target quantum hardware. + + Returns: + + The lowest-cost DisjointSubcircuitsState object identified in + the search, or None if no solution could be found. In the + case of the former, the circuit_interface object is also + updated as a side effect to incorporate the cuts found. + """ + + if circuit_interface is not None: + self.circuit_interface = circuit_interface + + if optimization_settings is not None: + self.optimization_settings = optimization_settings + + if device_constraints is not None: + self.device_constraints = device_constraints + + assert self.circuit_interface is not None, "circuit_interface cannot be None" + + assert ( + self.optimization_settings is not None + ), "optimization_settings cannot be None" + + assert self.device_constraints is not None, "device_constraints cannot be None" + + # Perform cut optimization assuming no qubit reuse + self.cut_optimization = CutOptimization( + self.circuit_interface, + self.optimization_settings, + self.device_constraints, + search_engine_config=self.search_engine_config, + ) + + out_1 = list() + + while True: + state, cost = self.cut_optimization.optimizationPass() + if state is None: + break + out_1.append((cost, state)) + + min_cost = min(out_1, key=lambda x: x[0], default=None) + + if min_cost is not None: + self.best_result = min_cost[-1] + self.best_result.exportCuts(self.circuit_interface) + else: + self.best_result = None + + return self.best_result + + def getResults(self): + """Return the optimization results.""" + + return self.best_result + + def getStats(self, penultimate=False): + """Return the optimization results.""" + + return { + "CutOptimization": self.cut_optimization.getStats(penultimate=penultimate) + } + + def minimumReached(self): + """Return a Boolean flag indicating whether the global + minimum was reached. + """ + + return self.cut_optimization.minimumReached() + + +def printStateList(state_list): + for x in state_list: + print() + x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py new file mode 100644 index 000000000..3a6d3c89a --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py @@ -0,0 +1,179 @@ +"""File containing class for specifying parameters that control the optimization.""" + + +class OptimizationSettings: + + """Class for specifying parameters that control the optimization. + + Member Variables: + + max_gamma (int) is a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered feasible. + All other potential solutions are discarded. + + engine_selections (dict) is a dictionary that defines the selections + of search engines for the various stages of optimization. In this release + only "BestFirst" or Dijkstra's best-first search is supported. In future + relesases the choices "Greedy" and "BeamSearch", which correspond respectively + to bounded-greedy and best-first search and beam search will be added. + + max_backjumps (int) is a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. This constraint + does not apply to beam search. + + beam_width (int) is the beam width used in the optimization. Only the B + best partial solutions are maintained at each level in the search, where B + is the beam width. This constraint only applies to beam search algorithms. + + greedy_multiplier (float) is a multiplier used to compute cost bounds + for bounded-greedy best-first search. + + rand_seed (int) is a seed used to provide a repeatable initialization + of the pesudorandom number generators used by the optimization, which + is useful for debugging purposes. If None is used as the random seed, + then a seed is obtained using an operating-system call to achieve an + unrepeatable randomized initialization, which is useful in practice. + + gate_cut_LO (bool) is a flag that indicates that LO gate cuts should be + included in the optimization. + + gate_cut_LOCC_with_ancillas (bool) is a flag that indicates that + LOCC gate cuts with ancillas should be included in the optimization. + + gate_cut_LOCC_no_ancillas (bool) is a flag that indicates that + LOCC gate cuts with no ancillas should be included in the optimization. + + wire_cut_LO (bool) is a flag that indicates that LO wire cuts should be + included in the optimization. + + wire_cut_LOCC_with_ancillas (bool) is a flag that indicates that + LOCC wire cuts with ancillas should be included in the optimization. + + wire_cut_LOCC_no_ancillas (bool) is a flag that indicates that + LOCC wire cuts with no ancillas should be included in the optimization. + + Raises: + + ValueError: max_gamma must be a positive definite integer. + ValueError: max_backjumps must be a positive semi-definite integer. + ValueError: beam_width must be a positive definite integer. + """ + + def __init__( + self, + max_gamma=1024, + max_backjumps=10000, + greedy_multiplier=None, + beam_width=30, + rand_seed=None, + LO=True, + LOCC_ancillas=False, + LOCC_no_ancillas=False, + engine_selections={"PhaseOneStageOneNoQubitReuse": "Greedy"}, + ): + if not (isinstance(max_gamma, int) and max_gamma > 0): + raise ValueError("max_gamma must be a positive definite integer.") + + if not (isinstance(max_backjumps, int) and max_backjumps >= 0): + raise ValueError("max_backjumps must be a positive semi-definite integer.") + + if not (isinstance(beam_width, int) and beam_width > 0): + raise ValueError("beam_width must be a positive definite integer.") + + self.max_gamma = max_gamma + self.max_backjumps = max_backjumps + self.greedy_multiplier = greedy_multiplier + self.beam_width = beam_width + self.rand_seed = rand_seed + self.engine_selections = engine_selections.copy() + self.LO = LO + self.LOCC_ancillas = LOCC_ancillas + self.LOCC_no_ancillas = LOCC_no_ancillas + + self.gate_cut_LO = self.LO + self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas + self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + + self.wire_cut_LO = self.LO + self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas + self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + + def getMaxGamma(self): + """Return the max gamma.""" + return self.max_gamma + + def getMaxBackJumps(self): + """Return the maximum number of allowed search backjumps.""" + return self.max_backjumps + + def getGreedyMultiplier(self): + """Return the greedy multiplier.""" + return self.greedy_multiplier + + def getBeamWidth(self): + """Return the beam width.""" + return self.beam_width + + def getRandSeed(self): + """Return the random seed.""" + return self.rand_seed + + def getEngineSelection(self, stage_of_optimization): + """Return the name of the search engine to employ.""" + return self.engine_selections[stage_of_optimization] + + def setEngineSelection(self, stage_of_optimization, engine_name): + """Return the name of the search engine to employ.""" + self.engine_selections[stage_of_optimization] = engine_name + + def clearAllCutTypes(self): + """Reset the flags for all circuit cutting types""" + + self.gate_cut_LO = False + self.gate_cut_LOCC_with_ancillas = False + self.gate_cut_LOCC_no_ancillas = False + + self.wire_cut_LO = False + self.wire_cut_LOCC_with_ancillas = False + self.wire_cut_LOCC_no_ancillas = False + + def setGateCutTypes(self): + """Select which gate-cut types to include in the optimization. + The default is to include all gate-cut types. + """ + + self.gate_cut_LO = self.LO + self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas + self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + + def setWireCutTypes(self): + """Select which wire-cut types to include in the optimization. + The default is to include all wire-cut types. + """ + + self.wire_cut_LO = self.LO + self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas + self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + + def getCutSearchGroups(self): + """Return a list of search-action groups to include in the + optimization for cutting circuits into disjoint subcircuits. + """ + + out = [None] + + if ( + self.gate_cut_LO + or self.gate_cut_LOCC_with_ancillas + or self.gate_cut_LOCC_no_ancillas + ): + out.append("GateCut") + + if ( + self.wire_cut_LO + or self.wire_cut_LOCC_with_ancillas + or self.wire_cut_LOCC_no_ancillas + ): + out.append("WireCut") + + return out diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py new file mode 100644 index 000000000..804a837c0 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py @@ -0,0 +1,36 @@ +"""File containing the class used for specifying characteristics of the target QPU.""" +import numpy as np + + +class DeviceConstraints: + + """Class for specifying the characteristics of the target quantum + processor that the optimizer must respect in order for the resulting + subcircuits to be executable on the target processor. + + Member Variables: + + qubits_per_QPU (int) : The number of qubits that are available on the + individual QPUs that make up the quantum processor. + + num_QPUs (int) : The number of QPUs in the target quantum processor. + + Raises: + + ValueError: qubits_per_QPU must be a positive integer. + ValueError: num_QPUs must be a positive integer. + """ + + def __init__(self, qubits_per_QPU, num_QPUs): + if not (isinstance(qubits_per_QPU, int) and qubits_per_QPU > 0): + raise ValueError("qubits_per_QPU must be a positive definite integer.") + + if not (isinstance(num_QPUs, int) and num_QPUs > 0): + raise ValueError("num_QPUs must be a positive definite integer.") + + self.qubits_per_QPU = qubits_per_QPU + self.num_QPUs = num_QPUs + + def getQPUWidth(self): + """Return the number of qubits supported on each individual QPU.""" + return self.qubits_per_QPU diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py new file mode 100644 index 000000000..004843eb7 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py @@ -0,0 +1,228 @@ +"""File containing the classes needed to generate and explore a search space.""" + + +class ActionNames: + + """Class that maps action names to individual action objects + and group names and to lists of action objects, where the + action objects are used to generate a search space. + + Member Variables: + + action_dict (dict) maps action names to action objects. + + group_dict (dict) maps group names to lists of action objects. + """ + + def __init__(self): + self.action_dict = dict() + self.group_dict = dict() + + def copy(self, list_of_groups=None): + """Return a copy of self that contains only those actions + whose group affiliations intersect with list_of_groups. + The default is to return a copy containing all actions. + """ + + action_list = getActionSubset(self.action_dict.values(), list_of_groups) + + new_container = ActionNames() + for action in action_list: + new_container.defineAction(action) + + return new_container + + def defineAction(self, action_object): + """Insert the specified action object into the look-up + dictionaries using the name of the action and its group + names. + """ + + assert ( + not action_object.getName() in self.action_dict + ), f"Action {action_object.getName()} is already defined" + + self.action_dict[action_object.getName()] = action_object + + group_name = action_object.getGroupNames() + + if isinstance(group_name, list) or isinstance(group_name, tuple): + for name in group_name: + if not name in self.group_dict: + self.group_dict[name] = list() + self.group_dict[name].append(action_object) + else: + if not group_name in self.group_dict: + self.group_dict[group_name] = list() + self.group_dict[group_name].append(action_object) + + def defineActionList(self, action_list): + """Inserts the specified action object into the look-up + dictionaries using the name of the action and its group + names""" + + for action in action_list: + self.defineAction(action) + + def getAction(self, action_name): + """Return the action object associated with the specified name. + None is returned if there is no associated action object. + """ + + if action_name in self.action_dict: + return self.action_dict[action_name] + return None + + def getGroup(self, group_name): + """Return the list of action objects associated with the group_name. + None is returned if there are no associated action objects. + """ + + if group_name in self.group_dict: + return self.group_dict[group_name] + return None + + def getGroupActionNames(self, group_name): + """Return a list of the names of action objects associated with + the group_name. None is returned if there are no associated action + objects. + """ + + if group_name in self.group_dict: + return [a.getName() for a in self.group_dict[group_name]] + return None + + def getActionNameList(self): + """Return a list of action names that have been defined.""" + + return list(self.action_dict.keys()) + + def getGroupNameList(self): + """Return a list of group names that have been defined.""" + + return list(self.group_dict.keys()) + + +def getActionSubset(action_list, action_groups): + """Return the subset of actions in action_list whose group affiliations + intersect with action_groups. + """ + + if action_groups is None: + return action_list + + if len(action_groups) <= 0: + action_groups = [None] + + groups = set(action_groups) + + return [ + a for a in action_list if len(groups.intersection(set(a.getGroupNames()))) > 0 + ] + + +class SearchFunctions: + + """Container class for holding functions needed to generate and explore + a search space. In addition to the required input arguments, the function + signatures are assumed to also allow additional input arguments that are + needed to perform the corresponding computations. In particular, an + ActionNames object should be incorporated into the additional input + arguments in order to generate next-states. For simplicity, all search + algorithms will assume that all search-space functions employ the same set + of additional arguments. + + Member Variables: + + cost_func (lambda state, *args) is a function that computes cost values + from search states. The cost returned can be numeric or tuples of + numerics. In the latter case, lexicographical comparisons are performed + per Python semantics. + + stratum_func (lambda state, *args) is a function that computes stratum + identifiers from search states, which are then used to stratify the search + space when stratified beam search is employed. The stratum_func can be + None, in which case each level of the search has only one stratum, which + is then labeled None. + + greedy_bound_func (lambda current_best_cost, *args) can be either + None or a function that computes upper bounds to costs that are used during + the greedy depth-first phases of search. If None is provided, the upper + bound is taken to be infinity. In greedy search, the search proceeds in a + greedy best-first, depth-first fashion until either a goal state is reached, + a deadend is reached, or the cost bound provided by the greedy_bound_func is + exceeded. In the latter two cases, the search backjumps to the lowest cost + state in the search frontier and the search proceeds from there. The + inputs passed to the greedy_bound_func are the current lowest cost in the + search frontier and the input arguments that were passed to the + optimizationPass() method of the search algorithm. If the greedy_bound_func + simply returns current_best_cost, then the search behavior is equivalent to + pure best-first search. Returning None is equivalent to returning an + infinite greedy bound, which produces a purely greedy best-first, + depth-first search. + + next_state_func (lambda state, *args) is a function that returns a list + of next states generated from the input state. An ActionNames object + should be incorporated into the additional input arguments in order to + generate next-states. + + goal_state_func (lambda state, *args) is a function that returns True if + the input state is a solution state of the search. + + upperbound_cost_func (lambda goal_state, *args) can either be None or a + function that returns an upper bound to the optimal cost given a goal_state + as input. The upper bound is used to prune next-states from the search in + subsequent calls to the optimizationPass() method of the search algorithm. + If upperbound_cost_func is None, the cost of the goal_state as determined + by cost_func is used as an upper bound to the optimal cost. If the + upperbound_cost_func returns None, the effect is equivalent to returning + an infinite upper bound (i.e., no cost pruning is performed on subsequent + calls to the optimizationPass method. + + mincost_bound_func (lambda *args) can either be None or a function that + returns a cost bound that is compared to the minimum cost across all + vertices in a search frontier. If the minimum cost exceeds the min-cost + bound, the search is terminated even if a goal state has not yet been found. + Returning None is equivalent to returning an infinite min-cost bound (i.e., + min-cost checking is effectively not performed). A mincost_bound_func that + is None is likewise equivalent to an infinite min-cost bound. + """ + + def __init__( + self, + cost_func=None, + stratum_func=None, + greedy_bound_func=None, + next_state_func=None, + goal_state_func=None, + upperbound_cost_func=None, + mincost_bound_func=None, + ): + self.cost_func = cost_func + self.stratum_func = stratum_func + self.greedy_bound_func = greedy_bound_func + self.next_state_func = next_state_func + self.goal_state_func = goal_state_func + self.upperbound_cost_func = upperbound_cost_func + self.mincost_bound_func = mincost_bound_func + + +class SearchSpaceGenerator: + + """Container class for holding both the functions and the + associated actions needed to generate and explore a search space. + + Member Variables: + + functions (SearchFunctions) is a container class that holds + the functions needed to generate and explore a search space. + + actions (ActionNames) is a container class that holds the search + action objects needed to generate and explore a search space. + The actions are expected to be passed as arguments to the search + functions by a search engine. + """ + + def __init__(self, functions=None, actions=None): + self.functions = functions + self.actions = actions diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py new file mode 100644 index 000000000..eaece58d7 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py @@ -0,0 +1,130 @@ +"""File containing helper functions that are used in the code.""" +import numpy as np +from qiskit import QuantumCircuit +from qiskit.circuit import Instruction +from .best_first_search import BestFirstSearch + + +def QCtoCCOCircuit(circuit: QuantumCircuit): + """Convert a qiskit quantum circuit object into a circuit list that is compatible with the SimpleGateList. + + Args: + circuit: QuantumCircuit object. + + Returns: + circuit_list_rep: list of circuit gates along with qubit numbers associated to each gate, represented in a + form that is compatible with SimpleGateList and is of the form: + + ['barrier', + ('barrier', ), + (( [, ]), ... )]. + + + TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. + """ + + circuit_list_rep = list() + num_circuit_instructions = len(circuit.data) + + for i in range(num_circuit_instructions): + gate_instruction = circuit.data[i] + instruction_name = gate_instruction.operation.name + qubit_ref = gate_instruction.qubits + params = gate_instruction.operation.params + circuit_element = instruction_name + + if ( + circuit_element == "barrier" and len(qubit_ref) == circuit.num_qubits + ): # barrier across all qubits is not assigned to a specific qubit. + circuit_list_rep.append(circuit_element) + else: + circuit_element = (circuit_element,) + if params: + circuit_element += tuple(params[i] for i in range(len(params))) + circuit_element = (circuit_element,) + for j in range(len(qubit_ref)): + qubit_index = qubit_ref[j].index + circuit_element += (qubit_index,) + circuit_list_rep.append(circuit_element) + + return circuit_list_rep + + +def CCOtoQCCircuit(interface): + """Convert the cut circuit outputted by the CircuitCuttingOptimizer into a qiskit.QuantumCircuit object. + + Args: + interface: A SimpleGateList object whose attributes carry information about the cut circuit. + + Returns: + qc_cut: The SimpleGateList converted into a qiskit.QuantumCircuit object, + """ + cut_circuit_list = interface.exportCutCircuit(name_mapping=None) + num_qubits = interface.getNumWires() + cut_circuit_list_len = len(cut_circuit_list) + cut_types = interface.cut_type + qc_cut = QuantumCircuit(num_qubits) + for i in range(cut_circuit_list_len): + op = cut_circuit_list[ + i + ] # the operation, including gate names and qubits acted on. + gate_qubits = len(op) - 1 # number of qubits involved in the operation. + if ( + cut_types[i] is None + ): # only append gates that are not cut to qc_cut. May replace cut gates with TwoQubitQPDGate's in future. + if type(op[0]) is tuple: + params = [i for i in op[0][1:]] + gate_name = op[0][0] + else: + params = [] + gate_name = op[0] + inst = Instruction(gate_name, gate_qubits, 0, params) + qc_cut.append(inst, op[1 : len(op)]) + return qc_cut + + +def selectSearchEngine( + stage_of_optimization, + optimization_settings, + search_space_funcs, + stop_at_first_min=False, +): + engine = optimization_settings.getEngineSelection(stage_of_optimization) + + if engine == "BestFirst": + return BestFirstSearch( + optimization_settings, + search_space_funcs, + stop_at_first_min=stop_at_first_min, + ) + + else: + assert False, f"Invalid stage_of_optimization {stage_of_optimization}" + + +def greedyBestFirstSearch(state, search_space_funcs, *args): + """Perform greedy best-first search using the input starting state and + the input search-space functions. The resulting goal state is returned, + or None if a deadend is reached (no backtracking is performed). Any + additional input arguments are pass as additional arguments to the + search-space functions. + """ + + if search_space_funcs.goal_state_func(state, *args): + return state + + best = min( + [ + (search_space_funcs.cost_func(next_state, *args), k, next_state) + for k, next_state in enumerate( + search_space_funcs.next_state_func(state, *args) + ) + ], + default=(None, None, None), + ) + + if best[-1] is not None: + return greedyBestFirstSearch(best[-1], search_space_funcs, *args) + + else: + return None diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb new file mode 100644 index 000000000..f38bd16d3 --- /dev/null +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -0,0 +1,408 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.circuit_interface import SimpleGateList\n", + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.lo_cuts_optimizer import LOCutsOptimizer\n", + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.optimization_settings import OptimizationSettings\n", + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.quantum_device_constraints import DeviceConstraints" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Best-First Test of CircuitCuttingOptimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([ 511, 1649, 511, 153])} , gamma = 27.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [13, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAABBBB \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([ 6486, 22989, 22989, 3288])} , gamma = 14348907.0 , min_reached = False\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [3, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [4, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [5, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 4, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 5, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 6, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [13, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [18, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [19, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [24, ['cx', 4, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 5, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [26, ['cx', 6, 7]]}]\n", + "Subcircuits: AAABCCCD \n", + "\n" + ] + } + ], + "source": [ + "circuit = [('cx', 0, 1), ('cx', 0, 2), ('cx', 1, 2),\n", + " ('cx', 0, 3), ('cx', 1, 3), ('cx', 2, 3),\n", + " \n", + " ('cx', 4, 5), ('cx', 4, 6), ('cx', 5, 6),\n", + " ('cx', 4, 7), ('cx', 5, 7), ('cx', 6, 7),\n", + " \n", + " \n", + " ('cx', 3, 4), ('cx', 3, 5), ('cx', 3, 6), \n", + " \n", + " \n", + " ('cx', 0, 1), ('cx', 0, 2), ('cx', 1, 2),\n", + " ('cx', 0, 3), ('cx', 1, 3), ('cx', 2, 3),\n", + " \n", + " ('cx', 4, 5), ('cx', 4, 6), ('cx', 5, 6),\n", + " ('cx', 4, 7), ('cx', 5, 7), ('cx', 6, 7),\n", + " ]\n", + "\n", + "interface = SimpleGateList(circuit)\n", + "\n", + "settings = OptimizationSettings(greedy_multiplier = None,\n", + " rand_seed = 12345)\n", + "\n", + "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", + "\n", + "qubits_per_QPU=4\n", + "num_QPUs = 2\n", + "\n", + "\n", + "\n", + "\n", + "for num_qpus in range(num_QPUs, 1, -1):\n", + " for qpu_qubits in range(qubits_per_QPU, 2, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", + " \n", + " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", + " num_QPUs = num_QPUs)\n", + "\n", + " op = LOCutsOptimizer(interface, \n", + " settings, \n", + " constraint_obj)\n", + " \n", + " out = op.optimize()\n", + "\n", + " print('Stats =', op.getStats(), \n", + " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", + " ', min_reached =', op.minimumReached())\n", + " if (out is not None):\n", + " out.print(simple=True)\n", + " else:\n", + " print(out)\n", + " \n", + " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')\n", + "\n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cut finding for efficient SU(2) Circuit with linear entanglement" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EfficientSU2\n", + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.utils import QCtoCCOCircuit\n", + "\n", + "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", + "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", + "\n", + "circuit_ckt=QCtoCCOCircuit(qc)\n", + "\n", + "qc.draw(\"mpl\", scale=0.8)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([ 7, 10, 7, 0])} , gamma = 1.0 , min_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([30, 92, 30, 7])} , gamma = 9.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + "Subcircuits: AAAB \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([15, 46, 15, 6])} , gamma = 9.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + "Subcircuits: AABB \n", + "\n" + ] + } + ], + "source": [ + "interface = SimpleGateList(circuit_ckt)\n", + "\n", + "settings = OptimizationSettings(rand_seed = 12345)\n", + "\n", + "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", + "\n", + "\n", + "qubits_per_QPU=4\n", + "num_QPUs=2\n", + "\n", + "\n", + "\n", + "for num_qpus in range(num_QPUs, 1, -1):\n", + " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", + " \n", + " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", + " num_QPUs = num_QPUs)\n", + "\n", + " op = LOCutsOptimizer(interface, \n", + " settings, \n", + " constraint_obj)\n", + " \n", + " out = op.optimize()\n", + "\n", + " print('Stats =', op.getStats(), \n", + " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", + " ', min_reached =', op.minimumReached())\n", + " if (out is not None):\n", + " out.print(simple=True)\n", + " else:\n", + " print(out)\n", + " \n", + " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cut finding for 7 qubit circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "qc_0 = QuantumCircuit(7)\n", + "for i in range(7):\n", + " qc_0.rx(np.pi / 4, i)\n", + "qc_0.cx(0, 3)\n", + "qc_0.cx(1, 3)\n", + "qc_0.cx(2, 3)\n", + "qc_0.cx(3, 4)\n", + "qc_0.cx(3, 5)\n", + "qc_0.cx(3, 6)\n", + "qc_0.cx(0, 3)\n", + "qc_0.cx(1, 3)\n", + "qc_0.cx(2, 3)\n", + "\n", + "qc_0.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([10, 16, 10, 0])} , gamma = 1.0 , min_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", + "\n", + "\n", + "\n", + "---------- 6 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([ 39, 101, 39, 2])} , gamma = 3.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAAAAB \n", + "\n", + "\n", + "\n", + "---------- 5 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([101, 381, 101, 24])} , gamma = 9.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAAABC \n", + "\n", + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([243, 945, 243, 101])} , gamma = 27.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAABCD \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([1191, 4154, 1191, 792])} , gamma = 243.0 , min_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [15, ['cx', 2, 3]]}]\n", + "Subcircuits: AABACDE \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + "Stats = {'CutOptimization': array([ 445, 1308, 667, 418])} , gamma = 2187.0 , min_reached = False\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [15, ['cx', 2, 3]]}]\n", + "Subcircuits: ABCADEF \n", + "\n" + ] + } + ], + "source": [ + "circuit_ckt_wirecut=QCtoCCOCircuit(qc_0)\n", + "\n", + "interface = SimpleGateList(circuit_ckt_wirecut)\n", + "\n", + "settings = OptimizationSettings(rand_seed = 12345)\n", + "\n", + "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", + "\n", + "qubits_per_QPU=7\n", + "num_QPUs=2\n", + "\n", + "\n", + "\n", + "for num_qpus in range(num_QPUs, 1, -1):\n", + " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", + " \n", + " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", + " num_QPUs = num_QPUs)\n", + "\n", + " op = LOCutsOptimizer(interface, \n", + " settings, \n", + " constraint_obj)\n", + " \n", + " out = op.optimize()\n", + "\n", + " print('Stats =', op.getStats(), \n", + " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", + " ', min_reached =', op.minimumReached())\n", + " if (out is not None):\n", + " out.print(simple=True)\n", + " else:\n", + " print(out)\n", + " \n", + " # print('\\nAfter Cuts\\n\\nGate Positions:', interface.new_gate_ID_map)\n", + " # for k, gate in enumerate(interface.new_circuit):\n", + " # print(k, gate, interface.cut_type[k])\n", + " # print('Output Wires:', interface.output_wires,'\\n')\n", + " \n", + " # print('Name Mapping = \"default\"')\n", + " # for k, gate in enumerate(interface.exportCutCircuit(name_mapping='default')):\n", + " # print(k, gate, interface.cut_type[k])\n", + " # print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\n", + " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cco", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8f79eb395f67b1bbd26bc52e3784b014686d5f1e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 8 Jan 2024 20:17:17 -0500 Subject: [PATCH 002/128] Update tutorial with bug fix pending --- .../circuit_interface.py | 4 + .../disjoint_subcircuits_state.py | 6 +- .../tutorials/LO_circuit_cut_finder.ipynb | 193 ++++++------------ 3 files changed, 71 insertions(+), 132 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py index 95a055279..f803639ad 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py @@ -344,11 +344,15 @@ def exportSubcircuitsAsString(self, name_mapping="default"): out = list(range(self.getNumWires())) alphabet = string.ascii_uppercase + string.ascii_lowercase + #print(out) for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] + # print (wire_map) + # print(self.subcircuits) + # print(out) return "".join(out) def makeWireMapping(self, name_mapping): diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py index 29517eaf2..476e080a1 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py @@ -190,9 +190,9 @@ def print(self, simple=False): if simple: # print only a subset of properties. # print(self.lowerBoundGamma(), self.gamma_UB, self.getMaxWidth()) - # print(debugActionListWithNames(self.actions)) + print('Actions:', PrintActionListWithNames(self.actions)) # print(self.no_merge) - print(cut_actions_sublist) + #print(cut_actions_sublist) else: print("wiremap", self.wiremap) print("num_wires", self.num_wires) @@ -481,7 +481,7 @@ def calcRootBellPairsGamma(root_bell_pairs): def PrintActionListWithNames(action_list): """Replace the action objects that appear in action lists in DisjointSubcircuitsState objects with the corresponding - action names for readability and print. + action names for readability, and print. """ return [[x[0].getName()] + x[1:] for x in action_list] diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index f38bd16d3..58fa8ab31 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -13,97 +13,6 @@ "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.quantum_device_constraints import DeviceConstraints" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Best-First Test of CircuitCuttingOptimizer" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([ 511, 1649, 511, 153])} , gamma = 27.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [13, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([ 6486, 22989, 22989, 3288])} , gamma = 14348907.0 , min_reached = False\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [3, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [4, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [5, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 4, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 5, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 6, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [13, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [18, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [19, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [24, ['cx', 4, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 5, 7]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [26, ['cx', 6, 7]]}]\n", - "Subcircuits: AAABCCCD \n", - "\n" - ] - } - ], - "source": [ - "circuit = [('cx', 0, 1), ('cx', 0, 2), ('cx', 1, 2),\n", - " ('cx', 0, 3), ('cx', 1, 3), ('cx', 2, 3),\n", - " \n", - " ('cx', 4, 5), ('cx', 4, 6), ('cx', 5, 6),\n", - " ('cx', 4, 7), ('cx', 5, 7), ('cx', 6, 7),\n", - " \n", - " \n", - " ('cx', 3, 4), ('cx', 3, 5), ('cx', 3, 6), \n", - " \n", - " \n", - " ('cx', 0, 1), ('cx', 0, 2), ('cx', 1, 2),\n", - " ('cx', 0, 3), ('cx', 1, 3), ('cx', 2, 3),\n", - " \n", - " ('cx', 4, 5), ('cx', 4, 6), ('cx', 5, 6),\n", - " ('cx', 4, 7), ('cx', 5, 7), ('cx', 6, 7),\n", - " ]\n", - "\n", - "interface = SimpleGateList(circuit)\n", - "\n", - "settings = OptimizationSettings(greedy_multiplier = None,\n", - " rand_seed = 12345)\n", - "\n", - "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", - "\n", - "qubits_per_QPU=4\n", - "num_QPUs = 2\n", - "\n", - "\n", - "\n", - "\n", - "for num_qpus in range(num_QPUs, 1, -1):\n", - " for qpu_qubits in range(qubits_per_QPU, 2, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", - " \n", - " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", - " num_QPUs = num_QPUs)\n", - "\n", - " op = LOCutsOptimizer(interface, \n", - " settings, \n", - " constraint_obj)\n", - " \n", - " out = op.optimize()\n", - "\n", - " print('Stats =', op.getStats(), \n", - " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", - " ', min_reached =', op.minimumReached())\n", - " if (out is not None):\n", - " out.print(simple=True)\n", - " else:\n", - " print(out)\n", - " \n", - " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')\n", - "\n", - " \n", - "\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -120,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -130,7 +39,7 @@ "
" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -158,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -168,22 +77,22 @@ "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([ 7, 10, 7, 0])} , gamma = 1.0 , min_reached = True\n", - "[]\n", + " Gamma = 1.0 , min_reached = True\n", + "Actions: []\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([30, 92, 30, 7])} , gamma = 9.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + " Gamma = 9.0 , min_reached = True\n", + "Actions: [['CutTwoQubitGate', [17, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [25, ['cx', 2, 3], None], ((1, 2), (2, 3))]]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([15, 46, 15, 6])} , gamma = 9.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + " Gamma = 9.0 , min_reached = True\n", + "Actions: [['CutTwoQubitGate', [9, ['cx', 1, 2], None], ((1, 1), (2, 2))], ['CutTwoQubitGate', [20, ['cx', 1, 2], None], ((1, 1), (2, 2))]]\n", "Subcircuits: AABB \n", "\n" ] @@ -215,8 +124,7 @@ " \n", " out = op.optimize()\n", "\n", - " print('Stats =', op.getStats(), \n", - " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", + " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", " ', min_reached =', op.minimumReached())\n", " if (out is not None):\n", " out.print(simple=True)\n", @@ -242,17 +150,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -268,9 +176,6 @@ "qc_0.cx(3, 4)\n", "qc_0.cx(3, 5)\n", "qc_0.cx(3, 6)\n", - "qc_0.cx(0, 3)\n", - "qc_0.cx(1, 3)\n", - "qc_0.cx(2, 3)\n", "\n", "qc_0.draw(\"mpl\")" ] @@ -284,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -294,49 +199,61 @@ "\n", "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([10, 16, 10, 0])} , gamma = 1.0 , min_reached = True\n", - "[]\n", + " Gamma = 1.0 , min_reached = True\n", + "Actions: []\n", "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([ 39, 101, 39, 2])} , gamma = 3.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + " Gamma = 3.0 , min_reached = True\n", + "Actions: [['CutTwoQubitGate', [12, ['cx', 3, 6], None], ((1, 3), (2, 6))]]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([101, 381, 101, 24])} , gamma = 9.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAAABC \n", + " Gamma = 4.0 , min_reached = True\n", + "Actions: [['CutLeftWire', [11, ['cx', 3, 5], None], ((1, 3, 7),)]]\n", + "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([243, 945, 243, 101])} , gamma = 27.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAABCD \n", + " Gamma = 4.0 , min_reached = True\n", + "Actions: [['CutLeftWire', [10, ['cx', 3, 4], None], ((1, 3, 7),)]]\n", + "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([1191, 4154, 1191, 792])} , gamma = 243.0 , min_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [15, ['cx', 2, 3]]}]\n", - "Subcircuits: AABACDE \n", + " Gamma = 16.0 , min_reached = True\n", + "Actions: [['CutRightWire', [9, ['cx', 2, 3], None], ((2, 3, 7),)], ['CutLeftWire', [11, ['cx', 3, 5], None], ((1, 7, 8),)]]\n", + "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - "Stats = {'CutOptimization': array([ 445, 1308, 667, 418])} , gamma = 2187.0 , min_reached = False\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [10, ['cx', 3, 4]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [14, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [15, ['cx', 2, 3]]}]\n", - "Subcircuits: ABCADEF \n", - "\n" + " Gamma = 243.0 , min_reached = True\n", + "Actions: [['CutTwoQubitGate', [7, ['cx', 0, 3], None], ((1, 0), (2, 3))], ['CutTwoQubitGate', [8, ['cx', 1, 3], None], ((1, 1), (2, 3))], ['CutTwoQubitGate', [9, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [11, ['cx', 3, 5], None], ((1, 3), (2, 5))], ['CutTwoQubitGate', [12, ['cx', 3, 6], None], ((1, 3), (2, 6))]]\n" + ] + }, + { + "ename": "TypeError", + "evalue": "sequence item 4: expected str instance, int found", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 45\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28mprint\u001b[39m(out)\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# print('\\nAfter Cuts\\n\\nGate Positions:', interface.new_gate_ID_map)\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# for k, gate in enumerate(interface.new_circuit):\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;66;03m# print(k, gate, interface.cut_type[k])\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;66;03m# print(k, gate, interface.cut_type[k])\u001b[39;00m\n\u001b[1;32m 44\u001b[0m \u001b[38;5;66;03m# print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\u001b[39;00m\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSubcircuits:\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[43minterface\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportSubcircuitsAsString\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname_mapping\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdefault\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py:356\u001b[0m, in \u001b[0;36mSimpleGateList.exportSubcircuitsAsString\u001b[0;34m(self, name_mapping)\u001b[0m\n\u001b[1;32m 351\u001b[0m out[wire_map[wire]] \u001b[38;5;241m=\u001b[39m alphabet[k]\n\u001b[1;32m 353\u001b[0m \u001b[38;5;66;03m# print (wire_map)\u001b[39;00m\n\u001b[1;32m 354\u001b[0m \u001b[38;5;66;03m# print(self.subcircuits) \u001b[39;00m\n\u001b[1;32m 355\u001b[0m \u001b[38;5;66;03m# print(out)\u001b[39;00m\n\u001b[0;32m--> 356\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mout\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: sequence item 4: expected str instance, int found" ] } ], "source": [ + "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.utils import QCtoCCOCircuit\n", + "\n", "circuit_ckt_wirecut=QCtoCCOCircuit(qc_0)\n", "\n", "interface = SimpleGateList(circuit_ckt_wirecut)\n", @@ -363,8 +280,7 @@ " \n", " out = op.optimize()\n", "\n", - " print('Stats =', op.getStats(), \n", - " ', gamma =', None if (out is None) else out.upperBoundGamma(),\n", + " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", " ', min_reached =', op.minimumReached())\n", " if (out is not None):\n", " out.print(simple=True)\n", @@ -382,6 +298,25 @@ " # print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\n", " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')" ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n" + ] + } + ], + "source": [ + "import string\n", + "x=string.ascii_uppercase + string.ascii_lowercase\n", + "print(x)" + ] } ], "metadata": { From 3e8c438b0ff3412b5a24c157855bac05d5b6451e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 8 Jan 2024 20:21:25 -0500 Subject: [PATCH 003/128] update tutorial with bug fix pending --- .../circuit_interface.py | 6 +++--- .../cut_optimization.py | 1 - .../disjoint_subcircuits_state.py | 12 ++++++------ .../lo_cuts_optimizer.py | 1 - .../quantum_device_constraints.py | 1 - .../search_space_generator.py | 6 +++--- .../LO_circuit_cut_optimizer/utils.py | 1 - .../tutorials/LO_circuit_cut_finder.ipynb | 19 ------------------- 8 files changed, 12 insertions(+), 35 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py index f803639ad..d7049e21c 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py @@ -441,7 +441,7 @@ def getID(self, item_name): item ID is assigned. """ - if not item_name in self.item_dict: + if item_name not in self.item_dict: while self.next_ID in self.ID_dict: self.next_ID += 1 @@ -454,9 +454,9 @@ def getID(self, item_name): def defineID(self, item_ID, item_name): """Assign a spefiic ID number to an item name.""" - assert not item_ID in self.ID_dict, f"item ID {item_ID} already assigned" + assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" assert ( - not item_name in self.item_dict + item_name not in self.item_dict ), f"item name {item_name} already assigned" self.item_dict[item_name] = item_ID diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py index c70f19b4a..33c995b13 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py @@ -9,7 +9,6 @@ ) from .disjoint_subcircuits_state import ( DisjointSubcircuitsState, - PrintActionListWithNames, ) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py index 476e080a1..0f7aff206 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py @@ -1,7 +1,7 @@ """File containing the class needed for representing search-space states when cutting circuits.""" import copy import numpy as np -from collections import Counter, namedtuple +from collections import Counter class DisjointSubcircuitsState: @@ -209,13 +209,13 @@ def print(self, simple=False): def getNumQubits(self): """Return the number of qubits in the circuit.""" - if not (self.wiremap is None): + if self.wiremap is not None: return self.wiremap.shape[0] def getMaxWidth(self): """Return the maximum width across subcircuits.""" - if not (self.width is None): + if self.width is not None: return np.amax(self.width) def getSubCircuitIndices(self): @@ -223,7 +223,7 @@ def getSubCircuitIndices(self): the current cut circuit. """ - if not (self.uptree is None): + if self.uptree is not None: return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] def getWireRootMapping(self): @@ -322,7 +322,7 @@ def checkDoNotMergeRoots(self, root_1, root_2): """ assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( - f"Arguments must be roots: " + "Arguments must be roots: " + f"{root_1} != {self.uptree[root_1]} " + f"or {root_2} != {self.uptree[root_2]}" ) @@ -401,7 +401,7 @@ def mergeRoots(self, root_1, root_2): """ assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( - f"Arguments must be roots: " + "Arguments must be roots: " + f"{root_1} != {self.uptree[root_1]} " + f"or {root_2} != {self.uptree[root_2]}" ) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py index 39a5fd645..16b50cb02 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py @@ -1,5 +1,4 @@ """File containing the wrapper class for optimizing LO gate and wire cuts.""" -from itertools import count from .cut_optimization import CutOptimization from .cut_optimization import disjoint_subcircuit_actions from .cut_optimization import CutOptimizationNextStateFunc diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py index 804a837c0..bf7f2383e 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py @@ -1,5 +1,4 @@ """File containing the class used for specifying characteristics of the target QPU.""" -import numpy as np class DeviceConstraints: diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py index 004843eb7..cd1508a88 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py @@ -39,7 +39,7 @@ def defineAction(self, action_object): """ assert ( - not action_object.getName() in self.action_dict + action_object.getName() not in self.action_dict ), f"Action {action_object.getName()} is already defined" self.action_dict[action_object.getName()] = action_object @@ -48,11 +48,11 @@ def defineAction(self, action_object): if isinstance(group_name, list) or isinstance(group_name, tuple): for name in group_name: - if not name in self.group_dict: + if name not in self.group_dict: self.group_dict[name] = list() self.group_dict[name].append(action_object) else: - if not group_name in self.group_dict: + if group_name not in self.group_dict: self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py index eaece58d7..11d3ec34a 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py @@ -1,5 +1,4 @@ """File containing helper functions that are used in the code.""" -import numpy as np from qiskit import QuantumCircuit from qiskit.circuit import Instruction from .best_first_search import BestFirstSearch diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 58fa8ab31..461e7c9b9 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -298,25 +298,6 @@ " # print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\n", " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')" ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n" - ] - } - ], - "source": [ - "import string\n", - "x=string.ascii_uppercase + string.ascii_lowercase\n", - "print(x)" - ] } ], "metadata": { From e08403334c72f16223fde14687fa8c70df052e2f Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 10:18:23 -0500 Subject: [PATCH 004/128] fix bug and update notebook --- .../circuit_interface.py | 10 +-- .../disjoint_subcircuits_state.py | 10 +-- .../tutorials/LO_circuit_cut_finder.ipynb | 77 +++++++------------ 3 files changed, 37 insertions(+), 60 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py index d7049e21c..ae8a70daa 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py @@ -243,7 +243,8 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): wire/qubit ID of the source wire to be cut is also provided as input to allow the wire choice to be verified. The ID of the (new) destination wire/qubit must also be provided. The cut - type can be "LO", "LOCCWithAncillas", or "LOCCNoAncillas". + type as of now can only be "LO", with the options "LOCCWithAncillas" + and "LOCCNoAncillas" being added in the future. """ gate_pos = self.new_gate_ID_map[gate_ID] @@ -344,15 +345,10 @@ def exportSubcircuitsAsString(self, name_mapping="default"): out = list(range(self.getNumWires())) alphabet = string.ascii_uppercase + string.ascii_lowercase - #print(out) - + for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - - # print (wire_map) - # print(self.subcircuits) - # print(out) return "".join(out) def makeWireMapping(self, name_mapping): diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py index 0f7aff206..5c872bb7c 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py @@ -167,10 +167,8 @@ def print(self, simple=False): cut_actions_sublist = [] # Output formatting for LO gate and wire cuts. - # Temporary and needs to be updated later on. - for i in range(len(cut_actions)): - if cut_actions[i][0] == ("CutLeftWire" or "CutRightWire"): + if (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): cut_actions_sublist.append( { "Cut action": cut_actions[i][0], @@ -187,12 +185,14 @@ def print(self, simple=False): "Cut Gate": [cut_actions[i][1][0], cut_actions[i][1][1]], } ) + if not cut_actions_sublist: + cut_actions_sublist = cut_actions if simple: # print only a subset of properties. # print(self.lowerBoundGamma(), self.gamma_UB, self.getMaxWidth()) - print('Actions:', PrintActionListWithNames(self.actions)) + # print('Actions:', PrintActionListWithNames(self.actions)) # print(self.no_merge) - #print(cut_actions_sublist) + print(cut_actions_sublist) else: print("wiremap", self.wiremap) print("num_wires", self.num_wires) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 461e7c9b9..b019095d5 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -77,30 +77,28 @@ "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , min_reached = True\n", - "Actions: []\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , min_reached = True\n", - "Actions: [['CutTwoQubitGate', [17, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [25, ['cx', 2, 3], None], ((1, 2), (2, 3))]]\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , min_reached = True\n", - "Actions: [['CutTwoQubitGate', [9, ['cx', 1, 2], None], ((1, 1), (2, 2))], ['CutTwoQubitGate', [20, ['cx', 1, 2], None], ((1, 1), (2, 2))]]\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", "Subcircuits: AABB \n", "\n" ] } ], "source": [ - "interface = SimpleGateList(circuit_ckt)\n", - "\n", "settings = OptimizationSettings(rand_seed = 12345)\n", "\n", "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", @@ -117,6 +115,8 @@ " \n", " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", " num_QPUs = num_QPUs)\n", + " \n", + " interface = SimpleGateList(circuit_ckt)\n", "\n", " op = LOCutsOptimizer(interface, \n", " settings, \n", @@ -125,7 +125,7 @@ " out = op.optimize()\n", "\n", " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", - " ', min_reached =', op.minimumReached())\n", + " ', Min_gamma_reached =', op.minimumReached())\n", " if (out is not None):\n", " out.print(simple=True)\n", " else:\n", @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -199,55 +199,45 @@ "\n", "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , min_reached = True\n", - "Actions: []\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , min_reached = True\n", - "Actions: [['CutTwoQubitGate', [12, ['cx', 3, 6], None], ((1, 3), (2, 6))]]\n", + " Gamma = 3.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , min_reached = True\n", - "Actions: [['CutLeftWire', [11, ['cx', 3, 5], None], ((1, 3, 7),)]]\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , min_reached = True\n", - "Actions: [['CutLeftWire', [10, ['cx', 3, 4], None], ((1, 3, 7),)]]\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , min_reached = True\n", - "Actions: [['CutRightWire', [9, ['cx', 2, 3], None], ((2, 3, 7),)], ['CutLeftWire', [11, ['cx', 3, 5], None], ((1, 7, 8),)]]\n", + " Gamma = 16.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , min_reached = True\n", - "Actions: [['CutTwoQubitGate', [7, ['cx', 0, 3], None], ((1, 0), (2, 3))], ['CutTwoQubitGate', [8, ['cx', 1, 3], None], ((1, 1), (2, 3))], ['CutTwoQubitGate', [9, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [11, ['cx', 3, 5], None], ((1, 3), (2, 5))], ['CutTwoQubitGate', [12, ['cx', 3, 6], None], ((1, 3), (2, 6))]]\n" - ] - }, - { - "ename": "TypeError", - "evalue": "sequence item 4: expected str instance, int found", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 45\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28mprint\u001b[39m(out)\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# print('\\nAfter Cuts\\n\\nGate Positions:', interface.new_gate_ID_map)\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# for k, gate in enumerate(interface.new_circuit):\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;66;03m# print(k, gate, interface.cut_type[k])\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;66;03m# print(k, gate, interface.cut_type[k])\u001b[39;00m\n\u001b[1;32m 44\u001b[0m \u001b[38;5;66;03m# print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\u001b[39;00m\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSubcircuits:\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[43minterface\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportSubcircuitsAsString\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname_mapping\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdefault\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py:356\u001b[0m, in \u001b[0;36mSimpleGateList.exportSubcircuitsAsString\u001b[0;34m(self, name_mapping)\u001b[0m\n\u001b[1;32m 351\u001b[0m out[wire_map[wire]] \u001b[38;5;241m=\u001b[39m alphabet[k]\n\u001b[1;32m 353\u001b[0m \u001b[38;5;66;03m# print (wire_map)\u001b[39;00m\n\u001b[1;32m 354\u001b[0m \u001b[38;5;66;03m# print(self.subcircuits) \u001b[39;00m\n\u001b[1;32m 355\u001b[0m \u001b[38;5;66;03m# print(out)\u001b[39;00m\n\u001b[0;32m--> 356\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mout\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mTypeError\u001b[0m: sequence item 4: expected str instance, int found" + " Gamma = 243.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: ABCDDEF \n", + "\n" ] } ], @@ -256,8 +246,6 @@ "\n", "circuit_ckt_wirecut=QCtoCCOCircuit(qc_0)\n", "\n", - "interface = SimpleGateList(circuit_ckt_wirecut)\n", - "\n", "settings = OptimizationSettings(rand_seed = 12345)\n", "\n", "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", @@ -274,6 +262,8 @@ " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", " num_QPUs = num_QPUs)\n", "\n", + " interface = SimpleGateList(circuit_ckt_wirecut)\n", + " \n", " op = LOCutsOptimizer(interface, \n", " settings, \n", " constraint_obj)\n", @@ -281,21 +271,12 @@ " out = op.optimize()\n", "\n", " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", - " ', min_reached =', op.minimumReached())\n", + " ', Min_gamma_reached =', op.minimumReached())\n", " if (out is not None):\n", " out.print(simple=True)\n", " else:\n", " print(out)\n", - " \n", - " # print('\\nAfter Cuts\\n\\nGate Positions:', interface.new_gate_ID_map)\n", - " # for k, gate in enumerate(interface.new_circuit):\n", - " # print(k, gate, interface.cut_type[k])\n", - " # print('Output Wires:', interface.output_wires,'\\n')\n", - " \n", - " # print('Name Mapping = \"default\"')\n", - " # for k, gate in enumerate(interface.exportCutCircuit(name_mapping='default')):\n", - " # print(k, gate, interface.cut_type[k])\n", - " # print('Output Wire Mapping:', interface.exportOutputWires(name_mapping='default'))\n", + "\n", " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')" ] } From aa280e83048f939d2d6ec48435f007d137f10ef0 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 10:28:04 -0500 Subject: [PATCH 005/128] update print method, Co-authored by: Edwin Pednault pednault@us.ibm.com --- .../LO_circuit_cut_optimizer/disjoint_subcircuits_state.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py index 5c872bb7c..165960ef3 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py @@ -1,7 +1,7 @@ """File containing the class needed for representing search-space states when cutting circuits.""" import copy import numpy as np -from collections import Counter +from collections import Counter, namedtuple class DisjointSubcircuitsState: @@ -162,6 +162,8 @@ def print(self, simple=False): # Gate=[cut_actions[i][1][0], cut_actions[i][1][1]], # ) # ) + # elif (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): + cut_actions = PrintActionListWithNames(self.actions) cut_actions_sublist = [] @@ -172,7 +174,7 @@ def print(self, simple=False): cut_actions_sublist.append( { "Cut action": cut_actions[i][0], - "Cut location:": { + "Cut location": { "Gate": [cut_actions[i][1][0], cut_actions[i][1][1]] }, "Input wire": cut_actions[i][2][0][0], From 654ec7c79bab32e9fe945f1b0c70520594dd6302 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 10:57:49 -0600 Subject: [PATCH 006/128] Update cut finding dir structure --- circuit_knitting/cutting/__init__.py | 3 ++ .../LO_circuit_cut_optimizer/__init__.py | 0 .../cutting/cut_finding/__init__.py | 1 + .../best_first_search.py | 0 .../circuit_interface.py | 0 .../cutting/cut_finding/cut_finding.py | 19 ++++++++++ .../cut_optimization.py | 0 .../cutting_actions.py | 0 .../disjoint_subcircuits_state.py | 0 .../lo_cuts_optimizer.py | 0 .../optimization_settings.py | 0 .../quantum_device_constraints.py | 0 .../search_space_generator.py | 0 .../{LO_circuit_cut_optimizer => }/utils.py | 0 .../tutorials/LO_circuit_cut_finder.ipynb | 35 +++++++++---------- 15 files changed, 40 insertions(+), 18 deletions(-) delete mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/best_first_search.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/circuit_interface.py (100%) create mode 100644 circuit_knitting/cutting/cut_finding/cut_finding.py rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/cut_optimization.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/cutting_actions.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/disjoint_subcircuits_state.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/lo_cuts_optimizer.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/optimization_settings.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/quantum_device_constraints.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/search_space_generator.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/utils.py (100%) diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index 268123d27..55cbed2d4 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -21,6 +21,7 @@ :toctree: ../stubs/ :nosignatures: + find_cuts cut_wires expand_observables partition_circuit_qubits @@ -80,6 +81,7 @@ cutqc.reconstruct_full_distribution """ +from .cut_finding import find_cuts from .cutting_decomposition import ( partition_circuit_qubits, partition_problem, @@ -93,6 +95,7 @@ from .wire_cutting_transforms import cut_wires, expand_observables __all__ = [ + "find_cuts", "partition_circuit_qubits", "partition_problem", "cut_gates", diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index e69de29bb..88a79e9b2 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -0,0 +1 @@ +from .cut_finding import find_cuts diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py rename to circuit_knitting/cutting/cut_finding/best_first_search.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py rename to circuit_knitting/cutting/cut_finding/circuit_interface.py diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py new file mode 100644 index 000000000..e9427bd34 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2023. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Automatically find cut locations in a quantum circuit.""" + +from __future__ import annotations + +from qiskit import QuantumCircuit + +def find_cuts(circuit: QuantumCircuit): + pass diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py rename to circuit_knitting/cutting/cut_finding/cut_optimization.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py rename to circuit_knitting/cutting/cut_finding/cutting_actions.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py rename to circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py rename to circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py rename to circuit_knitting/cutting/cut_finding/optimization_settings.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py rename to circuit_knitting/cutting/cut_finding/quantum_device_constraints.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py rename to circuit_knitting/cutting/cut_finding/search_space_generator.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py b/circuit_knitting/cutting/cut_finding/utils.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py rename to circuit_knitting/cutting/cut_finding/utils.py diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index b019095d5..c66a4a19f 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -7,10 +7,10 @@ "outputs": [], "source": [ "import numpy as np\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.circuit_interface import SimpleGateList\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.lo_cuts_optimizer import LOCutsOptimizer\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.optimization_settings import OptimizationSettings\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.quantum_device_constraints import DeviceConstraints" + "from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList\n", + "from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer\n", + "from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings\n", + "from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints" ] }, { @@ -29,17 +29,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAD2CAYAAABobBdEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA4X0lEQVR4nO3de3wU9dn//9duTgRIwjnhrCABkShElINAEYsUQRQVod71VFsPKLcIxa+t3kqtP6v267cVRUpRQa1K+2hF1AqC4eBdRQUMEAQV5JQA4RQSkpCQhOzvjymBQEJ2M7uZmQ/v5+ORh8lkdva63M81uZjDZ3yBQCCAiIiIiEg9+Z0OQERERES8TQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYku00wGYZt0CKMl3OgqIbwa9x9rbhltygfDkYxLTPhu35KNxZja3jDNQ3Yh51FCGWUk+FB9yOorwMCkX05j22ZiWj7iTaePMtHzE23TKW0RERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtuinHIc/Nv4Ola18HwO/z0yKxLb27DuOua35Pq6T2DkcXOtPyMYlJn41JuYi7mTTWTMpF3EtHKB2Udv5g/vY/e3nr0V38+pa32bonk9+9Oc7psOrNtHxMYtJnY1Iu4m4mjTWTchF3UkPpoOioWFokptAqqT0XdxnCqH53s2nnKopLjzgdWr2Ylo9JTPpsTMpF3M2ksWZSLuJOaihd4mDBHj7N+gd+fxR+f5TT4dhmWj4mMemzMSkXcTeTxppJuYh76BpKB63ftoJrH21KIFDJsfISAG4aMpX42CYAPPnGTVyaejWj+t8NwNbdmTz99i38eXImsTGNHIu7NnXl8++sBby59LfVXrNr/yYmjnmBawfe1+DxnktMGmsaZ9JQVDeqGwmepxvK9evX8/jjj7NixQoCgQDDhg1j1qxZpKamMmrUKObPn+90iGfVo2M/Hp7wOmUVpaxc/3cyt3zCnT95qur3E697gYdmDmJQ2g0kxLfghXfv44HrX3LdjuqEuvIZlDaWQWknn8/12cb3eG3Rbxje93Ynwg1JIAC5BVBYCnHR0KEFRHno+L5JY83kcWYa1Y17qG4k0jzbUGZkZDB69Gg6d+7MY489Rnx8PPPmzWPkyJEUFRXRu3dvp0OsU1xMPO1bXQDA+Sm92HvoB156bxJTxs0BoFVSe24cMoW/fDiNHp360aFVKundrnIy5LOqK59THcjP4cUF9/P0XYtoFNu4oUMNWiAAq7fDis2wJ//k8sR4GNQNhvWEaA+cMTJprJk4zkwTCMDaHbB8E+zOP7k8MR4GdoOrekKM6qZBqW4k0jz0b8WTDhw4wPjx40lPTyczM5Np06bxwAMPkJGRwa5duwA80VCe7tbh0/l4zVy+y15TtWzMwPvZue8b/rb8Ge659nkHowtdTfkAVFZW8sw7P2PClY/Qpd3FDkVXt0AA3vsa3l5VvZkEOFICH22APy+DsgpHwrPFpLHm9XFmmkAA3s+Ev35evZkEq24Wb4BZGaobp6luJNw82VA+++yzHD58mLlz5xIfH1+1PCkpifT0dMCbDWWH1t0YcOG1zF38aNUyv9/P6P73cnmPa2jWtLWD0YWupnwA3sp4isaNErl+0CSHIgvO2h2w8tuzr7N1P3yQ2SDhhJVJY83r48w0mTth+eazr7PtALy3tmHiCSfVjUjtPNlQzp8/n8GDB5Oamlrj75OTk0lJSQGgoqKCBx98kBYtWtCsWTPuuusuSktLGzLckIwbOo213y9h/Q8rqpb5fH58Pk9+VGfks3H7Zyz+6lWm3TzX2cDqEAhYp7mD8cUPUFIW2XgiwaSx5tVxZqIVdfwj7ISvtkHxscjGEgmqG5Gaee4aytzcXHbv3s348ePP+F1lZSVZWVn06dOnatnTTz/N8uXLycrKIjY2ljFjxvDwww8zY8aMoN6voqKC3NzcoOMrL08GYupc7+EJ82pcftF5A1n6h0DQ71d7HOXk5OyzuY3gcoHg8ikqyefZ+bcybfw8Epu0DDEW+/mEIu9oNDmHU4Jat/w4fLohj4tSjkY4qlPeM8yfjb1YGm6smTbOTJNfEsWuQ22DWrei0qqbtLaqm/pvQ3Uj4ZeSkkJ0dOjtoecayuLiYgB8Pt8Zv1u4cCH79++vdrr7lVde4bnnnqN9e+vxUtOnT2fcuHH88Y9/JCqq7qvCc3Nz6dixY9DxzZm6kfNSLgp6/Uj5/vvv+dE9vWxtI9y5fLBqFnlH9jLr/YeqLb+67+3cOOShWl5lCUc+oWiXegXjHv930Ov/+vH/j8xF/y+CEVXnlnEG7htrXhpnpknp2o/xv/0i6PUf/91zrPng2QhGVJ3qpnaqGzkhOzubDh06hPw6zzWUHTt2JCoqipUrV1ZbvnPnTiZNsq75ONFQ5ufnk52dXa3BTE9Pp7CwkB07dtC1a9eGCtuWEZfdwYjL7nA6DNt+OuzX/HTYr50OIyhlJaE9PaK8tDBCkTQsE8aal8aZaUKtm7IS1Y1bqG7ELl8gELB/7L6B/fznP2fu3LmMGTOGUaNGkZ2dzZw5c0hOTmbDhg1s3ryZHj16kJ2dTadOndi7d2/VNZXl5eXExsaSmZkZ1I07oZ7y3vZRMmVHgjulEkmxieV0ucbeKQi35ALhyScUgQC88lUKBaVRwJlHw0/lI8A9/ffSNK6yYYLDvM/GLfk09DgzTSAAr61O5nBJNMHUzS/75ZLY6HjDBId7xhmobsS9zplT3gAzZswgJiaGhQsXsmzZMgYMGMCCBQt48skn2bp1a9XNOgkJCQAUFBRUNZT5+fnVfleX6OjokA79ZseAG+7PiImJqdch61O5JRcITz6hGloEC7+ue71LOvno0bVd5AM6hWmfjVvycWKcmWZoMSwI4g7uXh189LwguOstw8Ut4wxUN2Ie792WBjRt2pTZs2eTm5tLYWEhS5YsYcCAAWzcuJG0tDT8fiutZs2a0bFjR9atW1f12szMTBISEjjvvPOcCV48Y0h36FlHn9iyKdx4WcPEI+IFg1KhVx29RYsmMO7yholHRBqGJxvKmuTn55OTk3PGaexf/OIX/P73v2fPnj0cOHCA6dOnc8cddwR1Q46c26L88PMh1tNwGp12Vsnvgz6dYfIISHDfU9ZEHBPlhzsHW0/DqalueneCh0ZYT80REXN48pR3TbKysoAzJzT/zW9+w8GDB7nooouorKzkpptu4tlnG+6uQvG26CgY0wdGpMHqbfCP1dbyh34CHVs4G5uIW0X54do+cPVpdTN5BHQKbUYaEfEIY45Q1tZQRkdHM2PGDA4fPkxBQQGvvvpqtafrOO2jL1/hwZcGMnnmILbvzapxnamzhvKnf97bwJHVj2n5nBAXXf00nhePSpr02ZiUi8lOrxsvHpU0aayZlIu4jzEN5cSJEwkEAvTv39/pUIJ25GgeH66axfP3rWTquFd5eeGDZ6zzxaYPaRwX3A1ETjMtH5OY9NmYlIu4m0ljzaRcxJ2MaSi96LtdX3Fx16FER8XQsU13CooPUll5cuqZyspK3v98JmMG3u9glMEzLR+TmPTZmJSLuJtJY82kXMSd1FA6qLAkj4T45lU/x8clUFxaUPXzkrWvMyjtBmJjvHF+1bR8TGLSZ2NSLuJuJo01k3IRd1JD6aCm8c0pKsmv+rnkWCFNGiUBUFZeyrKv32JE3zsdii50puVjEpM+G5NyEXczaayZlIu4kzF3eXtRj079eGPJExw/XkHu4R0kNWlVNYfm3rztFJXm89hroyksySOvMJela95geN/bHI66dqblYxKTPhuTchF3M2msmZSLuJMaSgclNm7ByMt/wZRZQ/D5/EwaO5PV3y6msCSPYX1u4eUH1wCw/ocVLF833/XFbVo+JjHpszEpF3E3k8aaSbmIO3nyWd5utmouFB9yOgpo0hIG2Dx74ZZcIDz52JV/FKYvsL6fPhaaNXYuFtM+G7fk44ZxZhrVTc1UN2IaXUMpIiIiIraooRQRERERW3QNZZjFN3M6Aks44nBLLuCuWNzATf8/TBprbolDIsNNn6/qRkyjhjLMeo91OoLwMSkX05j22ZiWj7iTaePMtHzE23TKW0RERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbEl2ukATLNuAZTkOx0FxDeD3mPtbcMtuUB48hH3cstYU92Il7hlrKluBNRQhl1JPhQfcjqK8DApF3E3k8aaSbmIu5k01kzK5VylU94iIiIiYosaShERERGxRQ2liIiIiNiiayhFzqKoFLbsg+xDkHP45PJ/rYMLkqFrG2iV4Fh4Iq5UVApb98GuPMjJO7n8w3Un66a16kbEKGooRWqQfQhWfAvrdsHxyjN/v3q79QWQmgJDusNF7cHna9g4RdwkOw9WbobMWupmzXbrC6BbMgzuDmkdVDciJlBD6ZDn5t/B0rWvA+D3+WmR2JbeXYdx1zW/p1VSe4ejC50p+ZRVwKINsGIzBIJ8zfe51levDjDuckiKj2iI5zRTxtkJpuRTftyqm+WbIRBk4WzZZ331bAfj+0FS48jGeC4zZZydYFo+ptA1lA5KO38wf/ufvbz16C5+fcvbbN2Tye/eHOd0WPXm9XyOlMCfPv7PH8V6vH5jDjz3L9ilqS8iyuvj7HRez6ewBF74GJZtCr6ZPNWmPfDsv2DHwfDHJid5fZydzrR8TKCG0kHRUbG0SEyhVVJ7Lu4yhFH97mbTzlUUlx5xOrR68XI+RaXw0iewJ7/2dfw+6+hjUrz1fU2Kj8HLGdapP4kML4+zmng5n+JjMDOj+vXFpwumbo6WwawM/WMskrw8zmpiWj4mUEPpEgcL9vBp1j/w+6Pw+6OcDsc2L+UTCMDbq2B/HfuhhEbw2xusr4RGta9XWg6vfWr9VyLLS+MsGF7KJxCAd76A3IKzrxds3RyrsOqmpCy8ccqZvDTOgmFaPl6laygdtH7bCq59tCmBQCXHyksAuGnIVOJjmwDw5Bs3cWnq1YzqfzcAW3dn8vTbt/DnyZnExpxlz+yQuvL5d9YC3lz622qv2bV/ExPHvMC1A+9r8HhP+GqbddotnA4Xw/uZcPPl4d2uqG7AHXWzdod1mUc45R+FhV/DhP7h3a6obsAddWMyTzeU69ev5/HHH2fFihUEAgGGDRvGrFmzSE1NZdSoUcyfP9/pEM+qR8d+PDzhdcoqSlm5/u9kbvmEO3/yVNXvJ173Ag/NHMSgtBtIiG/BC+/exwPXv+TK4oa68xmUNpZBaScfkPrZxvd4bdFvGN73difCBaDiuDWVSSR8vgWG9oA2iZHZfn0dLrZi23kIKgPQJgEGdIOOLZyOLDiqG+fr5nglfJAZmW1/8QMMvRBSkiKz/frKP2rVzY6DVt20ToABF0Cnlk5HFhzVjfN1YzrPNpQZGRmMHj2azp0789hjjxEfH8+8efMYOXIkRUVF9O7d2+kQ6xQXE0/7VhcAcH5KL/Ye+oGX3pvElHFzAGiV1J4bh0zhLx9Oo0enfnRolUp6t6ucDPms6srnVAfyc3hxwf08fdciGsU6d3vnhmwoLI3c9j/bAmMvjdz2QxEIwEfr4ZNvqt90tHUffL7Vukv91oEQF+NYiEFR3ThfNxtzoKAkctv/bAvc2Ddy2w9FIACLs2DJxuo3HW3dB6u2WtOF3XoFNFLdNCgv1o3pPHkN5YEDBxg/fjzp6elkZmYybdo0HnjgATIyMti1axeAJxrK0906fDofr5nLd9lrqpaNGXg/O/d9w9+WP8M91z7vYHShqykfgMrKSp5552dMuPIRurS72KHoLCfmxIvk9utz52skLNoAS7+p/Q72jTnw2v9CZQ3zB7qZ6qbhrW6Auql0Sd18vBE+zqq9jr/ZDa+urHneTTdT3Ui4ebKhfPbZZzl8+DBz584lPv7kpH9JSUmkp6cD3mwoO7TuxoALr2Xu4kerlvn9fkb3v5fLe1xDs6atHYwudDXlA/BWxlM0bpTI9YMmORSZJRCwTvtGUvExOFQU2fcIRv5Rq5msy3d7rT+QXqK6aXi7IjzFT0kZHCiM7HsE40gJLMmqe70t+yArzNeTRprqRsLNk6e858+fz+DBg0lNTa3x98nJyaSkpADw97//nRkzZrBu3TpatWrFjh07QnqviooKcnNzg16/vDwZqP+5j3FDpzF55hWs/2EFl3QdCoDP58fnC633Ly8vJydnX73jsLZhLxc4M5+N2z9j8VevMmvy1yHGYj+f0x0pjaL4WNtqy/y+2u9ETYyv+ftTFZaeeWRl/dZDdG8dwfODQfhsRyKBQDAXcwbIyDpGc1/DTgqouqnOzXVTdMzPkdJ21ZZFom42bDnEhcnO1s0XOxOoDARzMadVN638qpv6Mr1uvCQlJYXo6NDbQ18g4JYTcsHJzc2lbdu2TJkyheefr35IvrKykrZt29KnTx8WL14MwNKlSzl06BD79u3jj3/8Y8gNZU5ODh07dgx6/TlTN3JeykUhvUddPl49j+9z1jBp7EtBv2ZH7jf88vlett433LkUleRz35/SmTruVXpfcGVIrw1HPqdrc/6l/PR31U+PJMVb05vU1xPvnnlt2fJ597Phk5frv9EwGPOrDznvkpFB/aEoLT7M7Hsa9g4d1U3t3FY3rTpdwn89va7askjUzco3J7Pu4xfqv9EwGD15AV0uvQ5fEM+GLCstYtYvGvYB5aqb2rmtbrwkOzubDh06hPw6zx2hLC4uBqixwBcuXMj+/furne4ePnw4AO+9915DhCdn8cGqWeQd2cus9x+qtvzqvrdz45CHanlV5ATzRyI87+P8lSW+EOZm0zxu7nLO1o1fdSP157a6ORd47ghlWVkZjRs3pk+fPqxevbpq+c6dO7niiivYvXs377zzDhMmTKj2uvfee4/JkydH/JT3to+SKTvi/O1+sYnldLnG3iF7t+QC4cnndIePRvPq6pRqy+o6dTd1pPX984us66tOV9Opu2t65NEz+WgYIq6/5VuTWLs7mKMnAVISyvlZ+v6Ix3Qqt4w11U3d8kuieOWr0C4VqU/djOieR1qKs3Wz4ock1uQEVzdtmpZz26Wqm/pySy4Qmbrxkvqe8vbcEcrY2Fhuu+025s6dy3XXXceoUaPIzs5mzpw5JCcns3v37rDekBMdHR3Sod/sGHDDgx5iYmLqdcj6VG7JBcKTz+naBSAu03pCxwmVgeCmQzlSEvy0KWldW9C2mbOTPA5PgLVB3Wzj48qLYsP+/7oubhlrqpu6tQ9Ao8zqT4KKSN10aUGHFs7WzdWJsCaom218DO2purHDLblAZOrmXOD8OYV6mDFjBnfffTdffvklU6dO5csvv2TBggW0a9eOxo0b13qzjsip/D7oEOG/V7FR7pjYPCUJLj2v7vWSE6FP54iHIx7m80V+Mu+YKGjbLLLvEYw2iXBZl7rXa50Al54f+XhE3MxzRygBmjZtyuzZs5k9e3a15Rs3biQtLQ2/C669EW/o0xl+iOBZqks6Q5RLhuOE/lBWUfv0JslJcN8wiPXkXkEaUp/O8H3wVwKF7OKO7qmb8ZdDWTmsz675920S4d4rIU51I+c4Y0ogPz+fnJwcRo0aVW358ePHKS8vp7y8nEAgQGlpKT6fj7i4OIciFTfpe771CLlTT3uH06BukdlufcREwZ1DrEZg+Sb47j8NQccWMLg79O6kZlKCk36e9cztU097h9MgF51kio6C2wfDllxYvhm+3Wst79ACBqdazbXqRsSjp7xrkpVlzT57+vWTb775JvHx8dx8883s2rWL+Ph4unfv7kCENfvoy1d48KWBTJ45iO17a55Bd+qsofzpn/c2cGT147V8GsXAlT0js+2e7dz3nF+/D3q0hZ8OOLnsrh/B5V289UfRa+OsLl7LJy4aropQ3XRvC+e1isy268vvs+Ka0P/ksl/8CPp1Vd04ybR8vM74hvKOO+4gEAhU+wr1Tu9IOXI0jw9XzeL5+1YyddyrvLzwwTPW+WLThzSOa9i5zerLq/kMvwjaNw/vNhvFwM39rOvNJLy8Os5q49V8hvW0jm6HU1w0TFDdRIRXx1ltTMvHBMY0lBMnTiQQCNC/f/+6V3aJ73Z9xcVdhxIdFUPHNt0pKD5I5SkPUq6srOT9z2cyZuD9DkYZPK/mE+WH266AJnVcBVFYak3A/MS71ve18fvgvwZAs8bhjVMsXh1ntfFqPifqpmmY6sbng1sGQPMm4Y1TLF4dZ7UxLR8TGNNQelFhSR4J8ScPjcXHJVBcWlD185K1rzMo7QZiY2qZ4M1lvJzPiRtSzvbH8cTUKAUlZ86Zd4LfB7deAWnBP1xJQuTlcVYTL+fTOhEmXlX7HJQQfN381wC4pFNk4hRvj7OamJaPCdRQOqhpfHOKSvKrfi45VkiTRtZzY8vKS1n29VuM6HunQ9GFzuv5dGhhTcDco23d69YkORH++2pNuxNpXh9np/N6Pu2aW3VzYbu6161J6wSYNNy6QU4ix+vj7HSm5WMCD11ObJ4enfrxxpInOH68gtzDO0hq0qpqyqO9edspKs3nsddGU1iSR15hLkvXvMHwvrc5HHXtTMineRO450pYsx2WbYa9+XW/JikerkiFKy+07qSWyDJhnJ3KhHyaNYa7h8LaHVbd7Dlc92sS4+GKblbdeOnGFq8yYZydyrR8TKAydlBi4xaMvPwXTJk1BJ/Pz6SxM1n97WIKS/IY1ucWXn5wDQDrf1jB8nXzXV8MpuTj81mTGfc9H7YfsKYJyc6DfQVQdhyi/dCyqXVEs2sbuKi9e+bMOxeYMs5OMCUfn8+qmUvPgx0HYfMeyMmD3P/UTZTPqpuOLVU3TjBlnJ1gWj4m8NyzvN1u1VwoPuR0FNCkJQywebTfLblAePKRk/KPwvQF1vfTxzp/A5FbxprqRs5GdVMz1Y2ArqEUEREREZvUUIqIiIiILWooRURERMQW3ZQTZvHNnI7AEo443JILuCsWCT+3fL6qG/ESt3y+qhsBNZRh13us0xGEj0m5iLuZNNZMykXczaSxZlIu5yqd8hYRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsiXY6ANOsWwAl+U5HAfHNoPdYe9twSy4QnnxEGoJpdeOWfLQPMJtbxhmobupLDWWYleRD8SGnowgPk3IRaSim1Y1p+Yg7mTbOTMsnGDrlLSIiIiK2qKEUEREREVvUUIqcYwIBOFx88ucDR+B4pXPxiHjB6XWzX3UjUo2uoRQ5B1Qchw3Z8NU22HUIjpad/N3MDIiJgvbNoXdnuPx8aBznXKwiblFxHLJyrLrZebB63bz8n7pp1xx6d4LLu0AT1Y2cw9RQOuS5+XewdO3rAPh9floktqV312Hcdc3vaZXU3uHoQmdaPqYIBKw/hh+ug8LS2tcrPw47Dlpf/1oHP+oBP0mD6KiGivTcZFLdmJRLIABrtsMHmXCkjrrZedD6+mg9DO4OIy+2Gk2JHJPGmkm56JS3g9LOH8zf/mcvbz26i1/f8jZb92TyuzfHOR1WvZmWj9cVlcKcFfDOF2dvJk9Xfhw++Qb+7yLYczhi4cl/mFQ3JuRSfAxe/RTeWnX2ZvJ05cdh2Sb4w0eQkxe5+MRiwlg7wZRc1FA6KDoqlhaJKbRKas/FXYYwqt/dbNq5iuLSI06HVi+m5eNlhSXw4lLYtKf+28gtgBlLraOWEjkm1Y3XcykqhZeWwsac+m9j/xGr9rYfCF9cciavj7VTmZKLGkqXOFiwh0+z/oHfH4Xf7/3zJabl4yXlx+HPy2HfWfZFfh8kxVtffl/t65WWw1+Ww8HC8McpZzKpbryWS8VxmL0c9hbUvk6wdXOswtrWfm/1A57ltbF2Nl7ORddQOmj9thVc+2hTAoFKjpWXAHDTkKnExzYB4Mk3buLS1KsZ1f9uALbuzuTpt2/hz5MziY1p5Fjctakrn39nLeDNpb+t9ppd+zcxccwLXDvwvgaP11SLN8DuOk5VJzSC395gff/Eu1BQUvu6R8us0+b3//jsf0SlfkzaD3h5H/BxFmTXcao6lLopLbfqZtKPwa9DN2GnunFH3ZzK0w3l+vXrefzxx1mxYgWBQIBhw4Yxa9YsUlNTGTVqFPPnz3c6xLPq0bEfD094nbKKUlau/zuZWz7hzp88VfX7ide9wEMzBzEo7QYS4lvwwrv38cD1L7muGE6oK59BaWMZlHbyGVCfbXyP1xb9huF9b3ciXCPtPgzLNod/uz/shy+2wsBu4d+2XYGAdTS2sBQaRVt33UZ56A+4SfsBr+4D9uZDxqbwb3f7Afh8KwxKDf+2w2HfEThSAnHR1iwPqhtneLVuTufZhjIjI4PRo0fTuXNnHnvsMeLj45k3bx4jR46kqKiI3r17Ox1ineJi4mnf6gIAzk/pxd5DP/DSe5OYMm4OAK2S2nPjkCn85cNp9OjUjw6tUknvdpWTIZ9VXfmc6kB+Di8uuJ+n71pEo9jGDR2qsVZ+azVYkbB8Mwy4AHwuOUoZCMDaHbBiM+ScckQ2KR6uSIVhF3rjLnWT9gNe3Qes/BYqI1Q3KzZb/xBz09H9E3Vz6hHZxHi4ohsM6+mNu9RVN87Xzek89O+Rkw4cOMD48eNJT08nMzOTadOm8cADD5CRkcGuXbsAPNFQnu7W4dP5eM1cvsteU7VszMD72bnvG/62/BnuufZ5B6MLXU35AFRWVvLMOz9jwpWP0KXdxQ5FZ57iY5C5M3LbP1AIW/ZFbvuhCASsKV3++nn1ZhKs05AfrbeuIy2rcCY+O0zaD3hhH3C0zGqwIuVgEXy3N3LbD9WH6+DNz848vX+kBBZtgFnLVDdO80Ld1MSTDeWzzz7L4cOHmTt3LvHx8VXLk5KSSE9PB7zZUHZo3Y0BF17L3MWPVi3z+/2M7n8vl/e4hmZNWzsYXehqygfgrYynaNwokesHTXIoMjP9sN+6ISeSvrVx13g4Ze6s+9T+1n3w/tcNE084mbQf8MI+YHtD1I1LGsr1u6wpwc5m235YsLZh4gkn1Y3zPNlQzp8/n8GDB5OaWvOFKcnJyaSkpHDs2DF++ctf0qVLFxISEkhNTeXFF19s4GhDM27oNNZ+v4T1P6yoWubz+fH5PPlRnZHPxu2fsfirV5l281xnAzNQ9qEGeA+XzK+34tvg1vtiW/Wnm3iFSfsBt+8DGmJMN0RtBiPYulm9zTrj4TWqG2d57hrK3Nxcdu/ezfjx48/4XWVlJVlZWfTp0weAiooKUlJSWLJkCV26dGHDhg2MGDGC5ORkbr755qDer6Kigtzc3KDjKy9PBmLqXO/hCfNqXH7ReQNZ+gf7F/OUl5eTk2Pv/GSwuUBw+RSV5PPs/FuZNn4eiU1ahhiL/XxMt2NfC+DkNTV+n3VXak0S42v+/nSFpdWvLdtz+Dg5Oc4ebjlcEsWuQ22DWrfiOHy6IY9eKUcjHNVJ4a4be7E03H7Aq/uA7bmRr5u9+c7XTUFpFNsPBFk3lbByQx4Xt1Xd1H8b3q2blJQUoqNDbw8911AWFxcD4KvhzoCFCxeyf//+qtPdTZo04Xe/+13V73v37s2YMWP497//HXRDmZubS8eOHYOOb87UjZyXclHQ60fK999/z4/u6WVrG+HO5YNVs8g7spdZ7z9UbfnVfW/nxiEP1fIqSzjyMd2YX33I+b1HVf186hQnZzN1ZO2/O31qlEOHj4RUD5GQckF/xk9fFfT6j01/hrX/+kMEI6rOLfsAcN9+wI37gNEPvUfXS6+r+jkSdVNQWOJ43SR36cuEJ1cHvf70p/4vq9//fQQjqk51U7uGrpvs7Gw6dOgQcpyeayg7duxIVFQUK1eurLZ8586dTJpkXVdQ2/WT5eXl/O///i+/+tWvIh1mWI247A5GXHaH02HY9tNhv+anw37tdBjGqqwob4D3cP78cXlpaLOsl5WYMbu0CfsBN+4DKo+fG3VzLMQ6KCsx42kGqpuG4wsEIjXJSOT8/Oc/Z+7cuYwZM4ZRo0aRnZ3NnDlzSE5OZsOGDWzevJkePXqc8bp77rmHr7/+ms8++4zY2Nig3ivUU97bPkqm7Ehwh+0jKTaxnC7X2Dtk75ZcIDz5mG75D0mszUmo+rmuU3cnjrA8v8i6w7Mmp5+6a5d4jFv6OPtMuUAAXvkqhYLSKODsc7H4CHB3/1wS4iJ818UpTKsbt+QTqX3Aym1JrM6ObN0kJ5Rxa/r+MEVcP4EAvLY6mcMl0dRVNxDgl/1ySWqkuqkvt+RTn1zOmVPeADNmzCAmJoaFCxeybNkyBgwYwIIFC3jyySfZunVrjTfrTJkyhVWrVrFs2bKgm0mA6OjokA79ZseA8/8WhZiYmHodsj6VW3KB8ORjup7lsPaUZxBXBs7+JI8TjpQEtx5A15Q4V3wOVxbBe0HcwZ3W0ceFXYO7bixcTKsbt+QTqX1Az+OwOvvkzxGpm+RYV9TNsKPwzzV1r3dRex8XXaC6scMt+TTk305PNpRNmzZl9uzZzJ49u9ryjRs3kpaWhv+051xNnjyZjIwMli1bRqtWrRoyVJEG06WNddwhkqccuiZHcOMhGNwdvs+FTWeZxqhFE7jpsoaLSbypS2trsv5InqtzS90M7Abf5cLGnNrXadYYbr684WISc3jvXvpa5Ofnk5OTc8b1k//93//NJ598wrJly2jd2jvzUImEqnkT6Nk+cttPaAS9Irj9UET54edDrKfhxJ32z2K/D3p3gskjzn4nrghAUuPIjusmcXCJs/fjVInyw52D4aqe0Oi0s7E+nxXnQz+x/p+IhMqTRyhrkpWVBVS/IWfnzp28+OKLxMXFcf7551ctHzx4MIsWLWroEEUibkh3+GZ3ZLY9sJu7HmUYHQVj0mFEGny1Hf75nxtYJ4+ATqHNrCHnuCHdIessR+3sGHiBu+omyg/X9oGr06z5Jv/xn7p5SHUjNhlzhLKmhrJz584EAgFKS0spKiqq+nJTM/nRl6/w4EsDmTxzENv3ZtW4ztRZQ/nTP+9t4Mjqx7R8vKZ7W+jTOfzbbZ1gHdVwo7gYSDvlEiEvHpU0qW68mEu3FLj0vPBvt1VT+LFLZzuLi4ZeqhvXMCEXYxrKiRMnEggE6N+/v9OhBO3I0Tw+XDWL5+9bydRxr/LywgfPWOeLTR/SOC6hhle7j2n5eNWNfSGxlrtUTygstebKe+Jd6/uz8fvglgEQa8z5DHcxqW68nMsNfSGpjqYq1Lr5af8zL8mQ8PDyWDudKbkY01B60Xe7vuLirkOJjoqhY5vuFBQfpLKysur3lZWVvP/5TMYMvN/BKINnWj5e1bQR3DsMGp9lMoMTd7IWlFSf3uR0Ph/8bCCcr8uPI8akuvFyLk3irLppElf7OkHXDVYz6ZabcUzk5bF2OlNyUUPpoMKSPBLim1f9HB+XQHFpQdXPS9a+zqC0G4iNqeNwk0uYlo+XtWsOk4ZDKxv/oG0UY13An35e2MKSGphUN17PpW0zq25a26yb2wfDZV3CFpbUwOtj7VSm5KKG0kFN45tTVJJf9XPJsUKaNEoCoKy8lGVfv8WIvnc6FF3oTMvH69o2g4evgR/1qHsa49P1bAePjIaLXXJ3qslMqhsTcklJgmnXwJUXWkfoQ9GjLfyfUdYsAxJZJoy1E0zJRVd3OKhHp368seQJjh+vIPfwDpKatKqaQ3Nv3naKSvN57LXRFJbkkVeYy9I1bzC8720OR1070/IxQWw0jL3Uuov18y3WXZ1Harn2Ky4aLukEg1J1t2dDMqluTMklNhquS4fBqbBqK3y5rfan4sRGW9PtnKibUJtQqR9TxhqYk4saSgclNm7ByMt/wZRZQ/D5/EwaO5PV3y6msCSPYX1u4eUHrUcarP9hBcvXzXflADqVafmYpGVTa6qQ0b0h/yhk51k3FQQCEB8L7ZtDmwTw65xFgzOpbkzKBaBFUxjVG665xLpuMvvQyccqqm6cZdJYMyUXTz7L281WzYXiQ05HAU1awgCbR8jdkguEJx8xV/5RmL7A+n76WOtpH04xrW7cko/2AeGnuqmZ6qZ+9O8qEREREbFFDaWIiIiI2KJrKMMsvpnTEVjCEYdbcgF3xSJyNm4aqybtB9wSh0SGmz5f1U39qKEMs95jnY4gfEzKRaShmFY3puUj7mTaODMtn2DolLeIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiS7TTAZhm3QIoyXc6CohvBr3H2tuGW3KB8OQj0hBMqxu35KN9gNncMs5AdVNfaijDrCQfig85HUV4mJSLSEMxrW5My0fcybRxZlo+wdApbxERERGxRQ2liIiIiNiihlJEREREbNE1lCLiScXHYMs+yD4EOYdPLv9oPXRtY321SnAuPhE3Kj4GW/dBdp71dcK/1sMFbaBLG2itupF6UEMpIp6SkwcrvoV1O6Gi8szff7XN+gLongKDu8NF7cHna9g4Rdxk92GrbjJ31Fw3q7dZXwCpKTA4FXp1UN1I8NRQOuS5+XewdO3rAPh9floktqV312Hcdc3vaZXU3uHoQmdaPuI+5cdh0QZYvhkCgeBe812u9dWrA9x8OSTGRzbGUJlUNyblYpKK4/BxFmRsgsog6+b7XOvrovZW3SQ1jmyMoTJprJmUi66hdFDa+YP52//s5a1Hd/HrW95m655MfvfmOKfDqjfT8hH3KCyFFz6GZZuCbyZPtTEHnv0X7HLhNB4m1Y1JuZigqBReWAJLvwm+mTzVN7ututlxMPyx2WXSWDMlFzWUDoqOiqVFYgqtktpzcZchjOp3N5t2rqK49IjTodWLafmIOxQfg5mfVL9O8nR+HyTFW1/+Wk7RFR+DlzOqXzfmBibVjUm5eN3RIMZ7MHVztAxmZbjvH2MmjTVTclFD6RIHC/bwadY/8Puj8PujnA7HNtPyEWcEAvD2KsgtOPt6CY3gtzdYXwmNal+vtBxe+9T6rxuZVDcm5eI1gQDM/xL25J99vWDr5liFVTclZWENM2xMGmtezkXXUDpo/bYVXPtoUwKBSo6VlwBw05CpxMc2AeDJN27i0tSrGdX/bgC27s7k6bdv4c+TM4mNOUv1O6SufP6dtYA3l/622mt27d/ExDEvcO3A+xo8XnG/tTus027hdLgY3s+0rg1zA5P2A9oHuEPmTtiQHd5t5h+FhV/DhP7h3W59qW7cVzeebijXr1/P448/zooVKwgEAgwbNoxZs2aRmprKqFGjmD9/vtMhnlWPjv14eMLrlFWUsnL938nc8gl3/uSpqt9PvO4FHpo5iEFpN5AQ34IX3r2PB65/yXXFcEJd+QxKG8ugtJMPFf1s43u8tug3DO97uxPhissdr4QPMiOz7c+3wNAe0CYxMtsPhUn7Ae0DnFdZaf2DKRK++AGGXggpSZHZfihUN+6rG882lBkZGYwePZrOnTvz2GOPER8fz7x58xg5ciRFRUX07t3b6RDrFBcTT/tWFwBwfkov9h76gZfem8SUcXMAaJXUnhuHTOEvH06jR6d+dGiVSnq3q5wM+azqyudUB/JzeHHB/Tx91yIaxbrsFkJxhY05UFASue1/tgXGXhq57QfLpP2A9gHO27THOpoYKZ99DzdeFrntB0t147668eQ1lAcOHGD8+PGkp6eTmZnJtGnTeOCBB8jIyGDXrl0AnmgoT3fr8Ol8vGYu32WvqVo2ZuD97Nz3DX9b/gz3XPu8g9GFrqZ8ACorK3nmnZ8x4cpH6NLuYoeiE7c7MZdkpKzeVr87XyPNpP2A9gENL+J1s906Cuo2qhvnebKhfPbZZzl8+DBz584lPv7kxHJJSUmkp6cD3mwoO7TuxoALr2Xu4kerlvn9fkb3v5fLe1xDs6atHYwudDXlA/BWxlM0bpTI9YMmORSZuF0gADsjfFfp0TI4VBTZ96gPk/YD2gc0vJ0RnuKntBz2F0b2PepDdeM8T57ynj9/PoMHDyY1NbXG3ycnJ5OSkgLAxIkT+eCDDygoKCAhIYFx48bx3HPPERsbG9R7VVRUkJubG3Rs5eXJQEzQ659u3NBpTJ55Bet/WMElXYcC4PP58flC6/3Ly8vJydlX7zisbdjLBc7MZ+P2z1j81avMmvx1iLHYz0e8o/CYn6LSdtWW+X2134l66oTltU1eXlh65hHJ9VsO0aNNeM+rR6JuwLv7Ae0DGk5xmZ+CksjXzYateVQkh/e8uuqmOifrJiUlhejo0NtDXyBQn2mCnZObm0vbtm2ZMmUKzz9f/RB2ZWUlbdu2pU+fPixevBiATZs20blzZ5o0acLBgwcZN24cP/rRj5g+fXpQ75eTk0PHjh2Djm/O1I2cl3JR0OsH4+PV8/g+Zw2Txr4U9Gt25H7DL5/vZet9w51LUUk+9/0pnanjXqX3BVeG9Npw5CPe0fq8PtzyVPUdZ1K8Nb1JfT3x7pnXZK54fRLrlwZfV8GIxD4AzNgPaB8QWS079OJnz2RVWxaJuvn0rSlkLvpj/TdaA9VN7Rq6brKzs+nQoUNIrwEPHqEsLi4GwFfDA0YXLlzI/v37q53u7tmzZ9X3gUAAv9/Pli1bIh6nnOmDVbPIO7KXWe8/VG351X1v58YhD9XyKjkX+WiYBwj7/J686seztA+IrJr+LkbmfVQ3DckrdeO5I5RlZWU0btyYPn36sHr16qrlO3fu5IorrmD37t288847TJgwoep3zzzzDE899RTFxcW0bNmSRYsWcdllwd2mFuop720fJVN2xN5h+3CITSynyzX2Dtm7JRcITz7iHfklUbzyVdtqy+o6dTd1pPX984vgSA1nsWs6dfeT7nn0SgnvqTvT6sYt+WgfULcjpVH85cvI182I1DzS2qpuzsYt+dQnl/qe8vbcEcrY2Fhuu+025s6dy3XXXceoUaPIzs5mzpw5JCcns3v37jNuyHnkkUd45JFH2Lx5M2+99RZt27ateeM1iI6ODunQb3YMuOFhAjExMfU6ZH0qt+QC4clHvKNdAOK+tp7QcUJlILhphI6UBD/dUFrXFrRv3qJ+QdbCtLpxSz7aB9QtEIDGmdYNZydEom56dWlBh5aqm7NxSz4NWTeePG49Y8YM7r77br788kumTp3Kl19+yYIFC2jXrh2NGzeu9WadCy+8kEsuuYRbb721gSMWkVD4fdCxZWTfIybKHRM0i4SLzwcdw9vnnSHKD22bRfY9xJs8d4QSoGnTpsyePZvZs2dXW75x40bS0tLwn+W6qPLycr7//vtIhygiNvXpBFsjeIbzko7WH0cRk/TpDN8Ff5VWyC7uCNHeesS0NBBjdqf5+fnk5ORUO91dUFDAvHnzyM/PJxAIsGHDBp566ilGjBjhXKAiEpRLz4e4CP6T94qaT2SIeFr6edAogpfuDeoWuW2LtxnTUGZlWVMlnNpQ+nw+/vrXv9KlSxcSEhK4/vrrueaaa3jxxRcdivJMH335Cg++NJDJMwexfW9WjetMnTWUP/3z3gaOrH5My0ec0ygGrupZ93r10aMtnNcqMtuuD5PqxqRcvCg2Gn4c/tl3AEhNgS5tIrPt+jBprJmQiydPedekpoYyMTGRTz75xKGI6nbkaB4frprFjElfsPfQNma8ex9/uHdZtXW+2PQhjeMSHIowNKblI8676iLYkA05h8O3zUYxML6fdb2ZG5hUNybl4mVXXmjVza4wPm0qLlp1Eymm5GLMEcqJEycSCATo37+/06EE7btdX3Fx16FER8XQsU13CooPUnnKQ1IrKyt5//OZjBl4v4NRBs+0fMR5UX649QpoEnf29QpLrQmYn3jX+r42Ph/8tD80bxLeOO0wqW5MysXLovxw60BoGq66ASb0h5ZNwxqmLSaNNVNyMaah9KLCkjwS4ptX/Rwfl0BxaUHVz0vWvs6gtBuIjallEjGXMS0fcYfkJLhv2Nn/OJ6YGqWg5Mw5807w++BnA+CSTpGJs75MqhuTcvG61okw8ara56CE4OvmpwOsm33cxKSxZkouaigd1DS+OUUl+VU/lxwrpEkjax6TsvJSln39FiP63ulQdKEzLR9xjw4trAmYu6fU7/WtE2DScOtGH7cxqW5MysUE7ZpbddMj+KmXq2mVAPf/GC7vEt64wsGksWZKLsZcQ+lFPTr1440lT3D8eAW5h3eQ1KRV1ZRHe/O2U1Saz2OvjaawJI+8wlyWrnmD4X1vczjq2pmWj7hL8yZw7zBYvR2Wb4K9BXW/JrERDOwGw3paNyu4kUl1Y1IupmjWGO65EtbugGWbYE9+3a9J+E/dXKW6aRCm5OK5Ry+63aq5UBzChdD/+uIvLFkzD5/Pz6SxM8k7spfCkjyG9bmlap31P6xg+br5TL7xz0Fvt0lLGGDzHzSh5gLuzkfMEQjAtgPw7R7IzoN9BVB2HKL90KKpNblz1zbQq0PDzzVpWt2YtE871wUCsP0AbD6tbqL80LIJdGj5n7pp3/BzTapu3JtLsNRQhll9iiISnGooI0V/TMQrTKsbt+SjfYDZ3DLOQHVTX7qGUkRERERsUUMpIiIiIraooRQRERERW1x6/5Z3xTdzOgJLOOJwSy7grlhEzsZNY9Wk/YBb4pDIcNPnq7qpH92UIyIiIiK26JS3iIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMSW/x/BpNnG91G9nQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 2, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -53,9 +53,7 @@ "\n", "circuit_ckt=QCtoCCOCircuit(qc)\n", "\n", - "qc.draw(\"mpl\", scale=0.8)\n", - "\n", - "\n" + "qc.draw(\"mpl\", scale=0.8)" ] }, { @@ -67,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -78,21 +76,21 @@ "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", + "Actions: []\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + "Actions: [['CutTwoQubitGate', [17, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [25, ['cx', 2, 3], None], ((1, 2), (2, 3))]]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + "Actions: [['CutTwoQubitGate', [9, ['cx', 1, 2], None], ((1, 1), (2, 2))], ['CutTwoQubitGate', [20, ['cx', 1, 2], None], ((1, 1), (2, 2))]]\n", "Subcircuits: AABB \n", "\n" ] @@ -115,7 +113,8 @@ " \n", " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", " num_QPUs = num_QPUs)\n", - " \n", + "\n", + " find_cuts(qc, opt_settings, constraints)\n", " interface = SimpleGateList(circuit_ckt)\n", "\n", " op = LOCutsOptimizer(interface, \n", @@ -283,7 +282,7 @@ ], "metadata": { "kernelspec": { - "display_name": "cco", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -297,9 +296,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.8.16" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From cb648eba24ced430f783a227eea6d57453bac340 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 12:01:54 -0500 Subject: [PATCH 007/128] commit before pulling changes --- .../LO_circuit_cut_optimizer/__init__.py | 0 .../best_first_search.py | 0 .../circuit_interface.py | 4 ++- .../cut_optimization.py | 0 .../cutting_actions.py | 0 .../disjoint_subcircuits_state.py | 0 .../lo_cuts_optimizer.py | 0 .../optimization_settings.py | 0 .../quantum_device_constraints.py | 0 .../search_space_generator.py | 0 .../{LO_circuit_cut_optimizer => }/utils.py | 0 .../tutorials/LO_circuit_cut_finder.ipynb | 32 +++++++++---------- 12 files changed, 19 insertions(+), 17 deletions(-) delete mode 100644 circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/best_first_search.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/circuit_interface.py (99%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/cut_optimization.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/cutting_actions.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/disjoint_subcircuits_state.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/lo_cuts_optimizer.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/optimization_settings.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/quantum_device_constraints.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/search_space_generator.py (100%) rename circuit_knitting/cutting/cut_finding/{LO_circuit_cut_optimizer => }/utils.py (100%) diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py b/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/best_first_search.py rename to circuit_knitting/cutting/cut_finding/best_first_search.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py similarity index 99% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py rename to circuit_knitting/cutting/cut_finding/circuit_interface.py index ae8a70daa..2507aba40 100644 --- a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -344,11 +344,13 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) + print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase - + print('getNumWires:', out) for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] + print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cut_optimization.py rename to circuit_knitting/cutting/cut_finding/cut_optimization.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/cutting_actions.py rename to circuit_knitting/cutting/cut_finding/cutting_actions.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/disjoint_subcircuits_state.py rename to circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/lo_cuts_optimizer.py rename to circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/optimization_settings.py rename to circuit_knitting/cutting/cut_finding/optimization_settings.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/quantum_device_constraints.py rename to circuit_knitting/cutting/cut_finding/quantum_device_constraints.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/search_space_generator.py rename to circuit_knitting/cutting/cut_finding/search_space_generator.py diff --git a/circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py b/circuit_knitting/cutting/cut_finding/utils.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/LO_circuit_cut_optimizer/utils.py rename to circuit_knitting/cutting/cut_finding/utils.py diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index b019095d5..f8ca26be2 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,15 +2,15 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.circuit_interface import SimpleGateList\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.lo_cuts_optimizer import LOCutsOptimizer\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.optimization_settings import OptimizationSettings\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.quantum_device_constraints import DeviceConstraints" + "from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList\n", + "from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer\n", + "from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings\n", + "from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints" ] }, { @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -39,14 +39,14 @@ "
" ] }, - "execution_count": 2, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import EfficientSU2\n", - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -150,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -160,7 +160,7 @@ "
" ] }, - "execution_count": 4, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -214,21 +214,21 @@ "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", @@ -242,7 +242,7 @@ } ], "source": [ - "from circuit_knitting.cutting.cut_finding.LO_circuit_cut_optimizer.utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", "circuit_ckt_wirecut=QCtoCCOCircuit(qc_0)\n", "\n", From 33c40960e2c53446f0eba51357e2485293cdd973 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 11:04:31 -0600 Subject: [PATCH 008/128] Add license blurbs --- .../cutting/cut_finding/best_first_search.py | 14 +++++++++++++- .../cutting/cut_finding/circuit_interface.py | 15 +++++++++++++-- .../cutting/cut_finding/cut_finding.py | 2 +- .../cutting/cut_finding/cut_optimization.py | 14 +++++++++++++- .../cutting/cut_finding/cutting_actions.py | 16 ++++++++++++++-- .../cut_finding/disjoint_subcircuits_state.py | 14 +++++++++++++- .../cutting/cut_finding/lo_cuts_optimizer.py | 12 ++++++++++++ .../cutting/cut_finding/optimization_settings.py | 13 ++++++++++++- .../cut_finding/quantum_device_constraints.py | 13 ++++++++++++- .../cut_finding/search_space_generator.py | 13 ++++++++++++- circuit_knitting/cutting/cut_finding/utils.py | 14 +++++++++++++- 11 files changed, 128 insertions(+), 12 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index b261400d8..d3a3ab7e5 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -1,4 +1,16 @@ -"""File containing the classes required to implement Dijkstra's (best-first) search algorithm.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes required to implement Dijkstra's (best-first) search algorithm.""" + import heapq import numpy as np from itertools import count diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index ae8a70daa..2f9deee5b 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -1,5 +1,16 @@ -"""File containing the classes required to represent quantum circuits in a format - native to the circuit cutting optimizer.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Quantum circuit representation compatible with cut-finding optimizers.""" + import copy import string import numpy as np diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index e9427bd34..16fdc9b00 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -1,6 +1,6 @@ # This code is a Qiskit project. -# (C) Copyright IBM 2023. +# (C) Copyright IBM 2024. # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 33c995b13..475853733 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -1,4 +1,16 @@ -""" File containing the classes required to search for optimal cut locations.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes required to search for optimal cut locations.""" + import numpy as np from .utils import selectSearchEngine, greedyBestFirstSearch from .cutting_actions import disjoint_subcircuit_actions diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 70236c0fd..4daa48336 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -1,9 +1,21 @@ -""" File containing classes needed to implement the actions involved in circuit cutting.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes needed to implement the actions involved in circuit cutting.""" + import numpy as np from abc import ABC, abstractmethod from .search_space_generator import ActionNames -### This is an object that holds action names for constructing disjoint subcircuits +# Object that holds action names for constructing disjoint subcircuits disjoint_subcircuit_actions = ActionNames() diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 165960ef3..9a991ec1d 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -1,4 +1,16 @@ -"""File containing the class needed for representing search-space states when cutting circuits.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class needed for representing search-space states when cutting circuits.""" + import copy import numpy as np from collections import Counter, namedtuple diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 16b50cb02..8be8a3521 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -1,4 +1,16 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + """File containing the wrapper class for optimizing LO gate and wire cuts.""" + from .cut_optimization import CutOptimization from .cut_optimization import disjoint_subcircuit_actions from .cut_optimization import CutOptimizationNextStateFunc diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 3a6d3c89a..656e32af8 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -1,4 +1,15 @@ -"""File containing class for specifying parameters that control the optimization.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class for specifying parameters that control the optimization.""" class OptimizationSettings: diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index bf7f2383e..237aa4e0f 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -1,4 +1,15 @@ -"""File containing the class used for specifying characteristics of the target QPU.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class used for specifying characteristics of the target QPU.""" class DeviceConstraints: diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index cd1508a88..535a6744a 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -1,4 +1,15 @@ -"""File containing the classes needed to generate and explore a search space.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes needed to generate and explore a search space.""" class ActionNames: diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 11d3ec34a..2e41d1449 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -1,4 +1,16 @@ -"""File containing helper functions that are used in the code.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Helper functions that are used in the code.""" + from qiskit import QuantumCircuit from qiskit.circuit import Instruction from .best_first_search import BestFirstSearch From 4251c20aec29d30c79e8f8258b6bf45a66d927e2 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 11:07:16 -0600 Subject: [PATCH 009/128] black errors --- .../cutting/cut_finding/circuit_interface.py | 2 +- circuit_knitting/cutting/cut_finding/cut_finding.py | 10 +++++++++- .../cutting/cut_finding/disjoint_subcircuits_state.py | 6 +++--- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 2f9deee5b..166e0df53 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -356,7 +356,7 @@ def exportSubcircuitsAsString(self, name_mapping="default"): out = list(range(self.getNumWires())) alphabet = string.ascii_uppercase + string.ascii_lowercase - + for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 16fdc9b00..b1f01f779 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -15,5 +15,13 @@ from qiskit import QuantumCircuit -def find_cuts(circuit: QuantumCircuit): +from .optimization_settings import OptimizationSettings +from .quantum_device_constraints import DeviceConstraints + + +def find_cuts( + circuit: QuantumCircuit, + optimization: OptimizationSettings | dict[str, str | int], + constraints: DeviceConstraints | dict[str, int], +): pass diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 9a991ec1d..5d24c6158 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -176,13 +176,14 @@ def print(self, simple=False): # ) # elif (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): - cut_actions = PrintActionListWithNames(self.actions) cut_actions_sublist = [] # Output formatting for LO gate and wire cuts. for i in range(len(cut_actions)): - if (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): + if (cut_actions[i][0] == "CutLeftWire") or ( + cut_actions[i][0] == ("CutRightWire") + ): cut_actions_sublist.append( { "Cut action": cut_actions[i][0], @@ -473,7 +474,6 @@ def exportCuts(self, circuit_interface): scc_order = np.zeros((len(scc_subcircuits), len(scc_subcircuits)), dtype=bool) - def calcRootBellPairsGamma(root_bell_pairs): """Calculate the minimum-achievable LOCC gamma for circuit cuts that utilize virtual Bell pairs. The input can be a list From 9a73c0d5bd77d5e227e5789cff9a826250e8735f Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 13:15:35 -0500 Subject: [PATCH 010/128] clean up notebook with updated print method --- .../cutting/cut_finding/circuit_interface.py | 29 ++++++++++--------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 790ca7cbe..9146dd0d5 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -80,8 +80,10 @@ def getMultiQubitGates(self): @abstractmethod def insertGateCut(self, gate_ID, cut_type): """Derived classes must override this function and mark the specified - gate as being cut. The cut type can be "LO", "LOCCWithAncillas", - or "LOCCNoAncillas".""" + gate as being cut. The cut type can only be "LO" in this release. + In the future, support for "LOCCWithAncillas" and "LOCCNoAncillas". + will be added. + """ assert False, "Derived classes must override insertGateCut()" @@ -94,7 +96,9 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): is also provided as input to allow the wire choice to be verified. The ID of the new wire/qubit is also provided, which can then be used internally in derived classes to create new wires/qubits as needed. - The cut type can be "LO", "LOCCWithAncillas", or "LOCCNoAncillas".""" + The cut type can only be "LO" in this release. In the future, support + for "LOCCWithAncillas" and "LOCCNoAncillas" will be added. + """ assert False, "Derived classes must override insertWireCut()" @@ -105,7 +109,8 @@ def insertParallelWireCut(self, list_of_wire_cuts): list_of_wire_cuts must be a list of wire-cut quadruples of the form: [..., (, , , ), ...] - The assumed cut type is "LOCCNoAncillas".""" + The assumed cut type is "LOCCNoAncillas". + """ assert False, "Derived classes must override insertParallelWireCut()" @@ -113,7 +118,8 @@ def insertParallelWireCut(self, list_of_wire_cuts): def defineSubcircuits(self, list_of_list_of_wires): """Derived classes must override this function. The input is a list of subcircuits where each subcircuit is specified as a - list of wire IDs.""" + list of wire IDs. + """ assert False, "Derived classes must override defineSubcircuits()" @@ -208,12 +214,12 @@ def __init__(self, input_circuit, init_qubit_names=[]): ) def getNumQubits(self): - """Return the number of qubits in the input circuit""" + """Return the number of qubits in the input circuit.""" return self.num_qubits def getNumWires(self): - """Return the number of wires/qubits in the cut circuit""" + """Return the number of wires/qubits in the cut circuit.""" return self.qubit_names.getNumItems() @@ -355,17 +361,12 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - print('wire_map:', wire_map) + # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase -<<<<<<< HEAD - print('getNumWires:', out) -======= - ->>>>>>> 4251c20aec29d30c79e8f8258b6bf45a66d927e2 for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - print('subcircuits:', self.subcircuits) + # print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): From b22a29a526a6a83b638220778763ef12d2482977 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 13:33:20 -0500 Subject: [PATCH 011/128] clean up printed output in tutorial --- .../tutorials/LO_circuit_cut_finder.ipynb | 27 ------------------- 1 file changed, 27 deletions(-) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 0674ac76a..3bf65a396 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -79,9 +79,6 @@ "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", - "wire_map: [0, 1, 2, 3]\n", - "getNumWires: [0, 1, 2, 3]\n", - "subcircuits: [[0, 1, 2, 3]]\n", "Subcircuits: AAAA \n", "\n", "\n", @@ -89,9 +86,6 @@ "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", - "wire_map: [0, 1, 2, 3]\n", - "getNumWires: [0, 1, 2, 3]\n", - "subcircuits: [[0, 1, 2], [3]]\n", "Subcircuits: AAAB \n", "\n", "\n", @@ -99,9 +93,6 @@ "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", - "wire_map: [0, 1, 2, 3]\n", - "getNumWires: [0, 1, 2, 3]\n", - "subcircuits: [[0, 1], [2, 3]]\n", "Subcircuits: AABB \n", "\n" ] @@ -210,9 +201,6 @@ "---------- 7 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", - "wire_map: [0, 1, 2, 3, 4, 5, 6]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6]\n", - "subcircuits: [[0, 1, 2, 3, 4, 5, 6]]\n", "Subcircuits: AAAAAAA \n", "\n", "\n", @@ -220,9 +208,6 @@ "---------- 6 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 3.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "wire_map: [0, 1, 2, 3, 4, 5, 6]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6]\n", - "subcircuits: [[0, 1, 2, 3, 4, 5], [6]]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", @@ -230,9 +215,6 @@ "---------- 5 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "wire_map: [0, 1, 2, 3, 5, 6, 7, 4]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6, 7]\n", - "subcircuits: [[0, 1, 2, 3, 4], [5, 6, 7]]\n", "Subcircuits: AAAABABB \n", "\n", "\n", @@ -240,9 +222,6 @@ "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", - "wire_map: [0, 1, 2, 3, 5, 6, 7, 4]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6, 7]\n", - "subcircuits: [[0, 1, 2, 3], [4, 5, 6, 7]]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", @@ -250,9 +229,6 @@ "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "wire_map: [0, 1, 2, 3, 6, 7, 8, 4, 5]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6, 7, 8]\n", - "subcircuits: [[0, 1, 3], [2, 4, 7], [8, 5, 6]]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", @@ -260,9 +236,6 @@ "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 243.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "wire_map: [0, 1, 2, 3, 4, 5, 6]\n", - "getNumWires: [0, 1, 2, 3, 4, 5, 6]\n", - "subcircuits: [[0], [1], [2], [3, 4], [5], [6]]\n", "Subcircuits: ABCDDEF \n", "\n" ] From 95f024da688a3c3cbcfd5e6d4e64dc76da207ecf Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 12:34:36 -0600 Subject: [PATCH 012/128] Add find_cuts tutorial --- .../tutorials/04_automatic_cut_finding.ipynb | 247 ++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb new file mode 100644 index 000000000..24558a509 --- /dev/null +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -0,0 +1,247 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatically find cuts using CKT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EfficientSU2\n", + "\n", + "circ = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", + "circ.assign_parameters([0.4] * len(circ.parameters), inplace=True)\n", + "\n", + "circ.draw(\"mpl\", scale=0.8, style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + "Subcircuits: AAAB \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + "Subcircuits: AABB \n", + "\n" + ] + } + ], + "source": [ + "from circuit_knitting.cutting import find_cuts\n", + "\n", + "# Specify settings for the cut-finding optimizer\n", + "optimization_settings = {\"rand_seed\": 12345}\n", + "\n", + "# Specify the size and number of the QPUs available\n", + "qubits_per_qpu = 4\n", + "num_qpus = 2\n", + "device_constraints = {\"qubits_per_QPU\": qubits_per_qpu, \"num_QPUs\": num_qpus}\n", + "\n", + "for num in range(num_qpus, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", + " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", + " find_cuts(circ, optimization_settings, device_constraints)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cut finding for 7 qubit circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "from qiskit import QuantumCircuit\n", + "\n", + "circ2 = QuantumCircuit(7)\n", + "for i in range(7):\n", + " circ2.rx(np.pi / 4, i)\n", + "circ2.cx(0, 3)\n", + "circ2.cx(1, 3)\n", + "circ2.cx(2, 3)\n", + "circ2.cx(3, 4)\n", + "circ2.cx(3, 5)\n", + "circ2.cx(3, 6)\n", + "\n", + "circ2.draw(\"mpl\", scale=0.8, style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", + "\n", + "\n", + "\n", + "---------- 6 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 3.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAAAAB \n", + "\n", + "\n", + "\n", + "---------- 5 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABABB \n", + "\n", + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABBBB \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 16.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "Subcircuits: AABABCBCC \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 243.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: ABCDDEF \n", + "\n" + ] + } + ], + "source": [ + "# Specify settings for the cut-finding optimizer\n", + "optimization_settings = {\"rand_seed\": 12345}\n", + "\n", + "# Specify the size and number of the QPUs available\n", + "qubits_per_qpu = 7\n", + "num_qpus = 2\n", + "\n", + "for num in range(num_qpus, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", + " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", + " find_cuts(circ2, optimization_settings, device_constraints)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 99385667fcbdd8075b7b7c974d3af0abb2132193 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 12:36:26 -0600 Subject: [PATCH 013/128] Use dataclasses for settings objects --- .../cutting/cut_finding/cut_finding.py | 39 +++++++++++++- .../cut_finding/optimization_settings.py | 53 +++++++++---------- .../cut_finding/quantum_device_constraints.py | 25 +++++---- 3 files changed, 79 insertions(+), 38 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index b1f01f779..223963d6a 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -17,6 +17,9 @@ from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints +from .circuit_interface import SimpleGateList +from .lo_cuts_optimizer import LOCutsOptimizer +from .utils import QCtoCCOCircuit def find_cuts( @@ -24,4 +27,38 @@ def find_cuts( optimization: OptimizationSettings | dict[str, str | int], constraints: DeviceConstraints | dict[str, int], ): - pass + circuit_cco = QCtoCCOCircuit(circuit) + interface = SimpleGateList(circuit_cco) + + if isinstance(optimization, dict): + opt_settings = OptimizationSettings.from_dict(optimization) + else: + opt_settings = optimization + + # Hard-code the optimization type to best-first + opt_settings.setEngineSelection("CutOptimization", "BestFirst") + + if isinstance(constraints, dict): + constraint_settings = DeviceConstraints.from_dict(constraints) + else: + constraint_settings = constraints + + optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) + out = optimizer.optimize() + + print( + " Gamma =", + None if (out is None) else out.upperBoundGamma(), + ", Min_gamma_reached =", + optimizer.minimumReached(), + ) + if out is not None: + out.print(simple=True) + else: + print(out) + + print( + "Subcircuits:", + interface.exportSubcircuitsAsString(name_mapping="default"), + "\n", + ) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 656e32af8..731ffd727 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -11,9 +11,13 @@ """Class for specifying parameters that control the optimization.""" +from __future__ import annotations + +from dataclasses import dataclass -class OptimizationSettings: +@dataclass +class OptimizationSettings: """Class for specifying parameters that control the optimization. Member Variables: @@ -70,37 +74,24 @@ class OptimizationSettings: ValueError: beam_width must be a positive definite integer. """ - def __init__( - self, - max_gamma=1024, - max_backjumps=10000, - greedy_multiplier=None, - beam_width=30, - rand_seed=None, - LO=True, - LOCC_ancillas=False, - LOCC_no_ancillas=False, - engine_selections={"PhaseOneStageOneNoQubitReuse": "Greedy"}, - ): - if not (isinstance(max_gamma, int) and max_gamma > 0): + max_gamma: int = 1024 + max_backjumps: int = 10_000 + greedy_multiplier: float | int | None = None + beam_width: int = 30 + rand_seed: int | None = None + LO: bool = True + LOCC_ancillas: bool = False + LOCC_no_ancillas: bool = False + engine_selections: dict[str, str] | None = None + + def __post_init__(self): + if self.max_gamma < 1: raise ValueError("max_gamma must be a positive definite integer.") - - if not (isinstance(max_backjumps, int) and max_backjumps >= 0): + if self.max_backjumps < 0: raise ValueError("max_backjumps must be a positive semi-definite integer.") - - if not (isinstance(beam_width, int) and beam_width > 0): + if self.beam_width < 1: raise ValueError("beam_width must be a positive definite integer.") - self.max_gamma = max_gamma - self.max_backjumps = max_backjumps - self.greedy_multiplier = greedy_multiplier - self.beam_width = beam_width - self.rand_seed = rand_seed - self.engine_selections = engine_selections.copy() - self.LO = LO - self.LOCC_ancillas = LOCC_ancillas - self.LOCC_no_ancillas = LOCC_no_ancillas - self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas @@ -108,6 +99,8 @@ def __init__( self.wire_cut_LO = self.LO self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + if self.engine_selections is None: + self.engine_selections = {"PhaseOneStageOneNoQubitReuse": "Greedy"} def getMaxGamma(self): """Return the max gamma.""" @@ -188,3 +181,7 @@ def getCutSearchGroups(self): out.append("WireCut") return out + + @classmethod + def from_dict(cls, options: dict[str, int]): + return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 237aa4e0f..dca339d34 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -11,9 +11,13 @@ """Class used for specifying characteristics of the target QPU.""" +from __future__ import annotations + +from dataclasses import dataclass -class DeviceConstraints: +@dataclass +class DeviceConstraints: """Class for specifying the characteristics of the target quantum processor that the optimizer must respect in order for the resulting subcircuits to be executable on the target processor. @@ -31,16 +35,19 @@ class DeviceConstraints: ValueError: num_QPUs must be a positive integer. """ - def __init__(self, qubits_per_QPU, num_QPUs): - if not (isinstance(qubits_per_QPU, int) and qubits_per_QPU > 0): - raise ValueError("qubits_per_QPU must be a positive definite integer.") + qubits_per_QPU: int + num_QPUs: int - if not (isinstance(num_QPUs, int) and num_QPUs > 0): - raise ValueError("num_QPUs must be a positive definite integer.") - - self.qubits_per_QPU = qubits_per_QPU - self.num_QPUs = num_QPUs + def __post_init__(self): + if self.qubits_per_QPU < 1 or self.num_QPUs < 1: + raise ValueError( + "qubits_per_QPU and num_QPUs must be positive definite integers." + ) def getQPUWidth(self): """Return the number of qubits supported on each individual QPU.""" return self.qubits_per_QPU + + @classmethod + def from_dict(cls, options: dict[str, int]): + return cls(**options) From 8e30782a2a2e412a85a19a15cbf870212718be82 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 17:49:00 -0600 Subject: [PATCH 014/128] Update tutorial to integrate with CKT --- .../cutting/cut_finding/circuit_interface.py | 4 +- .../cutting/cut_finding/cut_finding.py | 69 +++-- .../tutorials/04_automatic_cut_finding.ipynb | 243 +++++++++--------- 3 files changed, 178 insertions(+), 138 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 9146dd0d5..2d0084499 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -361,12 +361,12 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - # print('wire_map:', wire_map) + # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - # print('subcircuits:', self.subcircuits) + # print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 223963d6a..4f1849d46 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -14,19 +14,38 @@ from __future__ import annotations from qiskit import QuantumCircuit +from qiskit.circuit import CircuitInstruction from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints from .circuit_interface import SimpleGateList from .lo_cuts_optimizer import LOCutsOptimizer from .utils import QCtoCCOCircuit +from ..instructions import CutWire +from ..cutting_decomposition import cut_gates def find_cuts( circuit: QuantumCircuit, optimization: OptimizationSettings | dict[str, str | int], constraints: DeviceConstraints | dict[str, int], -): +) -> QuantumCircuit: + """ + Find cut locations in a circuit, given optimization settings and QPU constraints. + + Args: + circuit: The circuit to cut + optimization: Settings for controlling optimizer behavior. Currently, + only a best-first optimizer is supported. For a list of supported + optimization settings, see :class:`.OptimizationSettings`. + constraints: QPU constraints used to generate the cut location search space. + For information on how to specify QPU constraints, see :class:`.DeviceConstraints`. + + Returns: + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + """ circuit_cco = QCtoCCOCircuit(circuit) interface = SimpleGateList(circuit_cco) @@ -43,22 +62,36 @@ def find_cuts( else: constraint_settings = constraints + # Hard-code the optimizer to an LO-only optimizer optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) - out = optimizer.optimize() - - print( - " Gamma =", - None if (out is None) else out.upperBoundGamma(), - ", Min_gamma_reached =", - optimizer.minimumReached(), - ) - if out is not None: - out.print(simple=True) - else: - print(out) - print( - "Subcircuits:", - interface.exportSubcircuitsAsString(name_mapping="default"), - "\n", - ) + # Find cut locations + opt_out = optimizer.optimize() + + wire_cut_actions = [] + gate_ids = [] + for action in opt_out.actions: + if action[0].getName() == "CutTwoQubitGate": + gate_ids.append(action[1][0]) + else: + wire_cut_actions.append(action) + + # First, replace all gates to cut with BaseQPDGate instances. + # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. + # This may not hold in the future as we stop treating gate cuts individually + circ_out = cut_gates(circuit, gate_ids)[0] + + # Insert all the wire cuts + counter = 0 + for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): + if action[0].getName() == "CutTwoQubitGate": + continue + inst_id = action[1][0] + qubit_id = action[2][0][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), + ) + counter += 1 + + return circ_out diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 24558a509..f8b56fc2e 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Visualize the circuit" + "#### Create a circuit and observables" ] }, { @@ -21,9 +21,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 1, @@ -32,19 +32,20 @@ } ], "source": [ - "from qiskit.circuit.library import EfficientSU2\n", - "\n", - "circ = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", - "circ.assign_parameters([0.4] * len(circ.parameters), inplace=True)\n", + "import numpy as np\n", + "from qiskit.circuit.random import random_circuit\n", + "from qiskit.quantum_info import PauliList\n", "\n", - "circ.draw(\"mpl\", scale=0.8, style=\"iqp\")" + "circuit = random_circuit(7, 5, max_operands=2)\n", + "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", + "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\", fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Perform cut finding" + "#### Find cut locations, given two QPUs with 4 qubits each" ] }, { @@ -53,173 +54,179 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", - "Subcircuits: AAAB \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", - "Subcircuits: AABB \n", - "\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "from circuit_knitting.cutting import find_cuts\n", "\n", "# Specify settings for the cut-finding optimizer\n", - "optimization_settings = {\"rand_seed\": 12345}\n", + "optimization_settings = {\"rand_seed\": 111}\n", "\n", "# Specify the size and number of the QPUs available\n", - "qubits_per_qpu = 4\n", - "num_qpus = 2\n", - "device_constraints = {\"qubits_per_QPU\": qubits_per_qpu, \"num_QPUs\": num_qpus}\n", + "device_constraints = {\"qubits_per_QPU\": 4, \"num_QPUs\": 2}\n", "\n", - "for num in range(num_qpus, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", - " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", - " find_cuts(circ, optimization_settings, device_constraints)" + "cut_circuit = find_cuts(circuit, optimization_settings, device_constraints)\n", + "cut_circuit.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Cut finding for 7 qubit circuit" + "#### Add ancillas for wire cuts and expand the observables to account for ancilla qubits" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJcAAAHECAYAAACEK8sWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACELUlEQVR4nOzdeVxU9f7H8ffAgIBsigoq5I6aO5m5L1mpV0vbtLpXs+WWWZb9MrPFzCxvtmm22qbtapa5ZJZpbmXuC664oYBsyiI7DMzvDwolUGEEzszwej4ePZr5nu855z0zzmHmM+f7PSar1WoVAAAAAAAAYAMXowMAAAAAAADAcVFcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANjMbHQAAAABAxVt99ytKi4wzOoZd8WkcpP6fTTI6RoV4fLMUk2l0ikINvaSZ1xidAoCRKC4BAAAATigtMk4pEdFGx0AlicmUjqUZnQIACjEsDgAAAAAAADajuAQAAAAAAACbMSyumrFarYqJz1TkqTTlWQrk5WFW66b+8vV2NzoaAAAAAABwQBSXqoGCAqt+/TNGHy46pA074pSQlF2iT4tGvvpXzxA9NLyVWjbxr/qQAAAAAADAIVFccnJrt8ZqzLTfdSgy9aL9Dp84q7dO7NNbX+3TTX2v0LvPdFdwUM0qSgkAAAAAABwVcy45qby8Aj32yib1u2/FJQtL/7R07Um1vfV7fbPiaCWlAwAAAAAAzoIzl5xQbl6+bn9ijZauPWnzNlLTcnXXpLVKOpujh++4sgLTAQAAAAAAZ8KZS07owRd/v2hhydXVpIaBXmoY6CVXV9NFt/XI9E1a9Mvxio4IAAAAAACcBMUlJ/PDmkjNW3L4on2C6ngqetWdil51p4LqeF5ymw9O+13xZ7IqKiIAAAAAAHAiDl1c2r17t4YOHSo/Pz/5+vpq2LBhio2NlY+Pj+644w6j41W5jMw8jZn2R4VvNyk1R+Nn/Fnh2wUAOLe8Aml3kvRngnQoVbJajU4EAIDtUtNytXZrrFZtitHRqLNGxwHsisPOubR69WoNGTJEjRo10nPPPSdPT0/NmzdPgwYNUnp6ujp27Gh0xCr39YqjlXaG0cJfjuvV/7taIUHelbJ9AIDzyM6XPjssfXdCSso5197UR/p3M+mmEMl08VHZACpZw2s76aqn75Jfi2BlJSRr/ycrtH/OcqNjoQqkha9VxHP9LtrnqiX8GnC+UwkZenHOLn2x7Igysy1F7f2urq9n/9tR/bs2MDAdYB8csriUmJioESNGKCwsTL/++qs8PQuHdo0cOVJNmjSRpGpZXHpv4YFK23ZBgVUfLjqkaY9cVWn7AAA4vmyL9PCfhWcs/dPxNGnarsKzmJ5sS4EJMEpAh2bqP+8p7f1gqdaNnaW6nVqo24wHlJ+Vq0Of/2J0PFSymq26q/282BLt2VEHdHjav1T3hgcMSGW/jkenqfc9yxUdn1li2W9bY7VuW6w+fbG37h7awoB0gP1wyGFxM2bMUHJysubOnVtUWJIkPz8/hYWFSap+xaXEpCztOljKJ/kKtGpTTKVuHwDg+GbuK72wJEl//w6+8Lj0Y3SVRQLwD20eGKLTu45qx/SvlXo4RkcWrtWBT39Su0eGGR0NVcDFzV1utYKK/WdydVPku/fLp21fBd/7ptER7YbVatWt/7e61MJSUR9J903ZoL2HK/e7GGDvHLK4NH/+fPXq1UuhoaGlLg8MDFRQUJAkyWKx6LHHHlPt2rXl7++v++67T9nZ2VUZt0ps33+m0vex61CS8vIKKn0/AADHdDZXWhZ16X4mSd8cZQ4mwCj1urRSzG87i7XF/LZL3iH15FW/tkGpYBSrJU9HZ9wqFzcPNX1ygUyurkZHshsbd8Rr58GLf8+yWqX8AqveW1B5o0gAR+Bww+Li4uIUExOjESNGlFhWUFCg8PBwderUqaht+vTp+u233xQeHi53d3fddNNNmjhxombPnl2m/VksFsXFxVVY/sry567IEm2urqZSrwZX/7y2+he5Wlzc6Szl55/75J+Tm68/dx5WkwY1Ly8sAMAprT7jpdyCS38xtUo6dFbacjRODT0sl+wPwDZ5eaW/vzzr+SsrMaVYW1ZC8l/Laikz1nnPwMjLsyg62jlOnczLC5TkdtnbOfnBWGWf3KdWr2+Rq5evjVnyFB0df9lZ7M1Hi/aXue8Xy4/omdGNKjENUHWCgoJkNpevXORwxaWMjAxJkqmUiRqWLFmihISEYkPiPv74Y7366qtq2LChJOmFF17Q7bffrpkzZ8q1DFX5uLg4hYSEVEz4ylR3kBR0a7GmoDqeil5150VX2/rNsAsuC77+G8X84xTQ3r2vlXJO2RwTAOC8Aoc9oeB7Xi9z//433qqMgxV/lVMAhV4KuF4N3WwrFjiriIgIDXeEz/ZlcOXbe+V5RZvL2kb8kpk689vnavHir6oR2MTm7URERChkQNvLymKXQh6U/K8uU9f0TItCQhpJYqQHHF9UVJSCg4PLtY7DDYsLCQmRq6ur1q1bV6z9xIkTGjdunKRz8y2lpKQoKiqqWLEpLCxMaWlpioyMrKLEVcRaRb/8WvOrZj8AAIeTn1m+yzLnZ3EZZ8AIWQkp8qzrX6zN46/7f5/BBOeXuv0nRc97UleMnSOfNr2MjmOfCsoxnUpBrigsoTpzuDOX3N3dNWrUKM2dO1dDhw7V4MGDFRUVpY8++kiBgYGKiYkpKialpaVJkvz9/YvW//v238suJSgoSFFRZZhAwmA/b0rQ/dOKj52PO52l4Ou/KdG3fh3PojOWrr7zB8Wezip1m3H/aDe7mnTgwGZ5uDMOGwBQUlKui+7fa1WBLn4ZOJOsCqph0fcbfpILV4wDKs2m4a8o43jJ6R0SthxUg74dtXvmoqK2hv06Kj0qwamHxElSaGioohZ+anSMCjFuf6CibJxKNuvkPh17/Q4FDntCdfqPvuwsoaGh+tkBvjOV1+otiRr9wo4y9b25fyPNXul8zwGqp7/nsC4PhysuSdLs2bPl5uamJUuWaM2aNerWrZsWL16sF198UUeOHCma6NvHx0eSlJqaWvTkpKSkFFt2KWazudyngxlhQK9akooXl/LzrSWGtf1T7OmsS/b5W9sWtdS8KeOIAQClC5bUP0ladYnR01aZdFcLN10RYv9/XwFH5uZW+kf9fR8u1+BlL6vTpDt1bNE61enUQq3vHaStL3xWxQmrnpubY3y2Lwu3w5JsKC5Zzp7WkZdulFeTjqo35DHlJZcsQJp965ZrYm83NzeneV7P95/6DTT1owhFxqTrUtegePLeqxQcHFgluQB75JDFJW9vb82ZM0dz5swp1r537161a9dOLi6Fo/38/f0VEhKiXbt2qWXLlpKknTt3ysfHR40bN67q2JWqYaCXml/hqyMnK2+IQd/O9Stt2wAA5zCxnXQwVYrKuHCfPkHS7Y2rLBKAfziz+6jW3POqwp6+S23H3KSsxBTtmPGNDn3+i9HRUAVSt/2o3Pjjyo0/rvB7G5bap+2Hx1UjsHHVBrNDrq4uWvRGf/W9d4XSMvNKLDeZCq8W9+LDYerWgcISqjeHLC6VJiUlRdHR0Ro8eHCx9vvvv1//+9//1KtXL7m5uemFF17Q6NGjyzSZtyMxmUx68LZWevLNLZW2jwdvb1Vp2wYAOIdaNaS5PaU390k/x0jnXXRUPm6FRaUHWkpmh5v1EXAu0at3KHp12Yb7wLkEXHu3Aq692+gYDiPsyjr6/fMhmvDmFv3yR0yxZY3qe2vyg510782hBqUD7IfTfLQLDw+XpGKTd0vSM888o969e6tNmzZq3ry5WrdurRkzZhiQsPLde3OofGpe/uVIS3ND94Zq1cS/UrYNAHAu/jWkF8OkWV3OtY1rLf10gzS2NYUlAIBjaRdaWz9/MFDrPv1XUds3M/rq6IrhFJaAvzjNx7sLFZfMZrNmz56t5ORkpaam6pNPPpGnp6cBCStfbb8aev2JLpfuWE6eHq5695nuFb5dAIBz83U/d7tzHcnDuU4aBgBUM02DfYtu9+wUJBeuSgEUcZri0tixY2W1WtW1a1ejoxjqv7e21IDupY+d/tvfV5ELvv6bEleEK82rj3dR8yt8L9kPAAAAAABUP05TXEIhk8mkha9fq6vb1rlgn7+vIhcTn6n8/Itf9+CJUW318B2tKzomAAAAAABwEhSXnJCvt7t+/XCQhvQOsXkbrq4mTX+0s157ootMJk73BAAAAAAApaO45KR8vd219O3rNW9ab/n7uF96hfO0D62tLV/dpKfv70BhCQAAAAAAXJTZ6ACoPCaTSXcPbaFbr2+sr348qg8XHdTOg2dkLWUknEcNV13ftaEevqO1ru/WkMnpAAAAAABAmVBcqga8vdz04O2t9ODtrZSWkatf/ojRbU+skSS9/XQ39b4qSK2b+MvNjRPZAAAAAABA+VBcqmZ8arrrmnb1iu4P69dIwUE1DUwEAAAAAAAcGaeqAAAAAAAAwGYUlwAAAAAAAGAzhsUBAAAAgINp6GV0gnPsKQsAY1BcAgAAAAAHM/MaoxMAwDkMiwMAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2MxsdAAAux+q7X1FaZJzRMSqNT+Mg9f9sktExLpuzvE7O8noAABzTTeNW6Wj0WaNjXFSzYF8tfft6o2M4PWf5bGWP+LxnG4pLABxaWmScUiKijY6BS+B1AgDg8h2NPqv9R1OMjgE7wGcr2BuGxQEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAP5h4HdT1f31MSXavYPranTsItXr0sqAVJB4bQAAAAB7RHEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNzEYHqEz/+9//tGPHDm3fvl3Hjx9Xo0aNFBkZaXQsAE7Aq0GAes0eJ8+6frIWWBXx1a868PEKo2NBvDYAAABAVXPq4tIzzzyj2rVrKywsTCkpKUbHAS4qJzVDR79dq+hV22XJypFnXX81va2PQq6/Si5mV6Pj4R+slnxtnfqZksKPy+zloRt/nqFT6/coNSLa6GjVHq8NAAAAULWcurh09OhRNW3aVJLUtm1bpaenG5wIKF3k8j+14dG3lZ+VI5kkySRZrTqxYrN8Ggfpui+ell/zhkbHrDZyz2bK3bdmiXZ3v8K2/Jw8ZSWkKCshRZJkycxW6pFT8gqqTQGjkvHaAABQUq+rgvTEqLbq2DJAjRp467m3t+vlj3YZHQsGaXhtJ1319F3yaxGsrIRk7f9khfbPWW50LDg5p55z6e/CEmDPolfv0NoH31B+dm5hg1WS1Vq0PC0yTitvnaKM2DPGBKyGUo/EKKB9U5lcih8i63RqrgJLvtKOxxZr9w6uq4B2TXR6x+GqjFkt8doAAFCSt6dZ+4+maOLMLYpNzDQ6DgwU0KGZ+s97StG/7dTS6ydo1+sLddWku9Ry1A1GR4OTc+riEmDvrFartkyZV6Kg9E9ZCSna+97SKstV3R38bKU86vqpx6yHFdC+qXwaBarJsB7qNPEOHVnwm3LPnvvQZvbyUN9PJmjLC58pLz3LwNTVA68NAAAl/bQxWs/M3qaFPx9XTm6+0XFgoDYPDNHpXUe1Y/rXSj0coyML1+rApz+p3SPDjI4GJ+fUw+IqgsViUVxcnNExKlTs6exzt+NiJYuHgWmqt6StETp79FSZ+kZ8s1pBo3rL1bNGJadyLHl5lgrfZkb0aa248VmFPXWn+n82SW6+Xko/Ea+97y3V/o9/LOpnMruq3ycTdPyH33Vi+aYKzyEVPr7oaMcfzlVRr5PRr42zvB5VJT7DTVJg4e2EePll5BkbCKhmKuNvpKNz9OO4Jc/+j6OWvDyHfo4vxp6+R13o/V2vSysd/np1sbaY33ap7dih8qpfW5mxSVURz6E5+nGiIgQFBclsLl+5iOLSJcTFxSkkJMToGBXLXEtq/ZokqcvVXSRLssGBqq9BNUM13KddmfrmZ2Sr55VhiracreRUjuWlgOvV0M23wrebvP+EVt/9ykX79HhzrFIPR2vf+5V3VllERISGO8ExqCJfJyNfG2d5PaqKV/POav3GVknSjUOGKPPINoMTAdVLZf2NdGQOfxxvMVXysO95OCMiIhQScqfRMSqHHX2PutD727Oev7ISU4q1ZSUk/7WsFsWlMnD440QFiIqKUnBwcLnWobgEGMhUzv4u5V4DlaVel1ZqfnsfJe0/oZtWFX7I2PnaAkX9wpdno/HaAAAAAFWL4tIlBAUFKSoqyugYFSr2dLa6jFonSdqydYvq12FYnFES1oVrz4RPytTXxd2stXu2yM3Hq5JTOZZNw19RxvGqH7qasOWg5tW/rdL3ExoaqqiFn1b6fipbVb5OlfnaOMvrUVUiMtw08VDh7WXLlyu0pv0P5wCciVF/I+2Zox/H+4/ZqIiTGUbHuKjQ0FCtXuNc35/+Zk/foy70/s5KSJFnXf9ibR5/3f/7DCZcnKMfJypCUFBQudehuHQJZrO53KeD2T3zuT9I9YPqKzio5GW9UTUajKivw699X3igv/B83pKkpjf3UpPWoVUTzIG4uTn3YczNzTmOQc7yOjnL61FVUpMl/VVcCqwXqOBahsYBqh1nOfZWJEc/jpvd3IyOcElmNzeHfo4vyo6+R13o/Z2w5aAa9O2o3TMXFbU17NdR6VEJDIkrI0c/ThiFq8UBBnIxuyrsqTsKC0sXGvFmMslc00Ntxw6tymgAAABwEDU9zerQsrY6tKwtdzcXBdXxVIeWtdUsxMfoaKhi+z5crrqdmqvTpDvl17yBmt3eR63vHaTwd34wOhqcnFP/nPHFF1/oxIkTkqTExETl5ubqpZdekiQ1atRII0eONDIeIElqcWd/5aSka9uLXxRfYJJkldy8PXXd55PkH0r1HAAAACV1blNHaz8dXHT/kTuv1CN3Xqm1W2PV774VBiZDVTuz+6jW3POqwp6+S23H3KSsxBTtmPGNDn3+i9HR4OScurj0ySefaN26dcXaJk+eLEnq06cPxSXYjbYPDVVw/6u0642Filz6hyTJp1GQWt59g5oP7yeP2vzqBAAAgNKt2xYnU/uyzeMJ5xe9eoeiV+8wOgaqGacuLq1du9boCECZ+YcGq82Ym4qKS73fG6+6nZobnMrx/OfYVzq984gkaf/HP+rkT1uKLe/4xHA1v6OfUg9Ha9VdL0sqfO67vfagrAVWWS35+v2J95V+MuGC+wjo0ExdXrxHJheTDnz6k44v3lhsefPhfdXh/25XRsxpSdKqf7+s/OzcUtfzDq6rG395VckHTkqStk//SonbIyrs+bBH3sF11fu98SqwWGRyddWfkz5S8oETxfr0eHOsfBoHyuzloWPfrdf+j36UdOnX93wDv5sqFzezCvIsitu0T7teX1hs+ZX/HawmN/dUQV6+ksKPafNzn5ZpPQAAAADFOXVxCUD1kxFzWitvnXLB5Ye++EVHvl2rbq/8t6gt+8xZ/fqf/ykvLVMN+3VUh8dv0++Pv3fBbVwz7V6te2imsk+navDy6Yr6eZssmdnF+kR8uarE2PbS1pOk07uOFBW6qoOM2DNaMfQ5yWpVUI+2av/oLVr30MxifTY99aEK8iwyubro5vVv6dCXq5SflXvJ1/effrvvNWUlppS6LGrV9qKiVZ/3H1dgtysVv2n/JdcDAAAAUBwTegNwKp6BtTTw+6nq8/7j8gjwLbE8KyFFKih+ab7sM2eVl5YpSSrIy5c1v+CC23et4SYXd7MyYk4rPydPCdsOKaBD0xL9mo/op0FLpqnNQzddcr3abZto0A/T1O21B2X2rGHrQ3cY1vwCyVr4Grj7eCppf2SJPgV5FkmSaw13pUUlKD+78BL2l3p9i+3HalXfj57QDfMnK6BDsxLL0yLPXb63wGIpet0vtR4AAACA4jhzCYBT+a7rw8pJSlOTm3vq6hfu1oZxb5d5XVcPd3V8crg2PfXRBfu4+3srN/XcZWhzUjNUw9+7WJ+TK7fo6KL1Mrm6qN8nTyop/LhSDkeXul7i9gh91+0RWTKy1e7RW9Ru3M3a+er8cjxix1S7TWN1feW/qtmgjn6777VS+/R5/3EFdb9Shz5fVVSMKs/ru/aBN5STlCbfZg107adP6oc+j5far16XVvIKqq2ELQfLtR4AAACAQpy5BMCp5CSlSZIil/6h2m2blHk9k6uLer/3mPa9v1QpB09esF9uaobc/WoW3Xf3ramclPTifc5mylpQoII8i06s2Kza7ZpccL2CXIssGYVD6o7/sFG125U9syNL2hepFTc+q9WjX9E10+8rtc+6h2Zq0TUPq+G1neT319USy/P6/t337NFTyk5KU41SznTya9FQnZ8bqbUPvlmu9QAAAACcQ3EJgNMwe9aQyaXwsBbY9cpiw54upccbD+nU2t06uXLrue3V9JC7r1exfvnZuSrItcgrqLZc3M2q1zlUZ/YcK9bHzefcOkHdrlTa8dgLrufm7Xmub/e2SjseW67H7Ihc3M+dNJt3NlP5WbkX7JOfnStLVo7ys3Iv+PqW9jpJKnpuawT4yrOuf1HR6G81G9ZRz7ce0fqH3yq27FLrAQAAACiOYXEAnIZfi4bq/voY5WVkqyAvX5smzpEkNezXUe7+3jq+eKNC/3Odmt3eR37NG+qGBc9rw6Nvq/aVjdT4pu7yDqmnJkN7KGnfcW15fp6aDOsps4e7Dnyyoth+tjw/V33m/J9MLibtm7NMloxsedb115UPDtH2l75UmzE3qmHfjrIWFOj0rqNFBavS1gu+7ip1fHK4LJk5ykvL0sbH363y562q1bu6lTpOGC5rfoFMJpO2vDBPUvHX6bovnpGL2VUu7mZFLt+k9KgEBbRvWurrW+rrZDJpwHcvKD87Vy5ms7Y8P1eyWou9Tp2fGymP2r7qOethSVL4O4sVs3Z3qesBAAAAuDCKSwCcxpk9x7Tshokl2mN+21V0O+LLXxXx5a/Fl8cn68um/y6xXq1WIdo967sS7ad3HdFPQ58r1paVmKLtL30pSdr12gLtem1BmdaL/nW7on/dfuEH5YTift+rlb/vLdF+/uv0y4gXSyy/0Otb6utktWr5gKdK9D3/dfrnFer+Vtp6AAAAAC6M4hIAXMCWyXONjoAy4HUCAAAAjMWcSwAAAAAAALAZxSUAAAAAAADYjGFxAByaT+MgoyNUKmd5fDwOAAAAwHlRXALg0Pp/NsnoCCgDXicAAADAeTEsDgAAAAAAADajuAQAAAAAAMrlhgXPq+esh42OATtBcQkAAAAAAAA2Y84lAAAAAACqoVajB6rVPQPk0yhIuWmZit98QGvvf123bXlPEV+v1p5Z3xX17f76GPk2qa+Vt05Rz1kPq0Hv9pKk5iP6SZJW3jJFcZv2XXR/t215T0cXrVeN2j5qOqyn8vMs2v3mt4r46ldd/fwoNb21tyxZOQp/e7EOzl1ZtJ5nPX91mXqPGvbrKBd3s07vPKKtL36uM7uPSiaTbtv6ng59vkrhs78vWsfF3awRuz/Wtmlf6PDXqwsf772D1PqegfIOrquMU2d0ZOFvCn/nB1nzCyrsOa2uKC4BAAAAAFDNdJwwXG3G3KjtL3+lU+t2y1zTQ8HXdirTupsnz5V3o0BlxSdry+S5kqSclPQyrdv63kHaNfNbLRv4lJoM66Gu0+9XcP8wndqwR8sHTVLjG7vpmpfuVezve5UaES1JunbuU3J1N+vXUf9T7tlMdRh/q26YP1nf9xinnKQ0Hftug5rd1rtYcemKAVfLtYabIpdtKny8TwxX8zv6acvzc5W0N1J+LRqq26sPyLWGu3a+Or88Tx1KwbA4AAAAAACqEbNnDbUdO1S7Xv9WB+eu1NljsUoKP649b31/6ZUl5aVlqiDXovzsXGUlpigrMUUFeZYyrRu3aZ/2z1mutMg47Xnre+WmZcqaX1DUFv7OD8o9m6n6PdpKkur3bKe6YS207uG3lLDloFIOntSGR99Wfk6eWt09QJJ09Nu18m8RrIAOzYr20+z2vjq5cqvy0jLl6umutg8P1aaJc3Typy1Kj0pQzJqd2jljvlrfO6iczx5Kw5lLAAAAAABUI/4tQ2T2rKFT63ZX+b6T9kWeu2O1KvvMWSUdOFG87XSqPOr4SSrMmp10tugsJkkqyLXo9M7D8m8ZIklKPXJKiTsOq9ltfXRm91F5BPiqYd8OWj16RuE2Qgsfb9+PJ0hWa9F2TC4uMnvWUI0AX+WcOVt5D7oaoLgEAAAAAACKWAuskslUrM3FrWLKBwWW/H/szCprXn6JfiYXU4m2izn67Tp1eOJ2bZ36mZre0kvZSWk6tXb3X9sqHLS19r9v6Oyx2BLr5iaXbUgfLoxhcQAAAAAAVCMpEdGyZOWoQZ8OpS7PPp0qr8Baxdpqt21S7H5BnkUm18ovKaQcipJHbV/5hQYXtbm4m1WnUwslH4oqajv2w0a5+3ipYb+OanZ7Hx37foOsBQVF27Bk5cinUaDSIuNK/Pd3P9iOM5cAAAAAAKhGLJnZ2jdnmTpOuF352bk6tX63XD3cFdw/TOFvL9apDXvU6u4BhfMTRSeq5agb5B1cR0nnTdqddjJB9Xu0kU+jQOWmZSr3bKas/zwrqQLEbgxX4o7D6vPuY/rzmY8LJ/R+/Da51nDToc9+LuqXm5Ku6NU71OnJOxTQrok2PPpOsce75+3FCnv6LskqndqwRy6uLqrVupFqt22i7S9/WeG5qxuKSwAAAAAAVDM7Z8xX9pmzan3fIF099W7lpmYo/s8DkqTwd36Qd3Bd9fngcRVY8nVo3s+KXLZJvk3qF62/74OlqtX6Ct20+nW51fTUylumKG7TvkrJuuaeGeoy9R5d98UzcnE36/SuI/rljmnKSUor1u/IwrXqP+8pnQk/rpSDJ4st2zNzkbLik9X6noG6esooWbJzdfZYrI4s+K1SMlc3FJcAAAAAAKiGDny8Qgc+XlGi3ZKRrQ3j3r7ouuknE7Ty5ufLtb9FXcaWaPu++7gSbYt7PVbsflZCitY9NPOS24/6eavm1b/tgssPf71ah79eXYakKC/mXAIAAAAAAIDNOHMJAAAAAABclnaP3qL2j958weVfNR9ZhWlQ1SguAQAAAACAy3Lo818UufQPo2PAIBSXAAAAAADAZclNSVfueVeTQ/XCnEsAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANjMoYtLu3fv1tChQ+Xn5ydfX18NGzZMsbGx8vHx0R133GF0PAAAAAAAgHJJiYjWqfV7lLD1oCzZuUbHKROz0QFstXr1ag0ZMkSNGjXSc889J09PT82bN0+DBg1Senq6OnbsaHREAAAAAACqVGDX1mrz4E2q3baxvIPraseMb7Rn1ndGx0IZRC77Q+HvLdGZXUeL2mrU8laLf1+nDo/dKjdvTwPTXZxDFpcSExM1YsQIhYWF6ddff5WnZ+ETPHLkSDVp0kSSKC4BAAAAAKods5eHUg5H6djiDery4j1Gx0EZ7X7zW+18bYFkKt6ek5Kuve/8oFNrd2nAoqmq4VfTmICX4JDD4mbMmKHk5GTNnTu3qLAkSX5+fgoLC5NEcQkAAAAAUP3ErNmpHdO/VuTSP1SQm2d0HJRB9OodhYUlSbL+Y+Ff95P2RmrTxDlVmqs8HLK4NH/+fPXq1UuhoaGlLg8MDFRQUJAkaeHCherZs6e8vb3VuHHjKkwJAAAAAABwcfs/+rFM/SKXb1JGzOlKTmMbhxsWFxcXp5iYGI0YMaLEsoKCAoWHh6tTp05FbbVq1dIjjzyi+Ph4zZw5s9z7s1gsiouLu6zM9ib2dPa523GxksXDwDQ4X2pCfNHthIR45UTz2gBwXPEZbpICC28nxMsvg19PgaqUl2cxOoLdycuzKDo62ugYNrPk2f9x1JKX59DP8cXY0/co3t+Vp6qPE7kp6Tq1bnfZOhdYteuLn9ToP/0qNVNQUJDM5vKVixyuuJSRkSFJMplMJZYtWbJECQkJxYbEXX/99ZKkH374wab9xcXFKSQkxKZ17Za5ltT6NUlSl6u7SJZkgwPhb43NtTSlzrWSpCFDblQkrw0AB+bVvLNav7FVknTjkCHKPLLN4ERA9fJSwPVq6OZrdAy7EhERoeGO/Nm+xVTJo6HRKS4qIiJCISF3Gh2jctjR9yje35Wnqo8TQa7e+l/dAWXuP+vlV7Xo6VGVmEiKiopScHBwudZxuGFxISEhcnV11bp164q1nzhxQuPGjZPEfEsAAAAAAMD+ZVnLdxZaltU+z2B0uDOX3N3dNWrUKM2dO1dDhw7V4MGDFRUVpY8++kiBgYGKiYmp0OJSUFCQoqKiKmx79iD2dLa6jCoszm3ZukX16zD0yl6k7juhraMLh28uX75Mfm0aGZwIAGwXkeGmiYcKby9bvlyhNe3zwxDgrDYNf0UZx51reofLFRoaqqiFnxodw2b9x2xUxMkMo2NcVGhoqFavca7vT3+zp+9RvL8rjxHHiS2j39TZ/SdLTuZditdXfKkPmgZVap6/57AuD4crLknS7Nmz5ebmpiVLlmjNmjXq1q2bFi9erBdffFFHjhy54ETftjCbzeU+Hczumc/9QaofVF/BQfZ5KcPqqEbiuXHc9eoFqq6z/dsDUK2kJkv6q7gUWC9QwbUMjQNUO25uDvlRv1K5uTn2Z3uzm5vRES7J7Obm0M/xRdnR96iLvb/NXh7ybVJYHHBxM8uzrr9qt2msvIxspUVSkLoUI44TOQ8O1YZH375kv6AebdWqd+cqSFR+DvkXx9vbW3PmzNGcOcUvw7d37161a9dOLi4ON9oPAAAAAIDLVqdDMw38fmrR/db3DlLrewcp7o99WnnrFAOT4UKa3tZbpzbs0dFv10kmlXoGk2dgLfWc+XCVZysrhywulSYlJUXR0dEaPHhwsfb8/Hzl5eUpLy9PVqtV2dnZMplMqlGjhkFJAQAAAACoHHGb9mle/duMjoFyMJlM6jnrYfk2baD9Hy1XTlLauWUuJoUMuFrXTLtXNRvWMTDlxTlNcSk8PFxSycm8v/jiC91zzz1F9z09PdWoUSNFRkZWYToAAAAAAIDSmVxc1GH8rWr70E06+t16/fHE+5Kkfy3/n+p2am5wuktzmvFjFyoujR49Wlartdh/FJYAAAAAAIC9ca3hpoZ9Oxbd9wp0jEkrnaa4NHbsWFmtVnXt2tXoKAAAAAAAANWG0xSXAAAAAAAAUPUoLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJuZjQ4AAAAAAADKzqdxkNERnBbPrW0oLgEAAAAA4ED6fzbJ6AhAMQyLAwAAAAAAgM0oLgEAAAAAAMBmDIsDAAAAACc2d1ovjR4aKknKyytQanquDh5P0dJ1J/Xu/APKzLIYnBCAo6O4BAAAAABObv32OA2fsEYuLiYF+NdQz06Bevq+Drrv5lD1Hv2jEpKyjY4IwIExLA4AAAAAnFxuXr7iz2QpNjFTew8n64OFB9Vt5DLVreWpV8ZfXdRv7IjW2rf4FmVvG634tXdp0ZvXSpKahfgo9Y+RGv+fNkV9WzXxU/rmUfrvrS2r/PEAsC8UlwAAAACgGjqVkKmvfjyiW/o3lskkvTC2k2Y8frXeW3BA7W79XgMf+lk7DpyRJB2NStNDL/2hV8ZfrU6tA1TD3VULXrtWP66P0kffHTL4kQAwGsPiAAAAAKCa2nc0RX4+7goJ8tbE0e01+d3tenf+gaLlO/8qLknS1yuO6rquDTR/Rj/9vitePjXd9N+pG42IDcDOcOYSAAAAAFRTJlPh/4PqeMrTw6xf/oi5aP9H/rdJZrNJo25srrueWquz6XlVkBKAvaO4BAAAAADVVJtmtZRyNkdWq7VM/ZuH+KpBXS9ZrVLzK3wrOR0AR0FxCQAAAACqoQb1vPTvwc30/eoT2n80RVnZFt3QveEF+3t5mjX/1X6av/KYJry5Re8+003NQnyqMDEAe8WcSwAAAADg5NzdXBUY4CkXF5MC/GuoZ6dAPX1fByUkZenpt7YqI8uiNz7fqxceClNWdr5W/Rkjzxpm/atXsF75ZI8kafZTXeXqYtIj0zcpI8ui665poG9m9FP3UctksZTtzCcAzoniEgAAAAA4ud5XBSnut7tksRQoNT1XB46l6J35+/Xu/APKzLJIkia/s12Jydl69N9XaubEa5R8Nlfrt8dJkm6/oYn+M6S5uo1cpoy/+o+evF67v71Z0x/trIlvbjXssQEwHsUlAAAAAHBi90zeoHsmbyhT39lf7dPsr/aVaP/2l+P69pfjxdrOpOQo+Pr5FZIRgGNjziUAAAAAAADYjOISAAAAAAAAbMawOABAhVl99ytKi4wzOkaV82kcpP6fTTI6BuyEvbwP7Pnfpb08R2Vhz88jAAD2guISAKDCpEXGKSUi2ugYgKF4H1wazxEAAM6FYXEAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGzGnEsAAAAAAJTCarVqS3ii/tyToA074ova739hg65pV09XXRmg/tc0UE0vNwNTAsajuAQAAAAAwHly8/L18XeH9O6CA9p/NKXE8p//iNHPf8RIkvx83DX6phZ6fGQbNWrgU8VJAfvAsDgAAAA4jIHfTVX318eUaPcOrqvRsYtUr0srA1IBcCbb95/WVSOW6OHpm0otLP1Talqu3vpqn9rc/L3eX3BABQXWyg8J2BmKSwAAAAAASPpsyWFd8++l2nskudzrZmRZNPblP3T7E2uUk5tfCekA+0VxCQAAAABQ7X2+9LBGT16v/PzSzzxydTWpYaCXGgZ6ydXVdMHtfL86Urc/sUZ5eQWVFRWwOxSXAAAAAADVWnhEku5/YeNF+wTV8VT0qjsVvepOBdXxvGjfZetOavrHuyowIWDfmNAbAAAATsWrQYB6zR4nz7p+shZYFfHVrzrw8QqjYwGwU3l5BRo9eb3yLBV7ptFLH+3S0H6N1LFVQIVuF7BHDn3m0u7duzV06FD5+fnJ19dXw4YNU2xsrHx8fHTHHXcYHc8upablau4PEUX3x0z7XcvWnlR+PqdsAgAA52C15Gvr1M/0Q5/H9ePgZ9Tq7gHyCw02OhYAOzV/5VHtOHCmwrdrsVj19FvbKny7gD1y2OLS6tWr1bVrVx06dEjPPfecpk+frujoaA0aNEjp6enq2LGj0RHtznerjqtB/2/0/Hs7itp+3BClmx5dpTY3f68jJ88amA6AMwvs2lrXzn1Kt219X6NjF6n9+FuNjgTYnZ6zHtYNC54vddno2EVqemuvKk5kn3LPZsrdt2aJdne/wrb8nDxlJaQoKfy4JMmSma3UI6fkFVS7SnMCcBzvLThQadv++Y9oHYvmexacn0MWlxITEzVixAiFhYVp586devLJJ/XII49o9erVOnnypCRRXPqHFRuiNHzCGmXlWEpdfigyVX3v/VGxiZlVnAxAdWD28lDK4Shtm/aFMuPLf/UVAPhb6pEYBbRvKpNL8Y+xdTo1V4ElX2nHY4u1ewfXVUC7Jjq943BVxgTgIA6fSNWfexIrbftWq/Tl8qOVtn3AXjhkcWnGjBlKTk7W3Llz5el5biI1Pz8/hYWFSaK4dL6CAqvGz/hTVhUe3C4kJiFTr38WXmW5AFQfMWt2asf0rxW59A8V5OYZHQeAAzv42Up51PVTj1kPK6B9U/k0ClSTYT3UaeIdOrLgN+WePfdDmdnLQ30/maAtL3ymvPQsA1MDsFdb9lZeYakq9wEYzSEn9J4/f7569eql0NDQUpcHBgYqKChIOTk5RWc0JSYmqn79+ho3bpzGjRtX5n1ZLBbFxcVVVHRDbNh5RofLOOTt4+8OaszNQfKs4VrJqVCa1IT4otsJCfHKifYwMA1Qfnl5pZ8d6ezy8iyKjo42Oobdic9wkxRYeDshXn4Z1aOwaC/vA3v+d3k5z1FG9GmtuPFZhT11p/p/Nkluvl5KPxGvve8t1f6PfyzqZzK7qt8nE3T8h991Yvmmy8pqr8/jpdjLv0V74sivpyRZ8uz/OGrJy3Oo53jdlshi911dTRe8Elz989rrX+RqcXGns5Sff+5X/a17ExzqOYHxsuNTim7HxsbKo6BqfyAJCgqS2Vy+cpHDFZfi4uIUExOjESNGlFhWUFCg8PBwderUSVJhYSgoKEi//PKLmjZtqj179mjAgAEKDAzU8OHDy7y/kJCQCn0MVa7uICmobPObnM2wKLRNdynnVCWHQmkam2tpSp1rJUlDhtyoSAvDh+BYXgq4Xg3dfI2OUeUiIiI03NH/VlQCr+ad1fqNrZKkG4cMUeaR6jGp6eW8D4K6t9G/j3xRITns+d/l5R4rkvef0Oq7X7lonx5vjlXq4Wjte3+pzfuR7Pt5vJTqeky+GEd+PSVJLaZKHg2NTnFRERERCgm50+gYZRd8n1SrW9HdoDqeil516fxbvxl24U1e/41i4s+dRZlwJtPxv1OiStVy8dSb9f4lSerSpYuSq7i4FBUVpeDg8l0Iw+GKSxkZGZIkk8lUYtmSJUuUkJBQNCSuZs2amjZtWtHyjh076qabbtLGjRvLXFxyDuUc/WhyyNGSAAA4vMQdh7XxsXdKtN+6qWQbLqxel1ZqfnsfJe0/oZtWvSZJ2vnaAkX9Uj0KnADKo+T3SsfcB2AshysuhYSEyNXVVevWrSvWfuLEiaLhbheabykvL08bNmzQhAkTyry/oKAgRUVF2ZzXHvz0e7weeHlXmfq6u7lo56718q3pVrmhUKrUfSe0dfRMSdLy5cvk16aRwYmA8tk0/BVlHHfsocS2CA0NVdTCT42OYXciMtw08VDh7WXLlyu0pv0P56gIl/M+yM/OVVpkxbyH7PnfZWUfKxK2HNS8+rdVyLbs+Xm8lOp6TL4YR349Jan/mI2KOJlhdIyLCg0N1eo1jvP9afL7BzRv2cmi+3GnsxR8/Tel9q1fx7PojKWr7/xBsadLP5sk7h/t/r41FO7g3ylRtbLjU7RxyAuSpC1btsgj0L9K9x8UFFTudRyuuOTu7q5Ro0Zp7ty5Gjp0qAYPHqyoqCh99NFHCgwMVExMzAWLS4888oh8fHw0atSoMu/PbDaX+3QwezP6lgZ6fs4hxZ/JuuiE3pL078HNdGXLJlUTDCXUSMwuul2vXqDqOvi/PVQ/bm4O92elQri5Of7fisqQmizpr+JSYL1ABdcyNE6VsZf3gT3/u7SX56gs7Pl5vBRHep6riiO/npJkdrP/H4DNbm4O9Rz3vCqjWHEpP99abEjbhcSezipTP0m66sq6DvWcwHgZLufN71W/vmo2CDAwTdk45Pin2bNn64EHHtDmzZv1xBNPaPPmzVq8eLEaNGggLy+vUif6/r//+z9t2rRJP/30k9zd3Q1IbRw3NxdNHRt20cKSySR5e5k18Z72VRcMQLVh9vJQ7TaNVbtNY7m4meVZ11+12zSWT+Py/yoCAABQUTq3qeMU+wCM5pA/Z3h7e2vOnDmaM2dOsfa9e/eqXbt2cnEpXjMbP368Vq9erTVr1qhOner5xn7gtlY6k5KjZ2YXn2vAZJKsVsm3ppuWvX2DWjXxNyYgAKdWp0MzDfx+atH91vcOUut7Bynuj31aeesUA5MBAIDqrH1obbVq4qeDx1MrbR93DGxaadsG7IVDFpdKk5KSoujoaA0ePLhY+6OPPqo1a9bot99+U926dQ1KZx+evr+Dbup7hd5bcEDL1p1URpZF9et66u4bW+ieYaGqU4vL3gOoHHGb9lXY/CeAs9o4/t0LLuP9AwCVw2Qy6aHhrfXYjD8rZftd29dVx1b2P6QJuFxOU1wKDw+XVHwy7xMnTujtt99WjRo11KTJuXmEevXqpZ9++qmqI9qFNs1r6d1nu+vdZ7sbHQUAAFRzrp7uGrBwivxbBGvTUx/q+JLfS/Tp9c6j8rkiUCZXFx2ct1JHv11XypYKXfnfwWpyc08V5OUrKfyYNj9XcuLma16+TwHtm8rk6qJdry1QzG+7dMW/rlGbB2+UtaBAeWlZWj92lvLSq/ayzwCMc+/NoXrzi706cSq9wrf94sNXVfg2AXvk1MWlRo0ayXqpGawBAABgiIIci3679zW1HHXDBfvsemOh0o7HycXdrKFr3tTxH35XQZ6l1L5Rq7Zr/0c/SpL6vP+4ArtdqfhN+4uW+7VoKL8WwVpx47PyrOuv/l8+rZjfdil61XadXLFZktTxyRFqeksvHfr8lwp8pADsmbeXmz6d2kv9/1uxJyD899aWur5bwwrdJmCvHHJC79KMHTtWVqtVXbt2NToKAAAAysBaUKCsxJSL9kk7HidJKsi1SFbrRX84TIuMK7pdYLHIml9QbHlWfLLyc3JlcnWRu5+XcpLSCvueV6wye9ZQ8iEuGQ5UN9de00BTxnS6aJ+401kKvv4bBV//jeJOX/zsxrDWAXpjQpeKjAjYNac5cwkAAADOq+3DwxT545+yWvIv2bdel1byCqqthC0Hi7Xnns1U+skE3fL72zJ7umvdQ7OKljUf3ldXPnij8rNzFf7uDxWcHoAjmPJQJ+XmFeh/n+wudXl+vlUx8ZmX3M5VV9bRyvcHyKdm9bpKOao3pzlzCQAAAM6pydAeCmjXRDtnzL9kX78WDdX5uZFa++CbJZY16NNBnvX89V23R7S4z+PqMu1emVwLPw4fWbhWS/s/oeNLf1fbh26q8McAwP6ZTCZNf6yzFrzWz+aLHT1615Va9+m/uFgSqh2KSwAAALBbDfp2UIs7r9WGR9+WzhsSV7NhnRJ9azaso55vPaL1D79VNOStGJOUk5IuWa3KS8+Sq7tZLmZXubifO5k/NzVT+dm5lfJYADiG4QOaat/3t2jcXVfK19utTOsM7BGs9XMH661J3VTTq2zrAM6EYXEAAAAwTN+PJyigbRNZMrNVJ6yFtk6Zp4b9Osrd31vHF29Ur7ceUWZ8sm74ZrIkad2YmcpOTtO1cydq2Q0Ti22r83Mj5VHbVz1nPSxJCn9nsWJ+26UuL47WrjcXKXZ9uJoO66lBP0yTaw03HfjkJ+Xn5KnNmJsUcn3hFZ1yz2Zo4/h3q/ZJAGB36gV4avakbpr+aGd9/2uk/tyToG37Tys2MUv5BVb51nRTh5a1dVXrOrrlusZqfoWv0ZEBQ1FcAgAAgGHW3v96ibaY33YV3V7Q4b8llte7uqUOf7OmRPu6h2aWuo8tz88rul1a4WjfB0u174OlZUgLoLrx9nLTqJtaaNRNLYyOAtg1iksAAABwKAlbDylh6yGjYwAAgL8w5xIAAAAAAABsRnEJAAAAAAAANmNYHAAAQAXyaRx0WesXWPJ19lisJMm3aX25mF0NyVGZ7DnbPzlSVgAAjEJxCQAAoAL1/2zSZa2fceqMvr3qQUnSgG9fUM0GARURy65c7nMEAADsC8PiAAAAAAAAYDOKS4CDWrt2rcaMGVN0PzIyUgMHDrzker///rtefvnlYm0RERFyc3PTn3/+Waw9MzNT3bp1k7+/v+bPn1/Uvm/fPvXs2VO9e/fWtddeq2PHjikpKUn/+c9/LvNRAQAAZ3HDgufVc9bDRscAAFQBiktANTNjxoxiRSlJmjZtmvr06VOib40aNbR48WKNHz++WHvdunX1448/av369Zo4caKmTZum2rVry8/PT3v37q3M+AAAoBpxcWMWDwBwBBytgWrk7NmzSk1NVUDAufk7Nm/erKCgILm6lpww1tXVVUFBJScyrVevXtFtNze3onUHDRqkRYsWqW3btpWQHgAAVLVWoweq1T0D5NMoSLlpmYrffEBr739dt215TxFfr9aeWd8V9e3++hj5NqmvlbdOUc9ZD6tB7/aSpOYj+kmSVt4yRXGb9l10f7dteU9Hv1uvGv7eanxTD6VFxunMnqMK7h+mpddNUO7ZTElSjzfHqt7VLbVswFPyrOevG395VbteX6j9Hy6XJPm1aKghK2do65R5ivjy18p4agAA56G4BFQjhw4dUpMmTYq1vfzyy5o7d66eeOKJcm8vKytLU6ZM0fvvvy9JatasmebOnVshWQEAgLE6ThiuNmNu1PaXv9Kpdbtlrumh4Gs7lWndzZPnyrtRoLLik7VlcuFng5yU9DKt2/q+f2n/nOVaceMzMpldlX4iXvW6tFb31x/S2gfeUJObe6rpLb3045BnZMnMVlpknP6c9JF6vDlWcZv2KTUiWn0++D9F/7qDwhIAVBGKS4CD8vT0VHZ2dtH97OxseXp6au/evXr99dc1cOBA3XHHHRfdxo8//qjOnTsXO5OprCwWi+666y5NmDBB7dq1K/f6AADAfpk9a6jt2KHa+eoCHZy7sqg9Kfx4mdbPS8tUQa5F+dm5ykpMKde+T+86ql1vLCzWtm7MmxqycobCnrlLrUYP1LaXvlDS3nNZjn2/QfV7tVOf9x9XwtaDcvP20B8TPijXfgEAtmPOJcBBtWzZUnv27FFOTo4kac2aNQoLC1Pbtm01evToUtcJDQ3VsWPHiu7v2rVLa9eu1cCBA7Vq1So9/vjjio2NveS+rVar7r//fg0YMEDDhg0raj969ChD4gAAcAL+LUNk9qyhU+t2V/m+T+86XKIt9XCMtk39XO3H3aKELQd14OMVJfpsfuYTuZhd1ez2Plo/9i3lpWVWRVwAgDhzCXBY/v7+mjBhgvr16yd3d3fVq1dPn3zyyUXX8fPzk5+fn86cOaOAgAA9++yzevbZZyVJo0eP1pgxY1S/fn2NGjVKn3/+uSTp1ltv1c6dO1WzZk1t3rxZM2fO1M8//6yFCxcqMjJS8+fPV8eOHTVr1iz99NNPJSYLBwAAzsdaYJVMpmJtFTX5tiUzp9T2oG5tVGDJV80GAXKt4ab8nLxiy32aBMkrsJZkLbyduD2iQvIAAC6N4hLgwO666y7dddddxdqio6O1aNEipaWlKSwsTKGhocWWP/XUU/rggw+Kikp/mzdvXtHtvwtLkvTdd9/pnwYOHKjMzOK/BiYlJSk1NZUhcgAAOIGUiGhZsnLUoE8HJR84UWJ59unUwkLOeWq3baLc8+ZVKsizyORaMQMlWtx5rUIGdNZPNz+vPu89pqunjtafkz4qWm72rKE+Hzyu40t+V9K+SHWdfr8St0UoLTKuQvYPALg4ikuAkwkODtY777xzweU9e/ZUz549K3y/tWvX1pdfflnh2wUAAFXPkpmtfXOWqeOE25WfnatT63fL1cNdwf3DFP72Yp3asEet7h6gkz9tUXp0olqOukHewXWUdF5xKe1kgur3aCOfRoHKTctU7tlMWS355c7i26yBuky7R1uen6vEbYe07qFZGrT4RZ1at1snf9oiSery0r0yubjoz2c+kSUzW/V7tVef98frxxuftWmfAIDyYc4lAAAAACXsnDFfO175Rq3vG6Shv72pG+ZPVkC7ppKk8Hd+UPTqHerzweMa9MM05Z3NVOSyTcXW3/fBUmUnpemm1a/rzn1zFXh1q3JncHE3q8/7jyvmt11FV35L3B6hna8vVPfXH5JXgwA1vrGbmt3aW+semilLZuHFTjaOf0eegbV01dN3XWzzAIAKwplLAAAAAEp14OMVpU6ebcnI1oZxb1903fSTCVp58/Pl2t+iLmOL3S/ItWjZDU+W6Bc++3uFz/5ekhR5alOJwlZOUpq+DXuwXPsGANiOM5cAAAAAAABgM85cAgAAAFDp2j16i9o/evMFl3/VfGQVpgEAVCSKSwAAAAAq3aHPf1Hk0j+MjgEAqAQUlwA4rZvGrdLR6LNGx7ikZsG+Wvr29UbHAIALWn33K1zSvYL4NA5S/88mGR3DELkp6co972pyQFWzp2NZdT4WwDlRXALgtI5Gn9X+oylGxwAAh5cWGaeUiGijYwDAZeFYBlQeJvQGAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGRN6AwAAAABwnp6zHlbzEf0kSQX5+cqKT1Hs73u1Y/pXyoxLMjgdYH84cwkAAAAOaeB3U9X99TEl2r2D62p07CLV69LKgFQAnEXcn/u1oP39WtT5Ia1/eJYC2jZW3w+fMDoWYJcoLgEAAAAA8A8FuRZlJaYoMy5J8X8e0KEvf1W9q1vKzdvT6GiA3aG4BAAAAADARXgG1lLjIV1VYMmXNb/A6DiA3WHOJQAAAAAA/iGoexv9+8gXMrm4yOxZQ5K09/2lsmTlSJL6fvSETq3brYgvf5Uk1W7bRL3fe0zLrn9S+Tl5huUGjODQZy7t3r1bQ4cOlZ+fn3x9fTVs2DDFxsbKx8dHd9xxh9HxgHIrsOQX3U47GS+r1WpgGgAAAKD6StxxWEuve1LLB03Srje/VcLWQ9o545ui5Vsmz1W7cTerRm0fyWRSt1f+q83PfEJhCdWSwxaXVq9era5du+rQoUN67rnnNH36dEVHR2vQoEFKT09Xx44djY4IlJklK0c7X1+gNXf/r6ht/ZiZWjZgoo59v8HAZM5rUM9g7Vw4TNnbRuv4T8P1+Mi2RkcCAACwCZ9rKkd+dq7SIuOUcihKu15boLSoBF3z8n1FyzPjkrRvznJ1njxSLUder9RjsYrdGG5gYsA4DjksLjExUSNGjFBYWJh+/fVXeXoWTqg2cuRINWnSRJIoLsFh5GVma9Ud05Sw9VCJZUl7j2v9w28p6cAJdX72Pwakc05XXVlHS966Xq9/Fq47n/pN17Srpw8md1dmtkVzvj1odDwAQBnlns2Uu2/NEu3ufoVtnD2A6oDPNVVn1+sLdPP6t3Toi1U6s/uoJOng3JUa/ON01e/RVssGTTI4IWAchzxzacaMGUpOTtbcuXOLCkuS5Ofnp7CwMEkUl+A4tkyeW2phSZL016i4ve/8oMjlm6oulJP7v1FttXVfop6ZvU0Hj6fqs6WH9fY3+zXp3vZGRwMAlEPqkRgFtG8qk0vxj7R1OjVXgSVfacdjDUoGVB0+11SdtONxilq1TWGT7jzXaLXq0OerFL16h3LOnDUuHGAwhywuzZ8/X7169VJoaGipywMDAxUUFCRJGjt2rEJCQuTr66uGDRtq/Pjxys3Nrcq4wAVlnzmro9+uvXRHk7T/w+WVnqe66NExUCt/jy7WtvL3aDVu6KOGgV4GpQIAlNfBz1bKo66fesx6WAHtm8qnUaCaDOuhThPv0JEFvyn3bKbREYFKx+eaqrX3vaVq2Lejgrq1OddYUCBrAXOlonpzuGFxcXFxiomJ0YgRI0osKygoUHh4uDp16lTU9sgjj+i1115TzZo1dfr0ad1+++2aPn26XnjhhTLtz2KxKC4urqLiA8VEf/+HCvLyL93RKiVsPaTDW/fIs37tyg/mJCx5pQ+HqF/XU3Gns4q1/X2/fh0vxcRX7ZcRS16eoqOjL93RAeTlWYyOYIi8PIvTvIYVKT7DTVJg4e2EePllMESpLLLjU4pux8bGyqMg68Kdq4i9vrczok9rxY3PKuypO9X/s0ly8/VS+ol47X1vqfZ//KPR8UpVlccLe33djOTox+vSPtvwuabsyvOe2Dj+3VLbE7cd0rz6t1VIFnt9nmA8oz8LBAUFyWwuX7nI4YpLGRkZkiSTyVRi2ZIlS5SQkFBsSNyVV15ZdNtqtcrFxUWHDx8u8/7i4uIUEhJie2DgIm6s2Uq3+LS5dMe/3NC9jyItKZUXyNm0mCp5NDQ6xSVFREQoJOTOS3d0AC8FXK+Gbr5Gx6hyERERGs7fihK8mndW6ze2SpJuHDJEmUe2GZzIMdRy8dSb9f4lSerSpYuS7aC4ZM/v7eT9J7T67leMjlFmVXm8sOfXzSgOf7x2gM829vy5xp7eEw7/bxGVyujPAlFRUQoODi7XOg43LC4kJESurq5at25dsfYTJ05o3LhxkkrOt/TKK6/I29tb9erV0+7duzV+/PgqSgtcXJa1fL/iZ1v5BbIixCZmKaiOZ7G2wIDC+7GnGUIBAAAcB59rjHdk4VptfvYTo2MAhnK4M5fc3d01atQozZ07V0OHDtXgwYMVFRWljz76SIGBgYqJiSlRXJo0aZImTZqkAwcO6KuvvlL9+vXLvL+goCBFRUVV8KMACmXFnNHvN08rmrj7gkySV6NAbdmyv9Sz9lC6/mM2KuJkRon233fFa0D3YE2bs6uobWCPYEXGpFX5qeOSFBoaqtVrnOM4s2n4K8o4Xv2GEoeGhipq4adGx7A7ERlumvjX9QqWLV+u0JoMiyuL7PgUbRzygiRpy5Yt8gj0NzSPVH3f25WhKo8XvG4lOfrxurTPNnyuKTt7ek84+r9FVC6jPwv8PYd1eThccUmSZs+eLTc3Ny1ZskRr1qxRt27dtHjxYr344os6cuTIBSf6bt26tTp06KCRI0fqt99+K9O+zGZzuU8HA8osOFgnr++sqF8uMVTEKrV7YAhDNMvJ7OZWavvML/bqj89v1EvjrtIXy47omvZ1Ne7OK/X4a5urOGEhs5ub0xxn3Nwc8s/KZXNz429FaVKTJf1VXAqsF6jgWobGcRgZLufOQKhfv75qNggwME2h6vrergxVebzgdSvJ0Y/XpX224XNN2dnTe8LR/y2ictnjZ4FLsZ93Vzl4e3trzpw5mjNnTrH2vXv3ql27dnJxufBov7y8PEVERFR2RKDMus14QEn7I5URffqCfa4Y1EUtR91Qhamc27Z9pzVs/K+a/uhVmnB3O8WdztKzb2/XnG8PGh0NAACgXPhcA8AeOGRxqTQpKSmKjo7W4MGDi9pSU1O1ePFiDRs2TH5+fgoPD9dLL72kAQMGGJgUKM4rqLYGL/+fNj/3iU6u2CJrQUHRMjcfL7W+Z6A6PjlCLq6uBqZ0Pis2RGnFBvs8ZRsAAKA8+FwDwGhOU1wKDw+XVHwyb5PJpC+//FL/93//p9zcXNWrV0+33HKLpk6dalBKoHRegbXU76MJyog9o1PrdsuSkS3Pev4K7n+VzF41jI4HAAAAAMAFOXVxydfXV7/++qtBiYDyq1k/QC3uuNboGAAAXNJ/jn2l0zuPSJL2f/yjTv60pdjyHm+OlU/jQJm9PHTsu/Xa/9GPZVrvfAEdmqnLi/fI5GLSgU9/0vHFG0v0affIMNXv1V4uZlftmPGNErYcVOjI69ViRD8VWPK16/WFit0YLu/gurrxl1eVfOCkJGn79K+UuP3iUyW4+3vr1j/e1p9Pf6zjS34vtqzuVaHq/PwoWfPzFbVqu/a9v7RM6wGwfxc7TjW8tpM6PTlCBXn5OhN+rOgqcR0nDFf9Xu1lteRr83OfKvnACUOyA0ZxmuLS2LFjNXbsWKNjAAAAVAsZMae18tYpF1y+6akPVZBnkcnVRTevf0uHvlyl/KzcS653vmum3at1D81U9ulUDV4+XVE/b5MlM7toecNrO8nVs4Z+GfFiUZtHgK9a3HmtVtz4rFxruGvAt1O04sZnJUmndx3RqrteLvNjbD/uZiVsK70A1WXaPfrt3teUGZeka+c+paift+rssdhLrgfA/l3sONXxieFac99ryjx1Rtd99axqtW4kk4tJAe2a6qehz8krqLZ6zh6nX4YzWgbVy4VnvgYAAAAuwDOwlgZ+P1V93n9cHgG+JZYX5FkkSa413JUWlaD87Lwyrfc31xpucnE3KyPmtPJz8pSw7ZACOjQt1qfxjd1k9qqhGxZOUc9ZD8tc00PeIfWUGhEta36BLJnZysvIlk/jQElS7bZNNOiHaer22oMye1582HnNhnXkGVhLZ3YfLXW5W00PZcYlSZJO7zmqoO5tyrQeAPt3seNU8sGTcvetKZOLi8we7spJTZdv0/o6s+eYJCkzLknewXXk4u4053EAZUJxCQAAAOX2XdeHtfKWKTr5y1Zd/cLdpfbp8/7junXT20rcekiyWsu8nlQ4tCw3NaPofk5qhmr4exfr4xVUW9a8fP0yfKqS9kWq7ZibdDYyTrXbNZW5poc86/kroG1j1fD3VmZCsr7r9oh+GjZZ6VGJajfu5os+vg7/d7v2vPXdBZfnpGTIv2WITGZXNejdvijbpdYDYP8udpw6vnijbvjmOd284S2lHo1R5qkzSj4UpaAebWQyu8q/ZYi8g+uqhp/3BbYOOCeKSwAAACi3nKQ0SVLk0j9Uu22TUvuse2imFl3zsBpe20l+ocFlXk+SclMz5O5Xs+i+u29N5aSkF8+QnK6Y33ZJkmJ+26laVzZSbkq6dr+5UNd98bSuefk+Je2LVGZ8sgpyLbJkFA6pO/7DRtVud+F9+7e6QrJalXo45oJ9Nj35ga6eMkrXfT5J6VGJyoxPLtN6AOzfxY5TXf93v5YPmqTve4yTrNIVA69WakS0ji/5QwMWPq+2D92k5IMnlX3mrBHRAcNwrh4AAADKxexZQ/k5ebIWFCiw65VKi4wr0cfF3ayCXIvys3NlycpRflbuBdcz1/SQi6uLcs9mFq2fn52rglyLvIJqKzvprOp1DtX2l78sto+4TfsU0KFZ0f/PHi+c8+jEj5t14sfN8qjjpx4zxyoj5rTcvD2Vl54lSQrq3lZpf/V19/cuLDydN5dTnfZN5de8oa7/+ln5NA6SJSNbqUdilLQvsqhPSkS0Vt31skxmV/X7eIKi1+xUSP+wS64HwL5d6vhmLSgoOqsy+8xZ1ajlI0k69NnPOvTZz/Jr0VDtH71F1oKCKs8OGIniEgAAAMrFr0VDdX99jPIyslWQl69NE+dIkhr26yh3f28dX7xR133xjFzMrnJxNyty+SalRyUooH3TUtdrMqynzB7uOvDJimL72fL8XPWZ838yuZi0b84yWTKy5VnXX1c+OETbX/pSRxb8ph5vPKQBi15Qfk6eNjz6tiSp17uPyauevyyZOdoyea4kKbDrler45HBZMnOUl5aljY+/K0lqM+ZGnd5xWFG/bCva75GFa3Vk4VpJhZP3/l0gqt2msYJ6ttX+OcvV5qGbFNw/TNYCq/Z9sFQ5Z85ecD0AjqO049v5x7adry0sPObk5ik3JUN73v5eknTDwikymaTspDRtfuZjgx8FUPUoLgEAAKBczuw5pmU3TCzR/vcQNUnFruB2qfVqtQrR7lkl5yk6veuIfhr6XLG2rMQUbX+p8AymglyLNox7u8R6Gx5+q0Rb9K/bFf3r9hLtNYNqa/d5uf9p1xsLi24n7YssKhbte3+p9r2/tEzrAXAcpR2nzj976cTyTTqxfFOJ9bg6HKo7iksAAAAw1N9nFxlh4/h3Dds3AADOggm9AQAAAAAAYDPOXAIAAMBF+TQOMjqC0+C5xOVoFuxrdIRLsueM9vT+s6csQEWguAQAAICL6v/ZJKMjAJC09O3rjY7g0DiWAZWHYXEAAAAAAACwGcUlAAAAAAAA2IxhcQBQirnTemn00FBJUl5egVLTc3XweIqWrjupd+cfUGaWxeCEAAAAAGAfKC4BwAWs3x6n4RPWyMXFpAD/GurZKVBP39dB990cqt6jf1RCUrbREQEAAADAcAyLA4ALyM3LV/yZLMUmZmrv4WR9sPCguo1cprq1PPXK+KuL+o0d0Vr7Ft+i7G2jFb/2Li1681pJUrMQH6X+MVLj/9OmqG+rJn5K3zxK/721ZZU/HgAAAACoDBSXAKAcTiVk6qsfj+iW/o1lMkkvjO2kGY9frfcWHFC7W7/XwId+1o4DZyRJR6PS9NBLf+iV8VerU+sA1XB31YLXrtWP66P00XeHDH4kAAAAAFAxGBYHAOW072iK/HzcFRLkrYmj22vyu9v17vwDRct3/lVckqSvVxzVdV0baP6Mfvp9V7x8arrpv1M3GhEbAAAAACoFZy4BQDmZTIX/D6rjKU8Ps375I+ai/R/53yaZzSaNurG57npqrc6m51VBSgAAAACoGhSXAKCc2jSrpZSzObJarWXq3zzEVw3qeslqlZpf4VvJ6QAAAACgalFcAoByaFDPS/8e3Ezfrz6h/UdTlJVt0Q3dG16wv5enWfNf7af5K49pwptb9O4z3dQsxKcKEwMAAABA5WLOJQC4AHc3VwUGeMrFxaQA/xrq2SlQT9/XQQlJWXr6ra3KyLLojc/36oWHwpSVna9Vf8bIs4ZZ/+oVrFc+2SNJmv1UV7m6mPTI9E3KyLLoumsa6JsZ/dR91DJZLGU78wkAAAAA7BnFJQC4gN5XBSnut7tksRQoNT1XB46l6J35+/Xu/APKzLJIkia/s12Jydl69N9XaubEa5R8Nlfrt8dJkm6/oYn+M6S5uo1cpoy/+o+evF67v71Z0x/trIlvbjXssQEAAABARaG4BACluGfyBt0zeUOZ+s7+ap9mf7WvRPu3vxzXt78cL9Z2JiVHwdfPr5CMAAAAAGAPmHMJAAAAAAAANqO4BAAAAAAAAJsxLM5B3TRulY5GnzU6hpoF+2rp29cbHQMAADiwxzdLMZlGpyjU0EuaeY3RKYBL430DwJ5QXHJQR6PPav/RFKNjAAAAXLaYTOlYmtEpAMfC+waAPWFYHAAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAATin8v42NjgAAQLXg0MWl3bt3a+jQofLz85Ovr6+GDRum2NhY+fj46I477jA6HgAAAADACZzOlj4+JI39Q3rgd+nFXdKeJMlqNToZYB/MRgew1erVqzVkyBA1atRIzz33nDw9PTVv3jwNGjRI6enp6tixo9ER7d7cab0UHFhT1z+w0ugoQJXqdVWQnhjVVh1bBqhRA2899/Z2vfzRLqNjoQLcsOB5Zcae0cbx7xodBYCBoj5+XGl7f1Ne0intH99RHg1aqunEBUbHAuxCQU6WYhdNV/KG+co9Ey0Xd0/VCGqmgL4jVe/GR42OZ3esVunzI9J7B6X8vwpJJkk7zkhLT0pd6kivdJZ83Q2NCRjOIYtLiYmJGjFihMLCwvTrr7/K09NTkjRy5Eg1adJEkiguAbggb0+z9h9N0dcrjmrWxK5GxwEAlNH2oaaLLnev10jtPopUyP0zJRUOi7ty1q4qSAY4jpMfPKS08N8Ucv9b8mzSQfmZZ5V5bKdyE08aHc0ufXVMevtA8bbzT1bacloav1n6oLvk7lql0QC74pDFpRkzZig5OVlz584tKixJkp+fn8LCwrR69WqKSwAu6KeN0fppY7Qkacb4qw1Og39qNXqgWt0zQD6NgpSblqn4zQe09v7XdduW9xTx9WrtmfVdUd/ur4+Rb5P6WnnrFPWc9bAa9G4vSWo+op8kaeUtUxS3ad9F92dydVH7x25Vs9v7qGb9AGUnndXJFZu1+blPVbdzSw36fqrWPvimTv60RZIU1L2Nbpg/Wb+O+p9Ord1dSc8CgNK0nxdbdDv94B869sqtaj1zh9xq1S9sdOGbHXApKZt/UIN/vyT/rsOK2ryadDAukB07myu9d+DS/fYkS7/ESEOuqPxMgL1yyOLS/Pnz1atXL4WGhpa6PDAwUEFBQcXasrKy1K5dO8XFxSk9Pb3M+7JYLIqLi7usvJXBkpdndARJhTmio6ONjgGUyl7eJ5fiTO+jvDzLZa3fccJwtRlzo7a//JVOrdstc00PBV/bqUzrbp48V96NApUVn6wtk+dKknJSLn287/HmWDW8tpO2Tv1MiVsPySPAV3U7t5QkJW47pF1vLFSPNx7SmT3HZMnOVa93HtW+D5cXKyzl5Vmc5jWsSPEZbpICC28nxMsvwzHek0bLjk8puh0bGyuPgizjwlSRvLxASW6X7OdW69znO7N37cL/+9Yt1n75WfIUHR1fYdsz0uUek52RMx2vy/q++Se3WvV1dsdK1e59l8w+tSsoi/O8b863NMFbuQX+Zehp1VcReeroklDZkVBNGP1ZICgoSGZz+cpFDldciouLU0xMjEaMGFFiWUFBgcLDw9WpU8kvIs8//7waNWpU7kJRXFycQkJCbM5baVpMlTwaGp1CERERCgm50+gYQOns5H1yKc70Pnop4Ho1dPO1aV2zZw21HTtUO19doINzz80FlxR+vEzr56VlqiDXovzsXGUlppRpHZ/GQWo+vK9+u/91nfjxT0lS2ol4Je44XNRnz+zFCureVr3ffUx56VnKjEvSjle+KbadiIgIDbfHvxUG82reWa3f2CpJunHIEGUe2WZwIsdQy8VTb9b7lySpS5cuSq4GxaUr394rzyvaGB1D0l/H5AFtjY5RIS7nmOysnOl4bev7ptEjH+v4G3dp96i68gxpo5otu8rvqn/J75qhMpkuPvT0QpzpfXO+xv/3pQL6/LsMPU2KSHdVyBVXMMM3KoTRnwWioqIUHBxcrnUc7mpxGRkZklTqgW/JkiVKSEgoMSRu+/btWrlypZ566qmqiAgAsIF/yxCZPWvo1LqqG2oW0K5wnr6L7tNq1YZxs1Wr1RUK7Npa68bMlNWSX0UJAQCoWN6te6jtnKNqOX2DAq69W3kp8To64zYdffkmWSmMFGMqx1Bbk4urZGNxDnAGDnfmUkhIiFxdXbVu3bpi7SdOnNC4ceMkFZ/M22Kx6L///a/effddFRQUlHt/QUFBioqKuqzMlaH/mI2KOJlhdAyFhoZq9Rr7e34AyX7eJ5fiTO+jTcNfUcbxyhlKbC2wlvjQ5uJWNX/GardtIrNXDclkUs2GdZR+svhp76GhoYpa+GmVZHEkERlumnio8Pay5csVWpNhcWWRHZ+ijUNekCRt2bJFHoH+huapCuP2Byoqu+K36xFyZbnXCQ0N1c92+NnPFpV5THZUznS8vpz3jcnVLO/W3eXdursChz2hM2u/VOTMkUrft14+bfuUe3vO9L453/xYH82PvXQ/k6wKqmFR1IkTlR8K1YLRnwX+Oc1QWThcccnd3V2jRo3S3LlzNXToUA0ePFhRUVH66KOPFBgYqJiYmGLFpddee02dOnVS7969tXbt2nLvz2w2l/t0sKpgdiv/+OrKYHZzs8vnB5Ds531yKc70PnK7jGJPSkS0LFk5atCng5IPlPxwln06VV6BtYq11W7bRLnnzatUkGeRybXsJ+We+WvIXYM+HYqGxf2TZ11/9XzrEe1563u5+3mp99uPasl1E4rt183NPv9WGC01WdJfxaXAeoEKrnXR7vhLhsu5i5XUr19fNRsEGJimargdllQJxaUWz68ofxaOyU7NmY7XFfm+8QhuLUmypNo2Z5AzvW/ONzJAWhgrXeoUBatMuqO5cz4HMIYjfhZwyL84s2fPlpubm5YsWaI1a9aoW7duWrx4sV588UUdOXKkaKLvI0eO6IMPPtDOnTsNTgzAntT0NKv5FYVzULi7uSiojqc6tKyt9Mw8HY1KMzhd9WXJzNa+OcvUccLtys/O1an1u+Xq4a7g/mEKf3uxTm3Yo1Z3D9DJn7YoPTpRLUfdIO/gOko6r8iTdjJB9Xu0kU+jQOWmZSr3bOZFh7ClRcbp6Hfr1fWV/8rVw02J2yLk7u+tele31IGPC7+U9nx7nFKPxGj3zEUyuboosOuV6jlzrNbc82qlPycAAFS0Q8/0Ue1ed8qreWeZ/eoqJ/aIYr54Rq41/eXTrp/R8exKoKd0a2Pp28iL96vvKd3EleJQzTlkccnb21tz5szRnDlzirXv3btX7dq1k4tL4a/WGzduVHx8fFGxKS8vTxkZGapTp46+//579e7du8qzAzBe5zZ1tPbTwUX3H7nzSj1y55VauzVW/e4r/6/cqDg7Z8xX9pmzan3fIF099W7lpmYo/s/CawCHv/ODvIPrqs8Hj6vAkq9D835W5LJN8m1Sv2j9fR8sVa3WV+im1a/LraanVt4yRXGb9l10nxvHv6uO/3e7wp66U56BtZR9+qxO/LhJktT24WGq076pllw3QdaCAlkLCrRuzEzd+POrajV6oA7OW3nRbQMAYG/8wgYpaf1XOvXN88rPPCuzXz35tOmtxo/Oldm3jtHx7M4TbaV0i/TTBS4y2MBLerer5OMYJ8wDlcYhi0ulSUlJUXR0tAYPPveFcfjw4bruuuuK7m/atEmjR4/Wrl27VLduXSNi2pV7Jm8wOgJgiHXb4mRq/4nRMXABBz5eUXTW0PksGdnaMO7ti66bfjJBK29+vlz7s1rytfPV+dr56vwSy/a++4P2vvtDsbazx2L1VYuR5doHAAD2Iui2SQq6bZLRMRyG2UV6sZM07Arp4whp6+nC9ibe0l3NpIENJU+n+VYN2M5p3gbh4eGSik/m7eXlJS8vr6L7devWlclkYiwsAACAg/Np11dXLeHKVgAqn8kkXVVH8nCV7v7r9/kXOkltmEsQKOLUxaV/6tu3r9LT0y+4HADgXNo9eovaP3rzBZd/1ZwzkAAAAIDL5TTFpbFjx2rs2LFGxwAA2JFDn/+iyKV/GB0DAAAAcGpOU1wCAOCfclPSlZvCGasAAABAZXIxOgAAAAAAAAAcF8UlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmZqMDwDbNgn2NjiDJfnIApXGUf5+OkhMAKktDL6MTnGNPWYCLsad/q/aUBYAxKC45qKVvX290BMDu8T4BAMcw8xqjEwCOh/cNAHvCsDgAAGCYyMhI1a5dW3379tXVV1+tn3/+uUSfY8eO6eGHH5YkzZo1S126dFGPHj00bty4En337dunnj17qnfv3rr22mt17NgxSdLHH3+s77//vnIfDAAAQDVFcQkAABiqS5cuWrt2rRYvXqwnnniixPLXXntNY8aMkSQNGTJEmzdv1u+//67ExEStW7euWN+6devqxx9/1Pr16zVx4kRNmzZNkjRq1Ci9//77lf9gAAAAqiGKSwAAwC4EBwcrIyOjRPuff/6pdu3aSZKaN28uk8kkSXJzc5Orq2uxvvXq1ZOfn1+J5e7u7vLz81NkZGQlPgIAAIDqieISAACwC+Hh4apTp06xtsTExKJi0fk2btyomJgY9ejRo9RtZWVlacqUKXrssceK2po1a6bw8PCKDQ0AAAAm9AYAAMbasmWL+vbtK3d3d33wwQeX7H/gwAFNnDhRS5cuLTqL6XwWi0V33XWXJkyYUHTGEwAAACoPxSUAAGCoLl26aOXKlaUuq1OnjlJSUorunzx5UnfffbcWLFhQ4iwnSbJarbr//vs1YMAADRs2rNiyo0ePFs3dBAAAgIrDsDgAAGC3TCaTunbtWjScbeLEiTp9+rTuuece9e3bt6goNX78eCUlJennn3/WwoULNX/+fPXt21fjx4+XJOXm5iolJUVNmjQx6qEAAAA4Lc5cAgAAhmncuPEFz1r628SJE/XGG2/o3Xff1fz580vtM2vWLEnSwIEDlZmZWWL5559/roceeuiy8wIAAKAkiksAAMCuNW3aVO++++5lbeP++++voDQAAAD4J4bFAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2MxsdAOesvvsVpUXGGR2j0vg0DlL/zyYZHQMAANiZxzdLMZlGpyjU0EuaeY3RKQAAjuxyv9sXWPKLbv98+wtyMbvatJ2q/A5OccmOpEXGKSUi2ugYAAAAVSomUzqWZnQKAAAqRkV+tz97LLZCtlPZGBYHAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAcBiHnu2ryLfvL9GeEx+p7UNNSt+/0YBUAABUb1wtrprpOethNR/RT5JUkJ+vrPgUxf6+Vzumf6XMuCSD0wEAAAAAAEfDmUvVUNyf+7Wg/f1a1PkhrX94lgLaNlbfD58wOhYAAAAAAHBAFJeqoYJci7ISU5QZl6T4Pw/o0Je/qt7VLeXm7Wl0NAAAAAAA4GAoLlVznoG11HhIVxVY8mXNLzA6DgAAQIU4Putu7R5VT/vGtTU6CgAATs+hi0u7d+/W0KFD5efnJ19fXw0bNkyxsbHy8fHRHXfcYXQ8uxXUvY3+feQL/efYVxqx6yMFdWuj/R/9KEtWjtHRAABOJN967vapTMlqvXBfnJMWGVd0u8CSb2ASx1bnunvVYspKo2MAAFAtOOyE3qtXr9aQIUPUqFEjPffcc/L09NS8efM0aNAgpaenq2PHjkZHtFuJOw5r42PvyLWGmxrf1F0NerXXzhnfGB0LAOAkcvOlL49K3xw71/b0dmneYenfzaRBwZLJZFw+e3V8ye/a+8FSndl1tKjtx8FPq9XoAWo7dqjMnjUMTGc/XL38lJ+ZWqI9PyNFkmRy85Ak+bTto5z4yCpMBgDA5XH1cFf7R29Rk6E95FW/tvKzc5V2Il5HF63XgU9WGB3vohyyuJSYmKgRI0YoLCxMv/76qzw9C+cKGjlypJo0aSJJFJcuIj87t+hX0V2vLZBP4yBd8/J9+mPCBwYnAwA4uux8afxmadvpkssizkrP7yz8/2NXUmA6344Z32jPrO+kfzwn2WdStev1hTq1fo+u/+Y5uXl5GBPQjngEt1Ly79/Kmp8vk6trUXvG4S2Si6tq1G9uYDoAAGzX7ZX/KqhHW22Z/KmS9p2Qm4+nAto2Uc2GdYyOdkkOOSxuxowZSk5O1ty5c4sKS5Lk5+ensLAwSRSXymPX6wvUfEQ/BXRoZnQUAICDm72/9MKSJP09Ku7Lo9LPMVUWye6dWLG5sLAknXuS/vbX/YQtB7Vl8twqzWWv6g4aK0tKvCJn36OMI9uVE3tUSeu/0amvJqtO/3tk9vY3OiIAADa5YmAX7X1viU6u3Kr0qAQl7z+hIwvXavfMRUZHuySHLC7Nnz9fvXr1UmhoaKnLAwMDFRQUJEkaPXq03N3d5e3tXfTfypWMvz9f2vE4Ra3aprBJdxodBQDgwNLypCUnLt3PJOnrY5fsVm3s+3B5iTOWSnN00Tplnzlb+YHsXI16jdRyxh/Kz0jW0Zdu1P7H2it20XQF3vykrhjzntHxAACwWWZCshr26yR3f2+jo5Sbww2Li4uLU0xMjEaMGFFiWUFBgcLDw9WpU6di7Q888IDeeecdm/ZnsVgUFxd36Y4VIC/PUiX7Kc3e95Zq8LKXFdStjeI27auUfeTlWRQdHV0p2wZgH4w8jhmJ41uhNWe8lFNQ+5L9rJL2p0hbjsSpgUf1/Dfzt+y4ZCVsPlCmvgW5Fu36aqWCb+leyamqXl5eoCS3Mvf3atJBzZ9bVklZ8hQdHV8p265q1fWYfDEcr3E54jPcJAUW3k6Il19GnrGBYLdsPf7+8cT76v3eeN2x9xOlHIpW4o4IxazeoZMrt9qcw5ZjXlBQkMzm8pWLHK64lJGRIUkylTJRw5IlS5SQkFChQ+Li4uIUEhJSYdu7mJcCrldDN99K3cfG8e+W2p647ZDm1b+tUvcdERGh4VX0XAIwRlUcx+wRx7dCgcOeUPA9r5e5/7U33qqMg39UYiL718jsrxfq9C9z/+nPTNGyxw5WYiJjXPn2Xnle0aZCt3l0xu1KP7BRlrOntefeYAXd9ozq/WvsJdeLiIhQyIC2FZrFKNX1mHwxHK9xObyad1brNwq/5N84ZIgyj2wzOBHsla3H34Sth/Rd14dVp1ML1bsqVIFdr1TfjyYoZs1Orb77lXJvz9ZjXlRUlIKDg8u1jsMVl0JCQuTq6qp169YVaz9x4oTGjRsnqeR8S1999ZW+/vprBQYG6j//+Y+eeuqpclfhAADAxeVnpZWrf0E5+zujbGv5ftksb//qrNlT3xodAQCAcrPmFyhx2yElbjukfXOWqemtvdT7nccU2O1KxW/ab3S8C3K4Cou7u7tGjRqluXPnaujQoRo8eLCioqL00UcfKTAwUDExMcWKS48++qheffVV1alTRzt27NCdd96p7OxsTZs2rUz7CwoKUlRUVCU9muI2DX9FGcerZgieEUJDQxW18FOjYwCoRM5+HLsQjm+FTue66oG9VhVcYgIhk6yq556v7zeskEs1v2Kc1WrVpuH/U+aJhJKTef+TSXpn9bfyCrb/K8aU17j9gYrKNjpFodDQUP1cRZ/9Klt1PSZfDMdrXI6IDDdNPFR4e9ny5QqtybA4lK4ij7+phwuvguIR4FfudW095v09h3V5OFxxSZJmz54tNzc3LVmyRGvWrFG3bt20ePFivfjiizpy5Eixib7/vnqcJHXu3FlTp07VlClTylxcMpvN5T4dzFZubg75cpSZm1vVPZcAjOHsx7EL4fhWKFhS3zPSmtiL97PKpDubm3VFCM+ZJGU8eJP+fPrjS/YL7h+m0K4dKz+QAdwOS7KT4pKbm5vTvJ+r6zH5Yjhe43KkJkv6q7gUWC9QwbUMjQM7Zuvxd+D3U3X8h991evdRZZ9JlW/j+gp7+i7lpKQr7o+9NuWoqmOeQ/7F8fb21pw5czRnzpxi7Xv37lW7du3k4nLhi+C5uLjIar3UT4MAAMAWE9tJB1OlU5kX7tO9nnRH06rLZO9CR16vU+v26OTKLRfs49UgQN1efbAKUwEAgKoWs2anmt7SSx2fHCF3b09lnUlV/J8HtPHxd5WTZN/TCThkcak0KSkpio6O1uDBg4u1L1iwQAMHDpSvr6/Cw8M1depU3X777QalBADAudXxkOb2lF7fW3gGU/55v+d4maVbG0ljW0vmC/8OVO24uLqq74f/p52vLdDBeSuVl5ZVtMzk4qIrBl6ta16+T15Bl74SHwAAcFzh7/yg8Hd+MDqGTZymuBQeHi6p5GTe7733nsaMGaO8vDzVr19fI0eO1NNPP21AQgAAqocAD+l/naXEbOmPBCnTItWuIfUKLCwwoSQXN7Oueubfaj/+VkWv2q6shBSZa3qoYd+OqtkgwOh4AAAAF+U0H/EuVFz651XlHIV3cF31fm+8CiwWmVxd9eekj5R84ESxPiE3dFb7R29Rfp5FEV+s0rHvN0iSAto3Vdgz/5aL2VUJWw9q54z5F9xPQIdm6vLiPTK5mHTg0590fPHGYstb3TNQTYb2kEwmpZ2I1++PvytrfoG6vz5Gwdddpaift2rTUx9Kklw93dXrrXGqUdtHuakZ+v3xd5V79iLjIgAATq2uhzT0CqNTOBY3L4/Cv7soISc+UsffuEsms5us+RZd8dD78mrcvmh56vafdOrr52VydZNXszBd8eA7kqRTX0/R2d2/ymR2U8h/ZxdbBwAAVAynKS6NHTtWY8eONTpGhcmIPaMVQ5+TrFYF9Wir9o/eonUPzTzXwWTSVc/+W8sHPa38nFwN/H6qolZtV352rsIm3anf7n1NlsxLz4x5zbR7te6hmco+narBy6cr6udtxdaL+PJXHZy7UpLUc/Y4NejdXjG/7dKu1xfq2Hcb1GTYuQ/ALf9zvRJ3HNa+D5aq0eBr1GbsUO185ZuKe1IAAEC15V4nWC1f2SiTi4vO7lmjuG+nq+mT535AO/XNC2o26Xu51w3R4amDlBm5RyooUOaxHWo143flnolR5KxRCp222sBHAQCAc2LGAztlzS+Q/pp43N3HU0n7I4st96jto+zTZ2XJzJY1v0CpR06pblgL1e0cqrzMHPX54HHdsHCK6l4VWsrWC7nWcJOLu1kZMaeVn5OnhG2HFNCh+AyrBXmWotsmk3T2r8spZsYlldieb9P6OrP7qCQpcecR1e/e1qbHDgAA8E8mV7NMf120pSDzrDybdCi23LNRW+VnpMian6+C3CyZa9ZS9qkIeTW7SpLkHtBQuQknVJCXU+XZAQBwdhSX7FjtNo31r2Uv65qX71fshvBiy7LPnJVHHV951vOXuaaHAq9prRr+3vIKrKXarRtp3UMztXH8O+r+2oWvLOPu763c1Iyi+zmpGarh712iX7tHhunmjbPl7u+tzPiSRaW/JR84qYb9OkqSQq67SjVqldwWAACArTKP7dLBid108sNH5Nu+f7FltXvfpcMvDNC+h1vJo2FLudcNkecVbZUW/pusljxlndirnMQTyk9PNig9AADOi+KSHUvaF6kVNz6r1aNf0TXT7yuxfNNTH6r3u4+pz/uPK+VQlDLjk5STkq6ErQdlychW5qkzsmTmyM3bs9Tt56ZmyN2vZtF9d9+ayklJL9Ev/J0ftLjno0qLjFPz4f0umPfwN2tkrumhAYteUM2GdUo9uwkAAMBWXk07qtWrm9T82aU6+eEjxZad/GCsWr2xVW0/OCzJpJQ/f5DnFVeqVs8Rinj+OsX/8Lo8G7WT2beuMeEBAHBiFJfslIv7uemw8s5mKj8rt0Sf+D8P6Ofbp2rdmJkye9VQ4vbDOr3jsHybNpDJ1UVuPl5y8/FUXnqWzDU95O7rVWz9/OxcFeRa5BVUWy7uZtXrHKoze45dMEfu2UzlZ5fM8beCPIs2P/uJfr7tBZ09HqfI5X/a+vABAACKOX84m6uXn1xqFP9cY3JxlWtNf0mS2a+uLGlnJEn1/jVWLaevU+AtT8nzijYyubpWWWYAAKoLp5nQ29nUu7qVOk4YLmt+gUwmk7a8ME+S1LBfR7n7e+v44o3qPGWUAto1VYElXzv+97UK8izKzbPo0Be/aOD3U+ViNmvbi19IkpoM6ymzh7sOfLKi2H62PD9Xfeb8n0wuJu2bs0yWjGx51vXXlQ8O0faXvlTYpLtUp0MzycWk9JMJ2jPrO0lSh8dvU8jAq+VZx183LHhev9wxTf4tQ9T15ftUYMlX8oET2jbtiyp9zgAAgPNKP/C7Yr95QXJxlWRVyL1vKnXHSuWnJal2n7vU4K6pinjuWrm41ZCrdy3Vv+1pSVLE5P6S1Sqzbx2FPPCOoY8BAABnRXHJTsX9vlcrf99boj3mt11Ft7dN/bzUdY9+u05Hv11XrK1WqxDt/qswdL7Tu47op6HPFWvLSkzR9pe+LNzHi6XvY/fMRdo9c1GxtpSDJ7Xy1iml9gcAALgcvu2vlW/7ay+4vFaP21Wrx+0l2rk6HAAAlY/iUjWxZfJcoyMAAAAAAAAnxJxLAAAAAAAAsBlnLtkRn8ZBRkeoVM7++AAAgG0ael26T1WxpywAAMdkL999qzIHxSU70v+zSUZHAAAAqHIzrzE6AQAAFac6frdnWBwAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwmdnoALDN6rtfUVpknNEx5NM4SP0/m2R0DAAAAMDp2Mtn/svB9wWgeqC45KDSIuOUEhFtdAwAAAAAlYTP/AAcBcPiAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADbjanFOruesh9V8RD9JUkF+vrLiUxT7+17tmP6VMuOSDE4HAAAAoLIN/G6qzh6P1R8TPijW7h1cV7dtfV8rhj6nhC0HDUoHwBlw5lI1EPfnfi1of78WdX5I6x+epYC2jdX3wyeMjgUAAAAAAJwAxaVqoCDXoqzEFGXGJSn+zwM69OWvqnd1S7l5exodDQAAAAAAODiKS9WMZ2AtNR7SVQWWfFnzC4yOAwAAAAAAHBxzLlUDQd3b6N9HvpDJxUVmzxqSpL3vL5UlK0eS5BVUW/9a/rKWD3hK2WfOytXTXUN/fUNr7ntNKQdPGhkdAAAAQBXwahCgXrPHybOun6wFVkV89asOfLzC6FgAHIRDn7m0e/duDR06VH5+fvL19dWwYcMUGxsrHx8f3XHHHUbHsxuJOw5r6XVPavmgSdr15rdK2HpIO2d8U7Q8My5J++cs19VTR0uSOj4xXCd+2kxhCQAAAKgmrJZ8bZ36mX7o87h+HPyMWt09QH6hwUbHshtnsqVl5309+vSwtDfZuDyAvXHY4tLq1avVtWtXHTp0SM8995ymT5+u6OhoDRo0SOnp6erYsaPREe1Gfnau0iLjlHIoSrteW6C0qARd8/J9xfoc+OQn+YeGqPX9/1Kjf12j3W98a1BaAM6q4bWddNOq1zQy8hvdtuU9XfngEKMjAUC1FNi1ta6d+5Ru2/q+RscuUvvxtxodCZUs92ym3H1rlmh39ytsy8/JU1ZCipLCj0uSLJnZSj1ySl5Btas0pz2yWqUvj0iDV0mLTpxrXxcnjd4gPbJJSsszLh9gLxyyuJSYmKgRI0YoLCxMO3fu1JNPPqlHHnlEq1ev1smTheVkiksXtuv1BWo+op8COjQrarMWFGjrlHm6Ztq92jbti6IhcwBQEQI6NFP/eU8p+redWnr9BO16faGumnSXWo66wehoAFDtmL08lHI4StumfaHMeE69qA5Sj8QooH1TmVyKf/2r06m5Ciz5SjseW6zdO7iuAto10ekdh6sypl365pg0a79ksZa+/M9EafyfUm5+1eYC7I1DFpdmzJih5ORkzZ07V56e56545ufnp7CwMEkUly4m7XicolZtU9ikO4u1N+zfSZlxSarV6gqDkgFwVm0eGKLTu45qx/SvlXo4RkcWrtWBT39Su0eGGR0NAKqdmDU7tWP614pc+ocKcjnlojo4+NlKedT1U49ZDyugfVP5NApUk2E91GniHTqy4Dflns0s6mv28lDfTyZoywufKS89y8DUxkvLk945cOl+u5OlX05Vfh7AnjnkhN7z589Xr169FBoaWurywMBABQUFFd3/8ccfNXnyZB06dEg+Pj564okn9OSTT5ZpXxaLRXFxcRWSuyLl5Vkua/297y3V4GUvK6hbG8Vt2if/VlfoioFdtHzQJP1r2cs6+t16pZ9MKFOO6Ojoy8oCwHlc6NhUr0srHf56dbG2mN92qe3YofKqX1uZsUlVEa/ScCwEYI8u9/OiM3K043VFvYYZ0ae14sZnFfbUner/2SS5+Xop/US89r63VPs//rGon8nsqn6fTNDxH37XieWbKmTfjvacn29ZgrdyC/zL0NOqrw7lqqMpsbIjAVUiKChIZnP5ykUOV1yKi4tTTEyMRowYUWJZQUGBwsPD1alTp6K2X375RQ888IA+//xz9enTR5mZmUVD58q6v5CQkArJXpFeCrheDd18L9lv4/h3S21P3HZI8+rfVnS/24wHtHXKPGXGJWnnq/N1zcv3afXI/11y+xERERpuh88PAGNc6NjkWc9fWYkpxdqyEpL/WlbL4YtLHAsB2KOyfl6sThzteF2Rr2Hy/hNaffcrF+3T482xSj0crX3vL62QfUqO95yfr/H/famAPv8uQ0+TItLNCrniisJJmgAHFxUVpeDg8k3o73DD4jIyMiRJJpOpxLIlS5YoISGh2JC4yZMna/Lkyerfv7/MZrN8fX3Vtm3bqorrEFr8+zpln05V9OodkqSj366TW00PXfGvawxOBgAAAKAq1OvSSs1v76OgHu1006rXdNOq1xRyQ2ejYxnK5OJavr6lfEcFqguHO3MpJCRErq6uWrduXbH2EydOaNy4cZLOzbeUkZGhrVu3atCgQWrVqpWSk5N1zTXX6K233lKTJk3KtL+goCBFRUVV6GOoCJuGv6KM4xUzXO/wV7/q8Fe/FmtbecuUMq0bGhqqqIWfVkgOAI7vQsemrIQUedb1L9bm8df9v89gcmQcCwHYo4r8vOgsHO14XZWvYcKWg8VGNlQUR3vOz/fNKV8tKMPTb5JVQTUsijpx4tKdAQdw/jRDZeVwxSV3d3eNGjVKc+fO1dChQzV48GBFRUXpo48+UmBgoGJiYoqKS8nJybJarfruu++0cuVK1atXT+PHj9ctt9yiHTt2lHr20z+ZzeZynw5WFdzc7OOlc3Ozz+cHgDEudGxK2HJQDfp21O6Zi4raGvbrqPSoBIcfEidxLARgn+zl86I9cbTjtTO8ho72nJ9vZIC0ME661EA3q0wa0dzNYR8nUBEcblicJM2ePVsPPPCANm/erCeeeEKbN2/W4sWL1aBBA3l5eRVN9O3j4yNJeuyxx9S4cWN5eXlp+vTp2rVrl12ejQQAzmrfh8tVt1NzdZp0p/yaN1Cz2/uo9b2DFP7OD0ZHA4Bqx+zlodptGqt2m8ZycTPLs66/ardpLJ/G5f+lGnBmQZ7SrY3L1u8mx5xWCqgwDlkK9/b21pw5czRnzpxi7Xv37lW7du3k4lJYM/Pz81OjRo3KdIYSAKDynNl9VGvueVVhT9+ltmNuUlZiinbM+EaHPv/F6GgAUO3U6dBMA7+fWnS/9b2D1PreQYr7Y59W3lq2qRGA6mJCWyk9T1oZU7zdpMIzmup7Su92k3zdjUgH2A+HLC6VJiUlRdHR0Ro8eHCx9jFjxuitt97SDTfcoLp162ry5Mm66qqrdMUVVxiUFACqp+jVO4ouHAAAME7cpn2VMrcO4IzMLtK0MGlYI2nhcWnnGSmvQAquKd3cSBoULHk5zbdqwHZO8zYIDw+XpGJXipOkiRMnKjk5WWFhYSooKFDPnj31/fffG5Cwarl6umvAwinybxGsTU99qONLfi+23PuKeurx5li5uJl18qct2vfBUvmHBqvbaw/KWmCV1ZKv3594X+knEwx6BAAAAAAklelzeo83x8qncaDMXh469t167f/oR0lS99fHyLdZA+X/f3v3Hxt1fcdx/HnXy/UoBSo/NysJMBm6oTbQTCZE6GZIlywDpy6LYyTbPwRc5tgwbrBhGhdJ53C4ZZKpbCaCf2yCxjmHg6jg+DFYEUwQqQykBTLoD2mr7fV+7g+yiuMQ/DK4u/b5SO6Py/dyn/fnc8nnPnndfT7feIJtP1pN94m2nG2ESsLctnYpkbJSQuEw+x75E8df3fuR15SPHc2MX38PMlnSiSRbFjxCorObsbOrufH7XyedTNH49CYOb3j9soxDvoRCUD3yzENSbv0+XAqHw9TX11NfX5+HqvIn05vi1e8+zKT5s3Ner/7pt9mz4hlaGhqp3VDH0b/sJN7WyeZ5K0h2dVNZU8VNi+9k2+LHrnDlkiRJks52Mev0Hfc/TiaZIlQS5vatj3Jw7SYqZ95EujfJxtuXM+LGCUxdNo/X73k0ZxvZTJadP36CrqMnKb2qnNrnHjwnXJo0fzaN6zZz+NmtTL5nLp+5axYHfv9Xpi77Fi9+5SekexPUbqijeVMDya7uyzUckgpQUR7oncuiRYvIZrNMmzYt36UUhGwmQ0/L6fNeHzaxkpaGRgCObd7DmGnXE2/r7PsSyCTTZNOZK1GqJEmSpI9xMev0TDIFQElplK7mU6TjSYZOuJq2ff8CoO3Nw4y5+brzN5LN0nX0JADpeBKy594j7b2DTUSHDgYgOqyMeFsHseFDiLd2kuqOk01n6Dh0glFTJl5SfyUVn34TLumTCYU/POS8t+MDSq8a0ve8JBal6r5v8NaTL+WjNEmSJEk5XGidPnP1Yu7Y8Rtadh+EbJb33m7i6llVAFTWVDFoxLCLaqf6gfk52/j39v1Mmj+bOa+spHJWFU0bdxNv6yQ2ciiDRlcQGRxjzM3XU1pRHriPkopTv9kWp0/m7B8iokPLiLd2AGf2Wt/62L3sX/0Cp99uylN1kiRJks52Mev0LQt/RUksSu36Oo78eTvHX3mDUVMmUru+jva33qX9wNELtjN50RxSPb28s27zOdeql81jz0PraP7bPxk/dzpTl97NruVPseP+x7n1t/eS6klw+mAz3SfbL7m/koqL4dIA1dF4jJFV19K69xDXfHkK2354Zs/29JULOfHaPpo27s5zhZIkSZL+60Lr9HA0QiaRIh1PkOrpJd2TAGDvL/8IwKdn3EC6NwlAZHCMcEmYROdHz0W69ptfYvjnx7H1POcyEQoRb+8CIN7a2bf74eTOA7x8Vx2Rshg1a5bQ0vDOJfdXUnExXOrHZj25hBGTx5PqjjNyykROvLaXaEU5R577Ow0PrWP6yoWEIiU0v7yb95tOUVlTxbiv3UL52NGMnzOd9v1H2LX8qXx3Q5IkSRrQzrdOr6yp6lvf3/b0UsKREsLRCO++uIP3m09ROnwINU8sIZNK88HxVv6xbA0A4+fOIBKLcmDNh1vfImUxbnl4Aa1vHKJ2fR0AG+94gEGjKvjcgq/S8PO1vLnqWb74iwVk0xlCkTDb7/sdcGYb3YgbJpBJpdmz4pm+858kDRyhbDbHSW0qeM/P/AGnG4/luwwqPnsNc7esyncZkgpEocxNV5pzoaRCNFDn5I9TbPP15foMv/Dgd9i3aj29bZ3/9/f+X8U25pKC8Z9LkiRJkjSA7PrZH/JdgqR+xrvFSZIkSZIkKTDDJUmSJEmSJAXmtrgiNWTcp/JdAlA4dUgqDAN1Thio/ZZU2JybzlVsY1Js9ebSH/og6cI80FuSJEmSJEmBuS1OkiRJkiRJgRkuSZIkSZIkKTDDJUmSJEmSJAVmuCRJkiRJkqTADJckSZIkSZIUmOGSJEmSJEmSAjNckiRJkiRJUmCGS5IkSZIkSQrMcEmSJEmSJEmBGS5JkiRJkiQpMMMlSZIkSZIkBWa4JEmSJEmSpMAMlyRJkiRJkhSY4ZIkSZIkSZICM1ySJEmSJElSYIZLkiRJkiRJCsxwSZIkSZIkSYEZLkmSJEmSJCkwwyVJkiRJkiQFZrgkSZIkSZKkwAyXJEmSJEmSFJjhkiRJkiRJkgL7D/MgGEUiW1xWAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from circuit_knitting.cutting import cut_wires, expand_observables\n", + "\n", + "qc_w_ancilla = cut_wires(cut_circuit)\n", + "observables_expanded = expand_observables(observables, circuit, qc_w_ancilla)\n", + "qc_w_ancilla.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Visualize the circuit" + "#### Partition the circuit and observables into subcircuits and subobservables. Calculate the sampling overhead incurred from cutting these gates and wires." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling overhead: 1201.0166532117305\n" + ] + } + ], + "source": [ + "from circuit_knitting.cutting import partition_problem\n", + "\n", + "partitioned_problem = partition_problem(circuit=qc_w_ancilla, observables=observables_expanded)\n", + "subcircuits = partitioned_problem.subcircuits\n", + "subobservables = partitioned_problem.subobservables\n", + "print(f\"Sampling overhead: {np.prod([basis.overhead for basis in partitioned_problem.bases])}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "{0: PauliList(['IIII', 'IIII', 'IIIZ']),\n", + " 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import numpy as np\n", - "from qiskit import QuantumCircuit\n", - "\n", - "circ2 = QuantumCircuit(7)\n", - "for i in range(7):\n", - " circ2.rx(np.pi / 4, i)\n", - "circ2.cx(0, 3)\n", - "circ2.cx(1, 3)\n", - "circ2.cx(2, 3)\n", - "circ2.cx(3, 4)\n", - "circ2.cx(3, 5)\n", - "circ2.cx(3, 6)\n", - "\n", - "circ2.draw(\"mpl\", scale=0.8, style=\"iqp\")" + "subobservables" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subcircuits[0].draw(\"mpl\", style=\"iqp\", scale=0.8)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subcircuits[1].draw(\"mpl\", style=\"iqp\", scale=0.8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Perform cut finding" + "#### Generate the experiments to run on the backend." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\n", - "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", - "\n", - "\n", - "\n", - "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAAAAB \n", - "\n", - "\n", - "\n", - "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABABB \n", - "\n", - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AABABCBCC \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: ABCDDEF \n", - "\n" + "576 total subexperiments to run on backend.\n" ] } ], "source": [ - "# Specify settings for the cut-finding optimizer\n", - "optimization_settings = {\"rand_seed\": 12345}\n", - "\n", - "# Specify the size and number of the QPUs available\n", - "qubits_per_qpu = 7\n", - "num_qpus = 2\n", + "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", - "for num in range(num_qpus, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", - " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", - " find_cuts(circ2, optimization_settings, device_constraints)" + "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=np.inf)\n", + "print(f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\")" ] } ], From 3e10f8967434527bbf0d3755ef3202f9d294b565 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 19:33:27 -0500 Subject: [PATCH 015/128] edit string output function --- circuit_knitting/cutting/cut_finding/circuit_interface.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 9146dd0d5..d7f9cd880 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -361,12 +361,10 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - # print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): From aee698eac2f3512595e0022d53d6ae25f70ee2d2 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 19:36:08 -0500 Subject: [PATCH 016/128] clean up utils doc strings. --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 2e41d1449..349c6d0b7 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -82,7 +82,7 @@ def CCOtoQCCircuit(interface): gate_qubits = len(op) - 1 # number of qubits involved in the operation. if ( cut_types[i] is None - ): # only append gates that are not cut to qc_cut. May replace cut gates with TwoQubitQPDGate's in future. + ): # only append gates that are not cut to qc_cut. if type(op[0]) is tuple: params = [i for i in op[0][1:]] gate_name = op[0][0] From 0a8d590f15e2deeb7913c80fce94d8a24a43dc0b Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:49:11 -0600 Subject: [PATCH 017/128] Simplifications in xform func --- circuit_knitting/cutting/cut_finding/utils.py | 26 ++++++------------- 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 349c6d0b7..3c3f732a3 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -35,27 +35,17 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): """ circuit_list_rep = list() - num_circuit_instructions = len(circuit.data) - - for i in range(num_circuit_instructions): - gate_instruction = circuit.data[i] - instruction_name = gate_instruction.operation.name - qubit_ref = gate_instruction.qubits - params = gate_instruction.operation.params - circuit_element = instruction_name - - if ( - circuit_element == "barrier" and len(qubit_ref) == circuit.num_qubits - ): # barrier across all qubits is not assigned to a specific qubit. - circuit_list_rep.append(circuit_element) + for i, inst in enumerate(circuit.data): + # Barrier on all qubits not assigned to a specific qubit + if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: + circuit_list_rep.append(inst.operation.name) else: - circuit_element = (circuit_element,) + circuit_element = (inst.operation.name,) if params: - circuit_element += tuple(params[i] for i in range(len(params))) + circuit_element += tuple(inst.operation.params) circuit_element = (circuit_element,) - for j in range(len(qubit_ref)): - qubit_index = qubit_ref[j].index - circuit_element += (qubit_index,) + for qubit in inst.qubits: + circuit_element += (qubit.index,) circuit_list_rep.append(circuit_element) return circuit_list_rep From 74d984ac07ea0d553739d9c550abdea53b735158 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:50:37 -0600 Subject: [PATCH 018/128] black --- circuit_knitting/cutting/cut_finding/utils.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 3c3f732a3..2e29e4cb8 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -70,9 +70,7 @@ def CCOtoQCCircuit(interface): i ] # the operation, including gate names and qubits acted on. gate_qubits = len(op) - 1 # number of qubits involved in the operation. - if ( - cut_types[i] is None - ): # only append gates that are not cut to qc_cut. + if cut_types[i] is None: # only append gates that are not cut to qc_cut. if type(op[0]) is tuple: params = [i for i in op[0][1:]] gate_name = op[0][0] From 8148475c5612e08e921a3c27b66eaa5f1f7da0f1 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:52:33 -0600 Subject: [PATCH 019/128] update xform code to fix small bug --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 2e29e4cb8..9e258fcda 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -41,7 +41,7 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): circuit_list_rep.append(inst.operation.name) else: circuit_element = (inst.operation.name,) - if params: + if inst.operation.params: circuit_element += tuple(inst.operation.params) circuit_element = (circuit_element,) for qubit in inst.qubits: From 5ca795c45849b3131807d7f2c0cdefadf4f99746 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:53:32 -0600 Subject: [PATCH 020/128] minor simplification --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 9e258fcda..813523e7c 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -35,7 +35,7 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): """ circuit_list_rep = list() - for i, inst in enumerate(circuit.data): + for inst in circuit.data: # Barrier on all qubits not assigned to a specific qubit if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: circuit_list_rep.append(inst.operation.name) From d56a19962bb08efd1c2612c02ec23e8fb92336ec Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 10 Jan 2024 22:35:24 -0500 Subject: [PATCH 021/128] edit doc strings --- circuit_knitting/cutting/cut_finding/cut_optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 475853733..fb99fa381 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -140,7 +140,7 @@ class CutOptimization: CutOptimization focuses on using circuit cutting to create disjoint subcircuits. It then uses upper and lower bounds on the resulting gamma in order to decide where and how to cut while deferring the exact - choices of quasiprobability decompositions to Stage Two. + choices of quasiprobability decompositions. Member Variables: From 78e0691f726e04c220342e892defbe61074faa4e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 11 Jan 2024 11:08:28 -0500 Subject: [PATCH 022/128] edit field name in settings --- circuit_knitting/cutting/cut_finding/optimization_settings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 731ffd727..3cd85ded7 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -100,7 +100,7 @@ def __post_init__(self): self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas if self.engine_selections is None: - self.engine_selections = {"PhaseOneStageOneNoQubitReuse": "Greedy"} + self.engine_selections = {"CutOptimization": "Greedy"} def getMaxGamma(self): """Return the max gamma.""" From 19321a61cc41d1d8f518fdac5e2d8a284d342d49 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 17 Jan 2024 10:34:35 -0600 Subject: [PATCH 023/128] Introduce a CircuitElement tuple --- .../cutting/cut_finding/best_first_search.py | 1 - .../cutting/cut_finding/circuit_interface.py | 40 +++++++++++------ .../cutting/cut_finding/cut_optimization.py | 6 +-- .../cutting/cut_finding/cutting_actions.py | 43 ++++++++++--------- circuit_knitting/cutting/cut_finding/utils.py | 26 ++++++----- 5 files changed, 67 insertions(+), 49 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index d3a3ab7e5..89f25f032 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -266,7 +266,6 @@ def optimizationPass(self, *args): self.num_backjumps += 1 prev_depth = depth - if self.goal_state_func(state, *args): self.penultimate_stats = self.getStats() self.updateUpperBoundGoalState(state, *args) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 2d0084499..acd1f1869 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -11,11 +11,24 @@ """Quantum circuit representation compatible with cut-finding optimizers.""" +from __future__ import annotations + import copy import string -import numpy as np +from typing import NamedTuple from abc import ABC, abstractmethod +import numpy as np + + +class CircuitElement(NamedTuple): + """Named tuple for specifying a circuit element.""" + + name: str + params: list + qubits: tuple + gamma: float | int + class CircuitInterface(ABC): @@ -189,14 +202,19 @@ def __init__(self, input_circuit, init_qubit_names=[]): for gate in input_circuit: self.cut_type.append(None) - if not isinstance(gate, list) and not isinstance(gate, tuple): - self.circuit.append([copy.deepcopy(gate), None]) - self.new_circuit.append(copy.deepcopy(gate)) - + if not isinstance(gate, CircuitElement): + assert gate == "barrier" + self.circuit.append([gate, None]) + self.new_circuit.append(gate) else: - gate_spec = [gate[0]] + [self.qubit_names.getID(x) for x in gate[1:]] - self.circuit.append([copy.deepcopy(gate_spec), None]) - self.new_circuit.append(copy.deepcopy(gate_spec)) + gate_spec = CircuitElement( + name=gate.name, + params=gate.params, + qubits=tuple(self.qubit_names.getID(x) for x in gate.qubits), + gamma=gate.gamma, + ) + self.circuit.append([gate_spec, None]) + self.new_circuit.append(gate_spec) self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) self.num_qubits = self.qubit_names.getArraySizeNeeded() @@ -236,11 +254,10 @@ def getMultiQubitGates(self): The is the list index of the corresponding element in self.circuit """ - subcircuit = list() for k, gate in enumerate(self.circuit): - if isinstance(gate[0], list): - if len(gate[0]) > 2 and gate[0][0] != "barrier": + if gate[0] != "barrier": + if len(gate[0].qubits) > 1 and gate[0].name != "barrier": subcircuit.append([k] + gate) return subcircuit @@ -454,7 +471,6 @@ def getID(self, item_name): If the hashable item does not yet appear in the item dictionary, a new item ID is assigned. """ - if item_name not in self.item_dict: while self.next_ID in self.ID_dict: self.next_ID += 1 diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 475853733..fb4e721ba 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -73,7 +73,7 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1]) <= 3: # change to ==3 + if len(gate_spec[1].qubits) == 2: # change to ==3 action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") @@ -84,7 +84,6 @@ def CutOptimizationNextStateFunc(state, func_args): next_state_list = [] for action in action_list: next_state_list.extend(action.nextState(state, gate_spec, func_args.qpu_width)) - return next_state_list @@ -92,7 +91,6 @@ def CutOptimizationGoalStateFunc(state, func_args): """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy the device constraints and the optimization settings). """ - return state.getSearchLevel() >= len(func_args.entangling_gates) @@ -124,7 +122,6 @@ def greedyCutOptimization( start_state = DisjointSubcircuitsState( circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) ) - return greedyBestFirstSearch(start_state, search_space_funcs, func_args) @@ -260,7 +257,6 @@ def optimizationPass(self): exceeding the minimum upper bound across all cutting decisions previously returned and the optimization settings. """ - state, cost = self.search_engine.optimizationPass(self.func_args) if state is None and not self.goal_state_returned: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 4daa48336..eb1acd2a1 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -124,15 +124,15 @@ def nextStatePrimitive(self, state, gate_spec, max_width): specification: gate_spec. """ - if len(gate_spec[1]) > 3: + gate = gate_spec[1] # extract the gate from gate specification. + if len(gate.qubits) > 2: # The function multiqubitNextState handles # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - gate = gate_spec[1] # extract the gate from gate specification. - r1 = state.findQubitRoot(gate[1]) # extract the root wire for the first qubit + r1 = state.findQubitRoot(gate.qubits[0]) # extract the root wire for the first qubit # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate[2]) # extract the root wire for the second qubit + r2 = state.findQubitRoot(gate.qubits[1]) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. # If applying the gate would cause the number of qubits to exceed @@ -160,7 +160,7 @@ def multiqubitNextState(self, state, gate_spec, max_width): """ gate = gate_spec[1] - roots = list(set([state.findQubitRoot(q) for q in gate[1:]])) + roots = list(set([state.findQubitRoot(q) for q in gate.qubits])) new_width = sum([state.width[r] for r in roots]) # If applying the gate would cause the number of qubits to exceed @@ -267,7 +267,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() gamma_LB, num_bell_pairs, gamma_UB = self.getCostParams(gate_spec) @@ -276,8 +276,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -346,11 +346,12 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): def lookupCostParams(gate_dict, gate_spec, default_value): - gate_name = gate_spec[1][0] + gate_name = gate_spec[1].name if gate_name in gate_dict: return gate_dict[gate_name] + # DO WE NEED THIS LOGIC? WHY WOULD THE NAME BE A TUPLE OR LIST? elif isinstance(gate_name, tuple) or isinstance(gate_name, list): if gate_name[0] in gate_dict: return gate_dict[gate_name[0]](gate_name) @@ -379,7 +380,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -387,8 +388,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -515,7 +516,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -523,8 +524,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -608,7 +609,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -620,8 +621,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -704,10 +705,10 @@ def nextStatePrimitive(self, state, gate_spec, max_width): gate = gate_spec[1] # If the gate is applied to two or fewer qubits, return the empty list - if len(gate) <= 3: + if len(gate.qubits) <= 2: return list() - input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate[1:])] + input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits)] subcircuits = list(set([pair[1] for pair in input_pairs])) return self.nextStateRecurse( @@ -809,7 +810,7 @@ def addCutsToNewState(self, new_state, gate, cuts, downstream_root): cut_triples = list() for i, root in cuts: - qubit = gate[i] + qubit = gate.qubits[i] wire = new_state.getWire(qubit) rnew = new_state.newWire(qubit) cut_triples.append((i, wire, rnew)) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 813523e7c..6344e8e15 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -11,9 +11,14 @@ """Helper functions that are used in the code.""" +from __future__ import annotations + from qiskit import QuantumCircuit -from qiskit.circuit import Instruction +from qiskit.circuit import Instruction, Gate + from .best_first_search import BestFirstSearch +from .circuit_interface import CircuitElement +from ..qpd import QPDBasis def QCtoCCOCircuit(circuit: QuantumCircuit): @@ -33,19 +38,20 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. """ - - circuit_list_rep = list() + circuit_list_rep = [] for inst in circuit.data: - # Barrier on all qubits not assigned to a specific qubit if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: circuit_list_rep.append(inst.operation.name) else: - circuit_element = (inst.operation.name,) - if inst.operation.params: - circuit_element += tuple(inst.operation.params) - circuit_element = (circuit_element,) - for qubit in inst.qubits: - circuit_element += (qubit.index,) + gamma = None + if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: + gamma = QPDBasis.from_instruction(inst.operation).kappa + circuit_element = CircuitElement( + inst.operation.name, + params=inst.operation.params, + qubits=tuple(circuit.find_bit(q).index for q in inst.qubits), + gamma=gamma, + ) circuit_list_rep.append(circuit_element) return circuit_list_rep From 3b8f16f3e4641b79af3a708a319db1abe8b14022 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 22 Jan 2024 09:39:25 -0500 Subject: [PATCH 024/128] Remove remnants of other search algorithms. --- .../cutting/cut_finding/__init__.py | 2 +- .../cutting/cut_finding/circuit_interface.py | 21 +- .../cutting/cut_finding/cut_finding.py | 2 +- .../cutting/cut_finding/cut_optimization.py | 12 +- .../cutting/cut_finding/cutting_actions.py | 217 +----------------- .../cut_finding/disjoint_subcircuits_state.py | 2 +- .../cutting/cut_finding/lo_cuts_optimizer.py | 3 +- .../cut_finding/optimization_settings.py | 29 +-- .../tutorials/LO_circuit_cut_finder.ipynb | 121 +--------- 9 files changed, 31 insertions(+), 378 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index 88a79e9b2..b9765124b 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -1 +1 @@ -from .cut_finding import find_cuts +from .cut_finding import find_cuts \ No newline at end of file diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 2d0084499..f92b264a9 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -102,17 +102,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): assert False, "Derived classes must override insertWireCut()" - @abstractmethod - def insertParallelWireCut(self, list_of_wire_cuts): - """Derived classes must override this function and insert a parallel - LOCC wire cut without ancillas into the circuit. The - list_of_wire_cuts must be a list of wire-cut quadruples of the form: - [..., (, , , ), ...] - - The assumed cut type is "LOCCNoAncillas". - """ - - assert False, "Derived classes must override insertParallelWireCut()" @abstractmethod def defineSubcircuits(self, list_of_list_of_wires): @@ -292,14 +281,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): qubit = self.circuit[gate_ID][0][input_ID] self.output_wires[qubit] = dest_wire_ID - def insertParallelWireCut(self, list_of_wire_cuts): - """Insert a parallel LOCC wire cut without ancillas into the circuit. - The list_of_wire_cuts must be a list of wire-cut quadruples of - the form: - [..., (, , , ), ...] - """ - - assert False, "insertParallelWireCut() not yet implemented" def defineSubcircuits(self, list_of_list_of_wires): """Assign subcircuits where each subcircuit is @@ -466,7 +447,7 @@ def getID(self, item_name): return self.item_dict[item_name] def defineID(self, item_ID, item_name): - """Assign a spefiic ID number to an item name.""" + """Assign a specific ID number to an item name.""" assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" assert ( diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 4f1849d46..13f6005da 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -78,7 +78,7 @@ def find_cuts( # First, replace all gates to cut with BaseQPDGate instances. # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. - # This may not hold in the future as we stop treating gate cuts individually + # This may not hold in the future as we stop treating gate cuts individually. circ_out = cut_gates(circuit, gate_ids)[0] # Insert all the wire cuts diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index fb99fa381..0640ecbd4 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -73,7 +73,7 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1]) <= 3: # change to ==3 + if len(gate_spec[1]) == 3: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") @@ -119,7 +119,6 @@ def greedyCutOptimization( func_args.search_actions = search_actions func_args.max_gamma = optimization_settings.getMaxGamma() func_args.qpu_width = device_constraints.getQPUWidth() - func_args.greedy_multiplier = optimization_settings.getGreedyMultiplier() start_state = DisjointSubcircuitsState( circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) @@ -205,7 +204,6 @@ def __init__( self.func_args.search_actions = self.search_actions self.func_args.max_gamma = self.settings.getMaxGamma() self.func_args.qpu_width = self.constraints.getQPUWidth() - self.func_args.greedy_multiplier = self.settings.getGreedyMultiplier() # Perform an initial greedy best-first search to determine an upper # bound for the optimal gamma @@ -254,11 +252,9 @@ def __init__( def optimizationPass(self): """Produce, at each call, a goal state representing a distinct - set of cutting decisions. The first goal state returned corresponds - to cutting decisions that minimize the lower bound on the resulting gamma. - None is returned once no additional choices of cuts can be made without - exceeding the minimum upper bound across all cutting decisions previously - returned and the optimization settings. + set of cutting decisions. None is returned once no additional choices + of cuts can be made without exceeding the minimum upper bound across + all cutting decisions previously returned and the optimization settings. """ state, cost = self.search_engine.optimizationPass(self.func_args) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 4daa48336..9cda64798 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -59,49 +59,7 @@ def nextState(self, state, gate_spec, max_width): return next_list - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Derived classes must register the action in the specified - AssignmentSettings object, where the action was applied to gate_spec - with the action arguments cut_args""" - - assert False, "Derived classes must override registerCut()" - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Derived classes must initialize the action in the specified - AssignmentSettings object, where the action was applied to gate_spec - with the action arguments cut_args. Intialization is performed after - all actions have been registered.""" - - assert False, "Derived classes must override initializeCut()" - - def nextAssignment( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - """Return a list of next assignment states that result from - applying assignment actions to the input assignment state. - """ - - next_list = self.nextAssignmentPrimitive( - assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ) - - for next_state in next_list: - next_state.setNextLevel(assign_state) - - return next_list - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - """Derived classes must retrieve the appropriate group of QPD - assignment actions from assign_actions, and then collect and - return the combined list of next assignment states that result - from applying those actions to the input assignment state, with - the constraint object, gate_spec, and cut_args provided as inputs - to the nextState() methods of those assignment actions.""" - - assert False, "Derived classes must override initializeCut()" - + class ActionApplyGate(DisjointSearchAction): @@ -125,15 +83,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ if len(gate_spec[1]) > 3: - # The function multiqubitNextState handles - # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - gate = gate_spec[1] # extract the gate from gate specification. - r1 = state.findQubitRoot(gate[1]) # extract the root wire for the first qubit - # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate[2]) # extract the root wire for the second qubit - # acted on by the given 2-qubit gate. + gate = gate_spec[1] + r1 = state.findQubitRoot(gate[1]) + r2 = state.findQubitRoot(gate[2]) # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate @@ -156,7 +110,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): def multiqubitNextState(self, state, gate_spec, max_width): """Return the new state that results from applying - ActionApplyGate to state given a multiqubit gate specification: gate_spec. + ActionApplyGate to state given a multiqubit (3 or more qubits) + gate specification: gate_spec. """ gate = gate_spec[1] @@ -304,34 +259,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): def getCostParams(self, gate_spec): return lookupCostParams(self.gate_dict, gate_spec, (None, None, None)) - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the gate cuts made by a ActionCutTwoQubitGate action - in an AssignmentSettings object. - """ - - assignment_settings.registerGateCut(gate_spec, cut_args[0][0]) - assignment_settings.registerGateCut(gate_spec, cut_args[1][0]) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the gate cuts made by a ActionCutTwoQubitGate action - in an AssignmentSettings object. - """ - - assignment_settings.initGateCut(gate_spec, cut_args[0][0]) - assignment_settings.initGateCut(gate_spec, cut_args[1][0]) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("TwoQubitGateCut") - - new_list = list() - for action in action_list: - new_list.extend( - action.nextState(assign_state, constraint_obj, gate_spec, cut_args) - ) - - return new_list def exportCuts(self, circuit_interface, wire_map, gate_spec, args): """Insert an LO gate cut into the input circuit for the specified gate @@ -413,31 +340,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutLeftWire action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutLeftWire action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified @@ -451,36 +353,6 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) -def registerAllWireCuts(assignment_settings, gate_spec, cut_args): - """Register a list of wire cuts in an AssignmentSettings object.""" - - for cut_triple in cut_args: - assignment_settings.registerWireCut(gate_spec, cut_triple) - - -def assignWireCuts(action_list, assign_state, constraint_obj, gate_spec, tuple_list): - if len(tuple_list) <= 0: - return [ - assign_state, - ] - - wire_cut = tuple_list[0] - new_states = list() - for action in action_list: - new_states.extend( - action.nextState(assign_state, constraint_obj, gate_spec, wire_cut) - ) - - final_states = list() - for state in new_states: - final_states.extend( - assignWireCuts( - action_list, state, constraint_obj, gate_spec, tuple_list[1:] - ) - ) - - return final_states - def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): """Insert LO wire cuts into the input circuit for the specified @@ -549,31 +421,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutRightWire action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutRightWire action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified @@ -643,32 +490,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutBothWires action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutBothWires action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. @@ -823,32 +644,6 @@ def addCutsToNewState(self, new_state, gate, cuts, downstream_root): return cut_triples - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionMultiWireCut action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionMultiWireCut action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 5d24c6158..5366eb6a2 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -13,7 +13,7 @@ import copy import numpy as np -from collections import Counter, namedtuple +from collections import Counter class DisjointSubcircuitsState: diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 8be8a3521..cfa3c80ed 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -22,8 +22,7 @@ ### Functions for generating the cut optimization search space cut_optimization_search_funcs = SearchFunctions( - cost_func=CutOptimizationUpperBoundCostFunc, # Change to CutOptimizationCostFunc with LOCC - # or after the new LO QPD's are incorporated into CKT. + cost_func=CutOptimizationUpperBoundCostFunc, # Valid choice only for LO cuts. upperbound_cost_func=CutOptimizationUpperBoundCostFunc, next_state_func=CutOptimizationNextStateFunc, goal_state_func=CutOptimizationGoalStateFunc, diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 3cd85ded7..563feff02 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -55,9 +55,6 @@ class OptimizationSettings: gate_cut_LOCC_with_ancillas (bool) is a flag that indicates that LOCC gate cuts with ancillas should be included in the optimization. - gate_cut_LOCC_no_ancillas (bool) is a flag that indicates that - LOCC gate cuts with no ancillas should be included in the optimization. - wire_cut_LO (bool) is a flag that indicates that LO wire cuts should be included in the optimization. @@ -67,6 +64,9 @@ class OptimizationSettings: wire_cut_LOCC_no_ancillas (bool) is a flag that indicates that LOCC wire cuts with no ancillas should be included in the optimization. + NOTE: The current release only support LO gate and wire cuts. LOCC + flags have been incorporated with an eye towards future releases. + Raises: ValueError: max_gamma must be a positive definite integer. @@ -76,8 +76,6 @@ class OptimizationSettings: max_gamma: int = 1024 max_backjumps: int = 10_000 - greedy_multiplier: float | int | None = None - beam_width: int = 30 rand_seed: int | None = None LO: bool = True LOCC_ancillas: bool = False @@ -89,8 +87,6 @@ def __post_init__(self): raise ValueError("max_gamma must be a positive definite integer.") if self.max_backjumps < 0: raise ValueError("max_backjumps must be a positive semi-definite integer.") - if self.beam_width < 1: - raise ValueError("beam_width must be a positive definite integer.") self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas @@ -100,7 +96,7 @@ def __post_init__(self): self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas if self.engine_selections is None: - self.engine_selections = {"CutOptimization": "Greedy"} + self.engine_selections = {"CutOptimization": "BestFirst"} def getMaxGamma(self): """Return the max gamma.""" @@ -110,14 +106,6 @@ def getMaxBackJumps(self): """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def getGreedyMultiplier(self): - """Return the greedy multiplier.""" - return self.greedy_multiplier - - def getBeamWidth(self): - """Return the beam width.""" - return self.beam_width - def getRandSeed(self): """Return the random seed.""" return self.rand_seed @@ -135,24 +123,20 @@ def clearAllCutTypes(self): self.gate_cut_LO = False self.gate_cut_LOCC_with_ancillas = False - self.gate_cut_LOCC_no_ancillas = False - self.wire_cut_LO = False self.wire_cut_LOCC_with_ancillas = False self.wire_cut_LOCC_no_ancillas = False def setGateCutTypes(self): """Select which gate-cut types to include in the optimization. - The default is to include all gate-cut types. + The default is to include LO gate cuts. """ - self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas - self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas def setWireCutTypes(self): """Select which wire-cut types to include in the optimization. - The default is to include all wire-cut types. + The default is to include LO wire cuts. """ self.wire_cut_LO = self.LO @@ -169,7 +153,6 @@ def getCutSearchGroups(self): if ( self.gate_cut_LO or self.gate_cut_LOCC_with_ancillas - or self.gate_cut_LOCC_no_ancillas ): out.append("GateCut") diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 3bf65a396..10a54a662 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -29,21 +29,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from qiskit.circuit.library import EfficientSU2\n", "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", @@ -67,37 +55,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", - "Subcircuits: AAAB \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", - "Subcircuits: AABB \n", - "\n" - ] - } - ], + "outputs": [], "source": [ "settings = OptimizationSettings(rand_seed = 12345)\n", "\n", @@ -150,21 +110,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from qiskit import QuantumCircuit\n", "qc_0 = QuantumCircuit(7)\n", @@ -189,58 +137,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", - "\n", - "\n", - "\n", - "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAAAAB \n", - "\n", - "\n", - "\n", - "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABABB \n", - "\n", - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AABABCBCC \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: ABCDDEF \n", - "\n" - ] - } - ], + "outputs": [], "source": [ "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", @@ -297,7 +196,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.9.6" } }, "nbformat": 4, From 71d2c6045b3601b9e366ec2a045200a30b038b29 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 22 Jan 2024 13:40:42 -0600 Subject: [PATCH 025/128] Fix cost lookup logic --- .../cutting/cut_finding/cutting_actions.py | 63 ++++++++++++------- 1 file changed, 42 insertions(+), 21 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 66b96c14e..ddaf09127 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -88,9 +88,13 @@ def nextStatePrimitive(self, state, gate_spec, max_width): # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - r1 = state.findQubitRoot(gate.qubits[0]) # extract the root wire for the first qubit + r1 = state.findQubitRoot( + gate.qubits[0] + ) # extract the root wire for the first qubit # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate.qubits[1]) # extract the root wire for the second qubit + r2 = state.findQubitRoot( + gate.qubits[1] + ) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. # If applying the gate would cause the number of qubits to exceed @@ -164,48 +168,64 @@ def __init__(self): self.gate_dict = { "cx": (1, 1, 3), + "cy": (1, 1, 3), + "cz": (1, 1, 3), + "ch": (3, 0, 3), + "cp": (1, 1, 3), + "cs": (1, 1, 1 + 2 * np.sin(np.pi / 4)), + "csdg": (1, 1, 1 + 2 * np.sin(np.pi / 4)), + "csx": (1, 1, 1 + 2 * np.sin(np.pi / 4)), "swap": (1, 2, 7), "iswap": (1, 2, 7), + "dcx": (7, 0, 7), + "ecr": (3, 0, 3), "crx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), + ) + ), + "cp": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[0] / 2)), + 0, + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "cry": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "crz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "rxx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), "ryy": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), "rzz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), } @@ -278,14 +298,13 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): def lookupCostParams(gate_dict, gate_spec, default_value): gate_name = gate_spec[1].name - - if gate_name in gate_dict: + params = gate_spec[1].params + if len(params) == 0: return gate_dict[gate_name] - # DO WE NEED THIS LOGIC? WHY WOULD THE NAME BE A TUPLE OR LIST? - elif isinstance(gate_name, tuple) or isinstance(gate_name, list): - if gate_name[0] in gate_dict: - return gate_dict[gate_name[0]](gate_name) + else: + if gate_name in gate_dict: + return gate_dict[gate_name]((gate_name, *params)) return default_value @@ -533,7 +552,9 @@ def nextStatePrimitive(self, state, gate_spec, max_width): if len(gate.qubits) <= 2: return list() - input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits)] + input_pairs = [ + (i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits) + ] subcircuits = list(set([pair[1] for pair in input_pairs])) return self.nextStateRecurse( From 754e5d20bf339c7d42256ca0b262de20f4c2f8db Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 22 Jan 2024 16:32:43 -0500 Subject: [PATCH 026/128] snapshot test notebook before pull --- .../cutting/cut_finding/best_first_search.py | 4 -- .../cutting/cut_finding/circuit_interface.py | 31 ++++------ .../cutting/cut_finding/cut_optimization.py | 2 +- .../cutting/cut_finding/cutting_actions.py | 14 ++--- .../cut_finding/optimization_settings.py | 11 +--- .../tutorials/04_automatic_cut_finding.ipynb | 56 +++++++++---------- 6 files changed, 44 insertions(+), 74 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index 89f25f032..eea25f5cd 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -350,10 +350,6 @@ def put(self, state_list, depth, args): self.pqueue.put(state, depth, cost) self.num_enqueues += 1 - # if (bfs_debug > 2): - # print() - # state.print(simple=True) - def updateMinimumReached(self, min_cost): """Update the minimum_reached flag indicating that a global optimum has been reached. diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index e93f312b9..4b0cc646f 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -45,8 +45,6 @@ def getNumQubits(self): """Derived classes must override this function and return the number of qubits in the input circuit.""" - assert False, "Derived classes must override getNumQubits()" - @abstractmethod def getMultiQubitGates(self): """Derived classes must override this function and return a list that @@ -88,18 +86,12 @@ def getMultiQubitGates(self): the allowed cut types are 'None', 'GateCut', 'WireCut', and 'AbsorbGate'. """ - assert False, "Derived classes must override getMultiQubitGates()" - @abstractmethod def insertGateCut(self, gate_ID, cut_type): """Derived classes must override this function and mark the specified gate as being cut. The cut type can only be "LO" in this release. - In the future, support for "LOCCWithAncillas" and "LOCCNoAncillas". - will be added. """ - assert False, "Derived classes must override insertGateCut()" - @abstractmethod def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): """Derived classes must override this function and insert a wire cut @@ -109,12 +101,9 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): is also provided as input to allow the wire choice to be verified. The ID of the new wire/qubit is also provided, which can then be used internally in derived classes to create new wires/qubits as needed. - The cut type can only be "LO" in this release. In the future, support - for "LOCCWithAncillas" and "LOCCNoAncillas" will be added. + The cut type can only be "LO" in this release. """ - assert False, "Derived classes must override insertWireCut()" - @abstractmethod def defineSubcircuits(self, list_of_list_of_wires): @@ -123,7 +112,6 @@ def defineSubcircuits(self, list_of_list_of_wires): list of wire IDs. """ - assert False, "Derived classes must override defineSubcircuits()" class SimpleGateList(CircuitInterface): @@ -220,6 +208,8 @@ def __init__(self, input_circuit, init_qubit_names=[]): (len(self.scc_subcircuits), len(self.scc_subcircuits)), dtype=bool ) + + def getNumQubits(self): """Return the number of qubits in the input circuit.""" @@ -252,8 +242,8 @@ def getMultiQubitGates(self): return subcircuit def insertGateCut(self, gate_ID, cut_type): - """Mark the specified gate as being cut. The cut type can - be "LO", "LOCCWithAncillas", or "LOCCNoAncillas". + """Mark the specified gate as being cut. The cut type in this release + can only be "LO". """ gate_pos = self.new_gate_ID_map[gate_ID] @@ -266,8 +256,7 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): wire/qubit ID of the source wire to be cut is also provided as input to allow the wire choice to be verified. The ID of the (new) destination wire/qubit must also be provided. The cut - type as of now can only be "LO", with the options "LOCCWithAncillas" - and "LOCCNoAncillas" being added in the future. + type in this release can only be "LO". """ gate_pos = self.new_gate_ID_map[gate_ID] @@ -346,7 +335,6 @@ def exportOutputWires(self, name_mapping="default"): out = dict() for in_wire, out_wire in enumerate(self.output_wires): out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] - return out def exportSubcircuitsAsString(self, name_mapping="default"): @@ -359,12 +347,11 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - # print('subcircuits:', self.subcircuits) + return "".join(out) def makeWireMapping(self, name_mapping): @@ -452,7 +439,9 @@ def getID(self, item_name): If the hashable item does not yet appear in the item dictionary, a new item ID is assigned. """ - if item_name not in self.item_dict: + + + if not item_name in self.item_dict: while self.next_ID in self.ID_dict: self.next_ID += 1 diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index e24ba6082..a36ec296e 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -73,7 +73,7 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1].qubits) == 2: # change to ==3 + if len(gate_spec[1].qubits) == 2: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 66b96c14e..ce1012439 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -25,15 +25,11 @@ class DisjointSearchAction(ABC): @abstractmethod def getName(self): - """Derived classes must return the look-up name of the action""" - - assert False, "Derived classes must override getName()" + """Derived classes must return the look-up name of the action.""" @abstractmethod def getGroupNames(self): - """Derived classes must return a list of group names""" - - assert False, "Derived classes must override getGroupNames()" + """Derived classes must return a list of group names.""" @abstractmethod def nextStatePrimitive(self, state, gate_spec, max_width): @@ -41,9 +37,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): result from applying all variations of the action to gate_spec in the specified DisjointSubcircuitsState state, subject to the constraint that the number of resulting qubits (wires) in each - subcircuit cannot exceed max_width""" - - assert False, "Derived classes must override nextState()" + subcircuit cannot exceed max_width. + """ def nextState(self, state, gate_spec, max_width): """Return a list of search states that result from applying the @@ -152,7 +147,6 @@ class ActionCutTwoQubitGate(DisjointSearchAction): """Action class that implements the action of cutting a two-qubit gate. - . TODO: The list of supported gates needs to be expanded. """ diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 563feff02..29dff1157 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -64,7 +64,7 @@ class OptimizationSettings: wire_cut_LOCC_no_ancillas (bool) is a flag that indicates that LOCC wire cuts with no ancillas should be included in the optimization. - NOTE: The current release only support LO gate and wire cuts. LOCC + NOTE: The current release only supports LO gate and wire cuts. LOCC flags have been incorporated with an eye towards future releases. Raises: @@ -118,15 +118,6 @@ def setEngineSelection(self, stage_of_optimization, engine_name): """Return the name of the search engine to employ.""" self.engine_selections[stage_of_optimization] = engine_name - def clearAllCutTypes(self): - """Reset the flags for all circuit cutting types""" - - self.gate_cut_LO = False - self.gate_cut_LOCC_with_ancillas = False - self.wire_cut_LO = False - self.wire_cut_LOCC_with_ancillas = False - self.wire_cut_LOCC_no_ancillas = False - def setGateCutTypes(self): """Select which gate-cut types to include in the optimization. The default is to include LO gate cuts. diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index f8b56fc2e..058a7589b 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -16,17 +16,17 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/0AAAGRCAYAAAA3ltNoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1jklEQVR4nO3deVhUZR/G8e/AgIAsKgqooOKCuymaS2pptmhampW2abaXZdlmVpaZ5ZtZabaalbarLaapWe5b5q7hiruAbCogsg8z7x8kRoCCAmdmuD/X1dX4nOecuWeGmTm/Oc95jslms9kQEREREREREafjYnQAERERERERESkfKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJmY0OICIiIiIi57fsnjdJPRJndIwS82kQRK8vRxsdo5CnNkBMutEpoK4XTO5kdAqpLFT0i4iIiIjYudQjcSRHRhsdw+HFpMOhVKNTiFQsDe8XERERERERcVIq+kVERERERESclIp+ERERERERESelc/orkV0HklizNY4tu09w5PgZcixWvDzMtGhYjfYtatKrUx0C/D2NjikiIiIiIiJlREW/k7PZbMxefIj3v9/Nn9sTiuzz29q8SWHczC7cdl0oTw9tRfsWNSsypoiIiIiIiJQDDe93YkdiUrnmwd+44/mVxRb8/5ZjsfLdooN0vHM+z72zkYxMSwWkFBERERERkfKiot9Jrdocy2W3zWX5xthSr2u12nj7ywi6Dl1AwsmMckgnIiIiIiIiFUFFvxNaty2ePsN/5/SZnCKXu7qaqBvoRd1AL1xdTcVuZ9vek/R68DdOpWSVV1QREREREREpRyr6nczJ5ExueXoZGZm5xfYJqulJ9JI7iF5yB0E1zz9x384DSTzw6hpsNltZRxUREREREZFy5tBF/44dO+jfvz9+fn74+voyYMAAYmNj8fHx4fbbbzc6niGenPgX8WU8JH/usqPMXnyoTLcpIiIiIiIi5c9hZ+9ftmwZ/fr1o379+owZMwZPT09mzpxJnz59OHPmDG3btjU6YoXbvvck3y48WC7bfn7KJm67LhRXV4f+nUhERCrImRxYFA2r4yDdAjWqQJ9guCoIzPoqESkzda9uR/sX7sSvSTAZCUns/nwRu6ctMDqWU0mNWEnkmJ7n7dN+nkbF/ldurpVFa6L56tf9HE9Mx8vDzA3dQxjWvwnVfasYHa9ScciiPzExkcGDBxMeHs7SpUvx9Mwboj5kyBBCQ0MBKmXR/9HsPeW27WOxaSxaE82NPeqV232IiIhzWBUHY7ZAxj9nmpkAG7AyDup4wZRO0NDHyIQizsH/skb0mvk8Oz+Zz6rhU6jVrgldJj5EbkY2+776w+h4TqNqsytoM7Pw5NiZUXvYP/4Gal33kAGp7Nuh6NP0fewP9h5OAcD0zzRiS/86zotTN/P5q925s28jAxNWLg75W/vEiRNJSkpixowZ+QU/gJ+fH+Hh4UDlK/pzcvIut1eevpy/v1y3LyIiju+vBHhuI/x7apl/H/86ng4Pr4PY9AqPJuJ0Wj7UjxPbD7J1wnek7I/hwJyV7PniN1o/PsDoaE7Fxc0dt+pBBf4zubpx5MMH8GnVg+D73jU6ol2JP5lBz/sW5Rf8ADZb3n8AWdm53P3iSn5ZfsSYgJWQQxb9s2bNonv37oSFhRW5PDAwkKCgIAAsFgtPPvkkNWrUoFq1atx///1kZmZWZNwKsftQEmkZlnK9j407E8t1+yIi4thsNpiyK6/IP99A16RsmKnfkUUuWUDHZsSs2FagLWbFdrxDAvCqXcOgVM7PZsnh4MRbcHHzoOFzszG5uhodya5M/nonx+LSil1+tvh/6q0NWK06LaIiONzw/ri4OGJiYhg8eHChZVarlYiICNq1a5ffNmHCBFasWEFERATu7u7cdNNNjBo1iqlTp5bo/iwWC3FxcWWWv7ws+zOmUJurq6nI2flr/6ut9nlm7487kUFu7rk3YlRcGjt2HcLfz/0S04qIiDPac8adA6kBJehpY0GUjVuqxeLlqh0+kZLIySl8cMczoBoZickF2jISkv5ZVp302FMVEa1IOTkWoqOjDbv/4uTkBAJul7SNY58MJ/PYLpq9vRFXL9+LzJFDdHT8JeWwR1k5Vj79YU/+aV3FsdngyPEzfDtvOz0vr1VR8RxeUFAQZnPpS3iHK/rT0vJ+NTKZCl9fft68eSQkJBQY2v/ZZ5/x1ltvUbduXQBeffVVbrvtNiZPnoxrCX6Vi4uLIyQkpGzCl6eavaH2rQWazl6a73w2fT+g2GXB135PTHzB8Zdt23eDrMLnNImIiAT0e4KQB98rQU8TWVYT7a4ZQPqBzeWeS8QZvO5/LXXdLq7ANEJkZCSD7HAfusX7O/Gs1/Ki14+fN5mTK76iyWtLqRIYetHbiYyMJOT6Vhe9vt1yD4Smb5S4+9BHXoEETTxZUlFRUQQHB5d6PYcb3h8SEoKrqyurVq0q0H706FFGjBgBnDufPzk5maioqAI/AoSHh5OamsqRI0cqKLGzKfxji4iICAAupdutMLloSKzIpchISMazVrUCbR7//PvsEX8pOylbfiN65nPUGz4Nn5bdjY5jn4o4MHt+DleOOiSHO9Lv7u7O0KFDmTFjBv3796dv375ERUUxffp0AgMDiYmJyS/yU1NTAahWrVr++mdvn112IUFBQURFRZXlQygX3/4Wxej3dxdoizuRQfC13xfqW7umZ/4R/svv+IXYExlFbjOuiPZNG1YR5O9x6YFFRMTpbE2pwmslnFPWFRsbf/8ZX7O1fEOJOIn1g94k7XDBU04TNu6lTo+27Jj8Y35b3Z5tOROVYOjQfoCwsDCi5nxhaIaijNgdSNRFTO+VcWwXh96+ncABz1Cz17BLzhEWFsbvDlBjlFZ6poW2d6wgI6tkn+0fTX6ZG6/8sJxTOY+z89aVlsMV/QBTp07Fzc2NefPmsXz5crp06cLcuXN57bXXOHDgQP4Efz4+edcDSklJyX+CkpOTCyy7ELPZfFFDKCpaz85V4D9Ff26urdDw/P+KPZFxwT5nBdTwoH2bRkWeWiEiIlK7Lkw/DnEZ5z+XE+CauiZaNKhTIblEnIGbW+Hd9l2fLqDvr2/QbvQdHPpxFTXbNaH5fX3Y9OqXBiQsyM3NPveh3fYDpSz6LadPcOD1G/EKbUtAvyfJSSo835fZt1apJvRzc3Ozy+enLNxzUxif/LD3vH1MQM3qHtx/Wzvc3TTqq7w5ZNHv7e3NtGnTmDZtWoH2nTt30rp1a1z+GV5YrVo1QkJC2L59O02bNgVg27Zt+Pj40KBBg4qOXa7ahFXHzexCjqX8jph0aFlTBb+IiBTL1QSPNoNXthXfxwS4u8C9TSoslojTOrnjIMvvfYvwF+6k1SM3kZGYzNaJ37Pvqz+MjuZUUjYvJDv+MNnxh4m4r26RfVp9epgqgQ0qNpideuae1nz/20FOp+Xkz9T/Xzbg1UdV8FcUhyz6i5KcnEx0dDR9+/Yt0P7AAw/wv//9j+7du+Pm5sarr77KsGHDSjSJnyPxqGLm5l71mfP74XK7jzv6NCq3bYuIiHO4IQRO58A7O4s+2u9phnc7QmPHmY9MxK5FL9tK9LKtRsdwav5X34P/1fcYHcNhNK7ny++f9OaG4X9w6nQWJhOFiv/XH2/P8NtbGBOwEnKamRMiIiIACkzaB/Diiy9y5ZVX0rJlSxo3bkzz5s2ZOHGiAQnL3/DBzctt2zWre3DrtQ3KbfsiIuI8bm8IP14N1//rgFiwF4xoDvN6QYeaxmUTEZHy16lNAAcW3cbk5zrRPLRafvs9NzVh588DeemhtoZlq4ycvug3m81MnTqVpKQkUlJS+Pzzz/H0LP7a9I7syvZBXNO5fM6PfOmBy/Co4jQDQ0REpJzV94Y7G5779xvt4Z4mUL2KcZlERKTiVPetwsghrfj9k975ba8/3p6WjasbmKpycpqif/jw4dhsNjp37mx0FMOYTCY+e7Ub3l5uZbrdbu0CeeKui7+eqYiIiIiIiBjDaYp+yVO/jg8zXuuOi0vxE+6dvZRf8LXfF3lZvn+rE+DF1xOuOu/2RERERERExD6p6HdCt14XyldvXImra9GF+tlL+cXEp5ObW/xFlYIDq7Jseh8a1C3Z5Q1FRERERETEvqjod1J39W3Mmpl9Cavvd1Hr39yrPptn9afZvybeEBEREREREceiot+JdbkskO0/DGD84+HUCfAq0TqdWtfih7ev5qd3exHo75wTHoqIiIiIiFQWmo7dyXl6mBnzUDuev/cyflsbxZqt8fy5PZ4/dyQAEFrXh8ua1qB9C3/6dAuhfQtdR0lERERERMRZqOivJNzcXLipZ31u6lmf6Lg0Qq6bBcDqGX0JDqpqcDoREREREREpDxreLyIiIiIiIuKkVPSLiIiIiIiIOCkV/SIiIiIiIiJOSuf0i4iIiIhIpVC3ZBe0Knf2kkMqBxX9IiIiIiJSKUzuZHQCkYqn4f0iIiIiIiIiTkpFv4iIiIiIiIiTUtEvIiIiIiIi4qRU9IuIiIiIiIg4KRX9IiIiIiIiIk5KRb+IiIiIiIiIk1LRLyIiIiIiIuKkVPSLiIiIiIiIOCkV/SIiIiIiIiJOSkW/iIiIiIiIiJNS0S8iIiIiIiLipFT0i4iIiIiIiDgpFf0iIiIiIiIiTkpFv4iIiIiIiIiTUtEvIiIiIiIi4qTMRgcQEbkUy+55k9QjcUbHKDc+DYLo9eVoo2NcMmd5nZzl9RARqSxuGrGEg9GnjY5xQY2CfZn//rVGxxAnpaJfRBxa6pE4kiOjjY4hF6DXSUREjHAw+jS7DyYbHUPEUBreLyIiIiIiIuKkVPSLiIiIiIiIOCkV/SIiIiIiIiJOSkW/iIiIiIiIiJNS0S8i8h+9fxrHFW8/UqjdO7gWw2J/JKBjMwNSCei1ERERESktFf0iIiIiIiIiTkpFv4iIiIiIiIiTUtEvIiIiIiIi4qTMRgcQEXFEXnX86T51BJ61/LBZbUR+u5Q9ny0yOpag10ZERETk3xz6SP+OHTvo378/fn5++Pr6MmDAAGJjY/Hx8eH22283Op5IqeVm55CweR/HV/9N0t5j2Gw2oyNJMWyWXDaN+5JfrnqKhX1fpNk91+MXFmx0LEGvjYiIiJSP7NR04tbv5viav0k9Fm90nBJz2CP9y5Yto1+/ftSvX58xY8bg6enJzJkz6dOnD2fOnKFt27ZGRxQpMUt6FhEfzGXf10vIPJGS3169ZQNaPXITDW/pjslkMjBh5ZJ9Oh1336qF2t398tpys3LISEgmIyEZAEt6JikHjuMVVIOUyOiKjFrp6LUREZGy0L19EM8MbUXbpv7Ur+PNmPe38Mb07UbHEjuVHp/Ejsk/cvCHlVjSs/Lba3dvTZsnBlK7W2sD012YQxb9iYmJDB48mPDwcJYuXYqnpycAQ4YMITQ0FEBFvziMnLQM/hg8nsQtkfCfuj5p9xHWjJhK0t6jdBgzxJiAlVDKgRga3NgFk4sLNqs1v71mu8ZYLbmkHo4t0N87uBb+rUM5sXV/RUetdPTaiIhIWfD2NLP7YDLfLTrIlFGdjY4jdiw1KoHfBrxM+vGThZbFrokgdt1Ouk95nEa3XWVAupJxyOH9EydOJCkpiRkzZuQX/AB+fn6Eh4cDKvrFcWx8eUZewQ/w39H8//x754fzOPLrnxWaqzLb++ViPGr50XXKY/i3aYhP/UBCB3Sl3ajbOTB7Bdmn0/P7mr086PH5s2x89UtyzmQYmLpy0GsjIiJl4be10bw4dTNzfj9MVnau0XHETtlsNlbe/3aRBf+/OrH2qQ9J2hdVccFKySGL/lmzZtG9e3fCwsKKXB4YGEhQUBAAc+bMoVu3bnh7e9OgQYMKTClyYZknUjj446oLdzTBrk8Xln8gASAt+gSLbnyJKn5V6fXlaG5a/g5tnhjIzo/ms3709Px+JrMrPT9/lsO/rOPogvUGJq489NqIiIhIRUnYuJeTEYfO38kGtlwr+2YurphQF8HhhvfHxcURExPD4MGDCy2zWq1ERETQrl27/Lbq1avz+OOPEx8fz+TJk0t9fxaLhbi4uEvKbG9iT2Seux0XCxYPA9NUbtE/r8OaU4Jfl22QuHkf+zfuwLOOf/kHcyA5OZZy2W7S7qMsu+fN8/bp+u5wUvZHs+vj+eWSAfIeX3S045+LXpavk5GvjbO8HhUlPs0NCMy7nRCPX1qOsYFEHFh5fd+VF3v5vLTkOMbnjiUnxy6er/LgyLXH3q9LXsgf+HEVwY/1Kcc0EBQUhNlc+hLe4Yr+tLQ0gCInNZs3bx4JCQkFhvZfe+21APzyyy8XdX9xcXGEhIRc1Lp2y1wdmk8CoOPlHcGSZHCgyqtf1abc4tOqxP2v69qDI5bk8gvkgF73v5a6br4Vfr8BHZvR+LarOLX7KDctyXs/bZs0m6g/Npfp/URGRjLICT6DKvJ1Ks/Xxllej4ri1bgDzd/ZBMCN/fqRfqBs3x8ilYlR33cXy24+L5uMA4+6Rqe4oMjISEJC7jA6Rvlw4NrjUb9OdPQs2RWALGcyqR9SD2uh83XLTlRUFMHBpb8ikcMV/SEhIbi6urJqVcEh0UePHmXEiBGAzucXx5FhK92v9qXtL+UnYeNeZta+1egYUgS9NiIiIlIWMm0lHymSbcst14L/Ujhc0e/u7s7QoUOZMWMG/fv3p2/fvkRFRTF9+nQCAwOJiYkp06I/KCiIqCj7nZThYsSeyKTj0LwfTTZu2kjtmo4zxMbZZBw/yboB4wtP4PdfJqjaIJBNG3fr0n3/sX7Qm6Qddq5TcP4tLCyMqDlfGB3jkjnL6+Qsr0dFiUxzY9S+vNu/LlhAWFXHGGYrYo8c7XPUXj4vez2ylshjaUbHuKCwsDCWLXeumuMsR649EtfsYsfT0y/cEajXuyNRr79frnnOzltXWg5X9ANMnToVNzc35s2bx/Lly+nSpQtz587ltdde48CBA8VO8HcxzGbzRQ2hsGvmcx98tYNqExxU+JrXUkGCgzl2XQeifr/AkFcbtH7oRuc71aQMuLk55MdYibm5OcdnkLO8Ts7yelSUlCTgn6I/MCCQ4OqGxhFxaI72OWovn5dmN7ci26t6mmlcL+90CXc3F4JqenJZ0xqcSc/hYFRqRUYE8nLaw/NVLhy49qgzqDYHJ//CmejECx6kC3/sZgLs9DV0yNn7vb29mTZtGnFxcaSmpvLHH3/QpUsXdu7cSevWrXFxcciHJZVUl4kP4x1Sq+iF/xzUr9+3M2FDrq24UCIiIiJOrEPLmmz/4Wa2/3AzdQKq8vgdLdj+w8189mp3o6OJHXFxdaXHp89g9ipmdMI/++ptnx1EwOXNKi5YKTnWT4bnkZycTHR0NH379i3QnpubS05ODjk5OdhsNjIzMzGZTFSpUsWgpCIFeQVW54YFE9j4ygyO/voXNqs1f5m7b1Wa3dubts8MwsXV1cCUIiIiIs5j1eY4TG0+NzqGOICabRtzw/zX2fTql8SuiSiwrGrdWlz25EDC7rbvg3NOU/RHROS9AP89n//rr7/m3nvvzf+3p6cn9evX58iRIxWYTuT8vAKq0+OTp4m6bRvL7n4DgPCX7qbF/X0we+oHqtK4+9C3nNh2AIDdny3k2G8bCyxv+8wgGt/ek5T90Sy5M++5rhYWTJdJD2Oz2rBZcln3zMecOZZQ7H34X9aIjq/di8nFxJ4vfuPw3LUFljce1IPLnr6NtJgTACy56w1yM7OLXM87uBY3/vEWSXuOAbBlwrckbokss+fDHnkH1+LKj0ZitVgwubry1+jpJO05WqBP13eH49MgELOXB4d+Ws3u6QuBC7++/9b7p3G4uJmx5liIW7+L7W/PKbC8xYN9Cb25G9acXE5FHGLDmC9KtJ6IiIhULjVaNOD6OWOJXbeL328dC0D3D54kdMAVDnFgzumL/mHDhjFs2LCKDyRyETxq+OTfrt21lQr+i5AWc4LFt4wtdvm+r//gwA8r6fLmg/ltmSdPs/Tu/5GTmk7dnm257KlbWffUR8Vuo9P4+1j16GQyT6TQd8EEon7fjCU9s0CfyG+WEPHBLxdcD+DE9gP5P0BUBmmxJ1nUfwzYbAR1bUWbJway6tHJBfqsf/5TrDkWTK4u3Lz6PfZ9s4TcjOwLvr7/teL+SWQkJhe5LGrJlvwfE676+CkCu7Qgfv3uC64nIiIilZNv6LmJ9IK6tHCIgh8c9Jz+ogwfPhybzUbnzp2NjiIiBvIMrE7vn8dx1cdP4eFf+HrGGQnJYC04E0vmydPkpKYDYM3JxZZrLbTeWa5V3HBxN5MWc4LcrBwSNu/D/7KGhfo1HtyTPvPG0/LRmy64Xo1WofT5ZTxdJj1cKX7oseVawZb3Grj7eHJq95FCfaw5eZendK3iTmpUArmZebO+X+j1LXA/Nhs9pj/DdbNexv+yRoWWpx45Nwu21WLJf90vtJ6IiIiII3GaI/0iIgA/dX6MrFOphN7cjctfvYc1I0p+6RRXD3faPjeI9c8Xf2kW92reZKecm4U2KyWNKtW8C/Q5tngjB39cjcnVhZ6fP8epiMMk748ucr3ELZH81OVxLGmZtH5iIK1H3My2t2aV4hE7photG9D5zQepWqcmK+6fVGSfqz5+iqArWrDvqyX5PxKU5vVd+dA7ZJ1KxbdRHa7+4jl+ueqpIvsFdGyGV1ANEjbuLdV6IiIiIo7AaY70i4gAZJ3Ku8zOkfl/UqNVaInXM7m6cOVHT7Lr4/kk7z1WbL/slDTc/c5dasbdtypZyWcK9jmdjs1qxZpj4eiiDdRoHVrsetZsC5a0vFMDDv+ylhqtS57ZkZ3adYRFN77EsmFv0mnC/UX2WfXoZH7s9Bh1r26HX1jeJXBK8/qe7Xv64HEyT6VSpYiRAX5N6tJhzBBWPvxuqdYTERERcRQq+kXEaZg9q2D655KdgZ1bFBi+fSFd33mU4yt3cGzxpnPbq+qBu69XgX65mdlYsy14BdXAxd1MQIcwTv59qEAfN59z6wR1aUHq4dhi13Pz9jzX94pWpB6OLdVjdkQu7ucGmeWcTic3I7vYPrmZ2VgyssjNyC729S3qdQLyn9sq/r541qqWX8yfVbVuTbq99zirH3uvwLILrSciIiLiSDS8X0Schl+Tulzx9iPkpGVizcll/ahpANTt2Rb3at4cnruWsLuvodFtV+HXuC7XzX6FNU+8T40W9Wlw0xV4hwQQ2r8rp3YdZuMrMwkd0A2zhzt7Pl9U4H42vjKDq6Y9jcnFxK5pv2JJy8SzVjVaPNyPLa9/Q8tHbqRuj7bYrFZObD+Y/0NCUesFX9Oets8NwpKeRU5qBmuf+rDCn7eKFnB5M9o+OwhbrhWTycTGV2cCBV+na75+ERezKy7uZo4sWM+ZqAT82zQs8vUt8nUymbj+p1fJzczGxWxm4yszwGYr8Dp1GDMEjxq+dJvyGAARH8wlZuWOItcTERERcVQq+kXEaZz8+xC/XjeqUHvMiu35tyO/WUrkN0sLLo9P4puGdxVar3qzEHZM+alQ+4ntB/it/5gCbRmJyWx5/RsAtk+azfZJs0u0XvTSLUQv3VL8g3JCcet2snjdzkLt/36d/hj8WqHlxb2+Rb5ONhsLrn++UN9/v07/vWLAWUWtJyIiIuKoVPSLiBRj48szjI4gJaDXSURERKR4OqdfRERERERExEmp6BcRERERERFxUhreLyIOzadBkNERypWzPD49DhERERFjqOgXEYfW68vRRkeQEtDrJCIiImIMDe8XERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESdlNjqAiIiIiDNZds+bpB6JMzoGPg2C6PXlaKNjFMlenqOSsOfnUUSkJFT0i4iIiJSh1CNxJEdGGx3Druk5EhGpOBreLyIiIiIiIuKkVPSLiIiIiIiIOCkV/SIiIiIiIiJOSuf0i4iIQ9p3OJnVW+LYsuckh2NSycmx4unhSvPQanRoWZOrO9YhwN/T6JgiIiKVzsnkTJZtOM6W3SfYsvtkfvvzkzdyZYfadA8PpEWj6gYmrFxU9IuIiMOw2WzMXXaU97/fzcpNsUX2WbQmb3IwN7MLt10XylNDWtKhZa2KjCki5aj3T+M4fTiWP5/9pEC7d3Atbt30MYv6jyFh416D0olUbn9HnuLdr3Yya/EhsrJzCy3/7rdDfPfbIQC6tgvk8dubM+j6hri4mCo6aqWiol9ERBxCTHwaD722Nr+ov5Aci5XvFh3k+98O8vSQVox/vD2eHvraExERKWtZ2bmMn7aNN7/4m9xcW4nWWbctnnXb4pn+0z4+H9edBnV9yjll5aVz+kVExO6t3xFP61t+LnHB/282G7zz1U463/0rcSfSyyGdiIhI5XUyOZMrhy3kjek7Slzw/9vyjbG0uXUuKzYeL4d0Air6RUTEzm3amch1Dy8m6XR2kctdXU3UDfSibqAXrq7FDw/8O/IUVz/wGyeSMssrqoiISKWSkprNtQ8tZuPOxGL7lOR7OjUthxse+4PVm4s+dU8ujYp+ERGxWymp2Qx8ahln0i3F9gmq6Un0kjuIXnIHQTXPP3HfnkPJ3Pvyamy20h+JEBHH4VXHn+t/fJUBqybTf8W7NH/gBqMjiTilR8avY9vek+ftU9Lv6cysXG59ZjmJpzLKOmal59BF/44dO+jfvz9+fn74+voyYMAAYmNj8fHx4fbbbzc6noiIXKKn395AdHxamW5zweoovv71QJluU0Tsi82Sy6ZxX/LLVU+xsO+LNLvnevzCgo2OJeJUfl56hFmLD5XpNhOTMnn8f+vLdJviwEX/smXL6Ny5M/v27WPMmDFMmDCB6Oho+vTpw5kzZ2jbtq3REe1SSmo2M36JzP/3I+PX8evKY+TmWg1MJSJS2O6DSXwxN/LCHS/C6Pc2k5Ojzz2xL92mPMZ1s18pctmw2B9peEv3Ck5kn7JPp+PuW7VQu7tfXltuVg4ZCcmcijgMgCU9k5QDx/EKqlGhOcXxzRjfHdvf92P7+36yt9xL4qq7WDOzL8/d2xovz8o9MazVamPU5I3lsu05vx9mY0TxpwtI6TnkX2tiYiKDBw8mPDycpUuX4umZN0xkyJAhhIaGAqjoL8JPSw4z9KXVpGeeGya7cE0UC9dE0bSBHws+uI7G9XwNTCgics7Hc8rvkluxienMW3GUW68LLbf7EJHykXIghgY3dsHk4oLNeu7Hu5rtGmO15JJ6uOA5wd7BtfBvHcqJrfsrOqo4gdVb4hj07HJcXEz4V6tCt3aBvHD/Zdx/cxhXDltIwqnKOU/MH3/GcDAqtdy2//GcPXRsrcvtlhWHPNI/ceJEkpKSmDFjRn7BD+Dn50d4eDigov+/Fq2JYtCzy8nIKvq82H1HUuhx30JiEzWztYgYz2q18c2C8h2C/5WG+Is4pL1fLsajlh9dpzyGf5uG+NQPJHRAV9qNup0Ds1eQffrcvozZy4Menz/Lxle/JOeMzhOW0svOySX+ZAaxiens3J/EJ3P20mXIr9Sq7smbIy/P7zd8cHN2zR1I5uZhxK+8kx/fvRqARiE+pPw5hJF3t8zv2yzUjzMbhvLgLU0r/PGUla9+Ld8f0WYtPkRWdm653kdl4pBF/6xZs+jevTthYWFFLg8MDCQoKIisrCwefPBBGjZsiI+PD2FhYbz//vsVnNZ4VquNkRP/wkbepauKE5OQzttfRlRYLhGR4uw/mkJyatGz9ZeVjTsTNaGfiANKiz7BohtfoopfVXp9OZqblr9DmycGsvOj+awfPT2/n8nsSs/Pn+XwL+s4ukDnCEvZOZ6QzrcLDzCwVwNMJnh1eDsmPnU5H83eQ+tbfqb3o7+zdU/e5HYHo1J59PU/eXPk5bRr7k8Vd1dmT7qahaujmP7TPoMfycU732z9ZSEzK5edB5LK9T4qE4cb3h8XF0dMTAyDBw8utMxqtRIREUG7du0AsFgsBAUF8ccff9CwYUP+/vtvrr/+egIDAxk0aFCJ7s9isRAXF1emj6Girdl2kv3HTpeo72c/7eWRm4PwrOJazqmkKCkJ8fm3ExLiyYr2MDCNiHGWrCt8yR5XV1ORs/7W/ldb7fPMChx3IqPA9YPjT2aw5e+DBPnrfVZe4tPcgMC82wnx+KXlGBuoguTkFH+1iQsJuqIldx34usxyREdHl8m2ytqlPEcASbuPsuyeN8/bp+u7w0nZH82uj+df0n3Zy/N4qc9ZRbOX582SUz6fO7sOJuPn405IkDejhrXh5Q+38OGsPfnLt+05N6P9d4sOck3nOsya2JN12+PxqerGg+PWFsppD89XSZxOyyk0tL+472go2ff0f7+jAZb9uZ9AX/s6fSIzPjn/dmxsLB7Wih1BFBQUhNlc+hLe4Yr+tLS8WZxNpsLXeJw3bx4JCQn5Q/urVq3K+PHj85e3bduWm266ibVr15a46I+LiyMkJOTSgxupVh8IuqVEXU+nWQhreQVkHS/nUFKUBubqjK2ZNxysX78bOWLRL5xSSfn3gjp3FGg6e8mf89n0/YBilwVf+z0x8QVPYbq889WQGXXRMeX8vBp3oPk7mwC4sV8/0g9sNjhRxXjd/1rqul3cHDmJW/ez9skPCrXfsr5w24VERkYyyE73YS7lOSqJgI7NaHzbVZzafZSblkwCYNuk2UT9Ufq/QXt5Hsv7OStr9vK80WQceNQt882eLUWCanri6WHmjz9jztv/8f+tJ+Knmxl6Y2O63bOQ02cK/hgRGRlJSMj5v+PshnsANJ1QoKkk39FQ/Pd0Ud/Rz7/4Bs8/uPCiY5aH6i6evBuQdwnQjh07klTBRX9UVBTBwaW/EonDFf0hISG4urqyatWqAu1Hjx5lxIgRQPHn8+fk5LBmzRqeffbZ8o5pZ0p5FofJIc/6EBGnUviHXce+H5GSyc3MJvWIY48wtAcJG/cys/atRscQJ9ayUXWST2eV+DSxxiG+1Knlhc0Gjev58tffCeWc0AkUcZBXLo7DFf3u7u4MHTqUGTNm0L9/f/r27UtUVBTTp08nMDCQmJiYYov+xx9/HB8fH4YOHVri+wsKCiIqyrGPAv22Lp6H3theor7ubi5s274a36pu5RtKipSy6yibhk0GYMGCX/FrWd/gRCLG+GFpDE+/u7NAW9yJDIKv/b5Q39o1PfOPHFx+xy/Enij6V/e4ItrXrVlCvSCvSw8sRYpMc2PUP6es/rpgAWFVK8fw/vWD3iTtsPGFe1hYGFFzvjA6RpHs5TkqCXt5Hh3pOQP7ed56PbKWyGNpZbrNOgFe3NW3ET8vO8rug8lkZFq47oq6ROwveoSml6eZWW/1ZNbiQ2zfd4oPX+zC+h3xBYbIh4WFsWy5Y9Qcp1KyueyOFQXaivuOhpJ9Txf1HT3+1dEMu/HjSw9chjLjk1nb71UANm7ciEdgtQq9/6CgoItaz+GKfoCpU6fi5ubGvHnzWL58OV26dGHu3Lm89tprHDhwoMgJ/p5++mnWr1/P8uXLcXd3L/F9mc3mixpCYU+GDazDK9P2EX8y47wT+QHc1bcRLZrqElZGqZJ47rylgIBAajn4357Ixbq6iydQsOjPzbUVGvr3X7EnMi7Y56xqPu50ad+kyNPFpGykJAH/FP2BAYEEVzc0ToVxc7OP3Ss3N/vdh7GX56gk7OV5dKTnDOzneTO7XdqBLHc3VwL9PQtdsi/hVAYvvLeJtAwL73y1k1cfDScjM5clf8XgWcXMDd2DefPzvwGY+nxnXF1MPD5hPWkZFq7pVIfvJ/bkiqG/YrHY8nPaw/NVEsHBUDdgAzEJ575vS/IdDaX7nu7ZuTHBwYEXnbM8pLn8a36C2rWpWsffwDQl51ifHv/w9vZm2rRpTJs2rUD7zp07ad26NS4uBYenjxw5kmXLlrF8+XJq1qxZkVHtgpubC+OGh/Pwa+uK7WMyQVVPM6PubVOByUREitaiYXU8qriSmVV+l+tp36KmCn4RETmvK9sHEbfiTiwWKylnstlzKJkPZu3mw1l7SM/Im1zx5Q+2kJiUyRN3tWDyqE4knc5m9Za8URm3XRfK3f0a02XIr6T903/Yy6vZ8cPNTHiiA6Pe3WTYY7sUHVrWJCbhWLlt38XFRNumNcpt+5WNQxb9RUlOTiY6Opq+ffsWaH/iiSdYvnw5K1asoFatWgalM95DtzbjZHIWL04tOIGNyZR3GT/fqm78+v51NAutZkxAEZF/cXNz4dZrG/DNgoPldh+3925YbtsWuRhrR35Y7DKdny5S8e59eQ33vrymRH2nfruLqd/uKtT+wx+H+eGPwwXaTiZnEXztrDLJaJTbezdk3oryK/pv6lGPql463bisOM2MbRERedeX//f5/EePHuX999/nwIEDhIaG4u3tjbe3N3369DEopbFeeOAydv48kOGDmxMSVJUaflVo0agabz11OQcWDqJ7+4s7R0REpDw8Oqh5uW3bz8edO/qo6BcREbkYA69pQECN8rvk7aODmpXbtisjpznSX1TRX79+/RLPqFlZtGxcnQ9fuoIPX7rC6CgiIufV5bIAencNZvG6sr9u8fP3ttERBBE74OrpzvVzxlKtSTDrn/+Uw/MKn4rY/YMn8KkXiMnVhb0zF3Pwh1VFbClPiwf7EnpzN6w5uZyKOMSGMYUnkuv0xv34t2mIydWF7ZNmE7NiO/Vu6ETLh2/EZrWSk5rB6uFTyDlTsZfiEnEk7m6uvPxwO0b8b32Zb7t7eCDXdC77yyxWZk5zpH/48OHYbDY6d+5sdBQRESkDJpOJ6WO74etdtsX55a1q8tyw1mW6TRG5ONYsCyvum8Tu6cVfi3v7O3NYdNNL/Hbzy7R58hZczjOhXdSSLSy84QV+6z8GD38/Aru0KLDcr0ld/JoEs+jGl1h+z0Tajc67rnj0ki381n8Mi29+hZMRh2g4sHvZPEARJzZ8cHOu6lC2I4U9PVz54rUrcXHRnDtlyWmKfhERcT7BQVX58vXzf/mfvUxQ8LXfF3nJn38LqOHBt//rgdmsrz8Re2CzWslITD5vn9R/LlNnzbaAzXbeUZypR85d0s5qsWDLtRZYnhGfRG5WNiZXF9z9vMg6lXfJNGuOJb+P2bMKSfsc49JpIkZycTHx1RtXUTfg/Je+Lc339Gdju9O4nm9ZxhRU9IuIiJ0bcHUDvnuzB2bXogv/s5cJiolPJze3+GIgqKYnSz/tQ5P6fuUVVUTKUavHBnBk4V/YLBe+qkdAx2Z4BdUgYePeAu3Zp9M5cyyBgevep/dP44h4f27+ssaDenDTsncI7NSclAMxZZ5fxBnVq+3N8s9uICSoarF9SvI97eJi4ovXunNn30blFbVSU9EvIiJ2b3Dvhqz9sh/NQi+uYO97ZQibv+9P6zBd/kfEEYX274p/61C2TbzwjOd+TerSYcwQVj78bqFlda66DM+AavzU5XHmXvUUHcffh8k1b3f4wJyVzO/1DIfnr6PVozeV+WMQcVZhDfzY/H1/brmmwUWt3yjEh5Wf38C9A8LKNpjkU9EvIiIOoVObALbNGcAbI9pfcCjhWe2a+fPdmz349f1rqRtY/FEIEbFfdXpcRpM7rmbNE+/nXWf4H1Xr1izUt2rdmnR773FWP/Ze/tD9AkyQlXwGbDZyzmTg6m7GxeyKi/u5eQKyU9LJzcwul8ci4qwC/D354Z2r+endXnRqXbLLpAfV9GTsI+3Y8cPNuopYOXOa2ftFRMT5eVQx8+KDbRl1bxsWrYli9ZY4/tyRwPodCQDUq12VNk1q0L5FTfp0C6Zj61qYTJoMSMSe9fjsWfxbhWJJz6RmeBM2jZ1J3Z5tca/mzeG5a+n+3uOkxydx3fcvA7DqkclkJqVy9YxR/HrdqALb6jBmCB41fOk25TEAIj6YS8yK7XR8bRjb3/2R2NURNBzQjT6/jMe1iht7Pv+N3KwcWj5yEyHXtgcg+3Qaa0d+WLFPgogTMJlMDLymAQOvacDW3SdYuCaKLbtPsPNAEmkZFtzMLjSo4037FjXpHh5Ev6tCcHdzNTp2paCiX0REHI7Z7MJNPetzU8/6RMelEXJd3pDfdV/eSPB5zisUEfuz8oG3C7XFrNief3v2ZQ8WWh5weVP2f7+8UPuqRycXeR8bX5mZf7uogn7XJ/PZ9cn8EqQVkZIIb1GT8BaFR+OIMVT0i4iIiIhDSdi0j4RN+4yOISLiEHROv4iIiIiIiIiTUtEvIiIiIiIi4qQ0vF9ERESkDPk0uLRZqK2WXE4figXAt2FtXMwXN9HVpeYoT/ac7b8cKauISFFU9IuIiIiUoV5fjr6k9dOOn+SH9g8DcP0Pr1K1jn9ZxLIrl/ociYhIyWl4v4iIiIiIiIiTUtEv4qBWrlzJI488kv/vI0eO0Lt37wuut27dOt54440CbZGRkbi5ufHXX38VaE9PT6dLly5Uq1aNWbNm5bfv2rWLbt26ceWVV3L11Vdz6NAhTp06xd13332Jj0pERERERMqSin6RSmbixIkFfiwAGD9+PFdddVWhvlWqVGHu3LmMHDmyQHutWrVYuHAhq1evZtSoUYwfP54aNWrg5+fHzp07yzO+iIiIiIiUgop+kUrk9OnTpKSk4O9/7vzQDRs2EBQURHBwcKH+rq6uBAUVnsAoICAAPz8/ANzc3HB1zZtkqk+fPvz444/llF5EREREREpLRb9IJbJv3z5CQ0MLtL3xxhuMHn1xEyplZGQwduxYnnzySQAaNWpERETEJecUEREREZGyoaJfxEF5enqSmZmZ/+/MzEw8PT3ZuXMnw4YNK3AOfnEWLlxIhw4dChz5LymLxcKdd97Js88+S+vWrUu9voiIiIiIlD8V/SIOqmnTpvz9999kZWUBsHz5csLDw2nVqhXDhg0rcp2wsDAOHTqU/+/t27ezcuVKevfuzZIlS3jqqaeIjY294H3bbDYeeOABrr/+egYMGJDffvDgQVq1anVJj0tERERERMqO2egAInJxqlWrxrPPPkvPnj1xd3cnICCAzz///Lzr+Pn54efnx8mTJ/H39+ell17ipZdeAmDYsGE88sgj1K5dm6FDh/LVV18BcMstt7Bt2zaqVq3Khg0bmDx5Mr///jtz5szhyJEjzJo1i7Zt2zJlyhR+++23QpMEioiIiIiIcVT0iziwO++8kzvvvLNAW3R0ND/++COpqamEh4cTFhZWYPnzzz/PJ598kl/snzVz5sz822cLfoCffvqp0P327t2b9PT0Am2nTp0iJSVFQ/1FREREROyIin4RJxMcHMwHH3xQ7PJu3brRrVu3Mr/fGjVq8M0335T5dkVERERE5OLpnH4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESel2ftFxGndNGIJB6NPGx3jghoF+zL//WuNjiEiUqxl97xJ6pE4o2M4BZ8GQfT6crTRMURKzF7e/3rvXDwV/SLitA5Gn2b3wWSjY4iIOLzUI3EkR0YbHUNEDKD3v+PT8H4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclCbyExERERERkUvWbcpjNB7cEwBrbi4Z8cnErtvJ1gnfkh53yuB0lZeO9IuIiIiIQ+r90ziuePuRQu3ewbUYFvsjAR2bGZBKpHKL+2s3s9s8wI8dHmX1Y1Pwb9WAHp8+Y3SsSk1Fv4iIiIiIiJQJa7aFjMRk0uNOEf/XHvZ9s5SAy5vi5u1pdLRKS0W/iIiIiIiIlDnPwOo06NcZqyUXW67V6DiVls7pFxERERERkTIRdEVL7jrwNSYXF8yeVQDY+fF8LBlZAPSY/gzHV+0g8pulANRoFcqVHz3Jr9c+R25WjmG5nZlDH+nfsWMH/fv3x8/PD19fXwYMGEBsbCw+Pj7cfvvtRscTKTWrJTf/duqxeGw2m4FpRERERERKJ3HrfuZf8xwL+oxm+7s/kLBpH9smfp+/fOPLM2g94maq1PABk4kubz7Ihhc/V8Ffjhy26F+2bBmdO3dm3759jBkzhgkTJhAdHU2fPn04c+YMbdu2NTqiSIlZMrLY9vZslt/zv/y21Y9M5tfrR3Ho5zUGJnNefboFs23OADI3D+Pwb4N4akgroyOJiIhIBdK+QPnIzcwm9Ugcyfui2D5pNqlRCXR64/785elxp9g1bQEdXh5C0yHXknIolti1EQYmdn4OObw/MTGRwYMHEx4eztKlS/H0zJsUYsiQIYSGhgKo6BeHkZOeyZLbx5OwaV+hZad2Hmb1Y+9xas9ROrx0twHpnFP7FjWZ9961vP1lBHc8v4JOrQP45OUrSM+0MO2HvUbHExGREso+nY67b9VC7e5+eW06cijF0b5Axdn+9mxuXv0e+75ewskdBwHYO2MxfRdOoHbXVvzaZ7TBCZ2fQx7pnzhxIklJScyYMSO/4Afw8/MjPDwcUNEvjmPjyzOKLPgB+Gd0/84PfuHIgvUVF8rJPT20FZt2JfLi1M3sPZzCl/P38/73uxl9Xxujo4mISCmkHIjBv01DTC4Fd2lrtmuM1ZJL6uFYg5KJvdO+QMVJPRxH1JLNhI++41yjzca+r5YQvWwrWSdPGxeuknDIon/WrFl0796dsLCwIpcHBgYSFBQEwPDhwwkJCcHX15e6desycuRIsrOzKzKuSLEyT57m4A8rL9zRBLs/XVDueSqLrm0DWbwuukDb4nXRNKjrQ91AL4NSiYhIae39cjEetfzoOuUx/Ns0xKd+IKEDutJu1O0cmL2C7NPpRkcUO6V9gYq186P51O3RlqAuLc81Wq3YrJq/qiI43PD+uLg4YmJiGDx4cKFlVquViIgI2rVrl9/2+OOPM2nSJKpWrcqJEye47bbbmDBhAq+++mqJ7s9isRAXF1dW8UUKiP75T6w5uRfuaIOETfvYv+lvPGvXKP9gTsKSU/Swztq1PIk7kVGg7ey/a9f0Iia+YncSLTk5REdHX7ijFCn2ROa523GxYPEwMI38W3yaGxCYdzshHr80DbUuicz45PzbsbGxeFgziu9cQXJyLEZHKFJa9AkW3fgS4c/fQa8vR+Pm68WZo/Hs/Gg+uz9baHS8IuXkWC7qM99eX4PiXOzjLGvaF7h0pfnbWzvywyLbEzfvY2btWy85h9HPkdGfz0FBQZjNpS/hHa7oT0tLA8BkMhVaNm/ePBISEgoM7W/RokX+bZvNhouLC/v37y/x/cXFxRESEnLxgUXO48aqzRjo0/LCHf9x3RVXccSSXH6BnE2TceBR1+gUFxQZGUlIyB0X7ihFM1eH5pMA6Hh5R7AkGRxIzvJq3IHm72wC4MZ+/Ug/sNngRI6huosn7wbcAEDHjh1JsoOi/3X/a6nr5mt0jCIl7T7KsnveNDpGiUVGRjLoIvYt7fk1KMrFPs4yp32BS2Yvf3v28Ddl9OdzVFQUwcHBpV7P4Yb3h4SE4OrqyqpVqwq0Hz16lBEjRgCFz+d/88038fb2JiAggB07djBy5MgKSityfhm20h31yrQ51q/89io2MYOgmp4F2gL98/4de0JDQUVERJyd9gWMd2DOSja89LnRMSoFhzvS7+7uztChQ5kxYwb9+/enb9++REVFMX36dAIDA4mJiSlU9I8ePZrRo0ezZ88evv32W2rXrl3i+wsKCiIqKqqMH4VInoyYk6y7eXz+hH3FMoFX/UA2btxd5CgXKVqvR9YSeSytUPu67fFcf0Uw46dtz2/r3TWYIzGpFT6cDyAsLIxly/U5c7FiT2TScWjeD8EbN22kdk0N77cXkWlujPpnntJfFywgrKqG95dEZnwya/u9CsDGjRvxCKxmaB6A9YPeJO2wTncsC2FhYUTN+aLU6znaa3Cxj7OsaV/g0tnL3549/E0Z/fl8dt660nK4oh9g6tSpuLm5MW/ePJYvX06XLl2YO3cur732GgcOHCh2gr/mzZtz2WWXMWTIEFasWFGi+zKbzRc1hEKkRIKDOXZtB6L+uMCQVxu0fqifTjUpJbObW5Htk7/eyZ9f3cjrI9rz9a8H6NSmFiPuaMFTkzZUcMI8Zjc3fc5cCvO5nbnaQbUJDip8+S4xRkoS8E/RHxgQSHB1Q+M4jDSXc0cfa9euTdU6/gamyePm5pC7jHbJze3i9i0d7TW42MdZ1rQvcOns5W/PHv6m7PHzuSTs4xUsJW9vb6ZNm8a0adMKtO/cuZPWrVvj4lL8WQs5OTlERkaWd0SREusy8SFO7T5CWvSJYvvU69ORpkOvq8BUzm3zrhMMGLmUCU+059l7WhN3IoOX3t+i6/KKiIhUEtoXkMrEIYv+oiQnJxMdHU3fvn3z21JSUpg7dy4DBgzAz8+PiIgIXn/9da6//noDk4oU5BVUg74L/seGMZ9zbNFGbFZr/jI3Hy+a39ubts8NxsXV1cCUzmfRmigWrbHPYXQiIiJS/rQvIJWF0xT9ERERQMFJ/EwmE9988w1PP/002dnZBAQEMHDgQMaNG2dQSpGieQVWp+f0Z0mLPcnxVTuwpGXiGVCN4F7tMXtVMTqeiIhIIXcf+pYT2w4AsPuzhRz7bWOB5V3fHY5Pg0DMXh4c+mk1u6cvLNF6/+Z/WSM6vnYvJhcTe774jcNz1xbq0/rxAdTu3gYXsytbJ35Pwsa9hA25liaDe2K15LL97TnEro3AO7gWN/7xFkl7jgGwZcK3JG45/+hP92re3PLn+/z1wmccnreuwLJa7cPo8MpQbLm5RC3Zwq6P55doPRFndb73dt2r29HuucFYc3I5GXEofwK/ts8Oonb3NtgsuWwY8wVJe44akt3ZOXXR7+vry9KlSw1KJFJ6VWv70+T2q42OISIickFpMSdYfMvYYpevf/5TrDkWTK4u3Lz6PfZ9s4TcjOwLrvdvncbfx6pHJ5N5IoW+CyYQ9ftmLOmZ+cvrXt0OV88q/DH4tfw2D39fmtxxNYtufAnXKu5c/8NYFt34EgAnth9gyZ1vlPgxthlxMwmbi/5hoOP4e1lx3yTS405x9Yznifp9E6cPxV5wPRFndb73dttnBrH8/kmkHz/JNd++RPXm9TG5mPBv3ZDf+o/BK6gG3aaO4I9BOjhbHhzukn3FGT58ODabjc6dOxsdRURERMTpeQZWp/fP47jq46fw8C98DW9rTt5lZl2ruJMalUBuZk6J1jvLtYobLu5m0mJOkJuVQ8Lmffhf1rBAnwY3dsHsVYXr5oyl25THMFf1wDskgJTIaGy5VizpmeSkZeLTIBCAGq1C6fPLeLpMehiz5/lH0lWtWxPPwOqc3HGwyOVuVT1IjzsFwIm/DxJ0RcsSrSfirM733k7aewx336qYXFwwe7iTlXIG34a1Ofn3IQDS407hHVwTF3enOSZtV5ym6BcRERGRivNT58dYPHAsx/7YxOWv3lNkn6s+fopb1r9P4qZ9YLOVeD3IGyKfnXLu6hxZKWlUqeZdoI9XUA1sObn8MWgcp3YdodUjN3H6SBw1WjfEXNUDz4Bq+LdqQJVq3qQnJPFTl8f5bcDLnIlKpPWIm8/7+C57+jb+fu+nYpdnJadRrWkIJrMrda5sk5/tQuuJOKvzvbcPz13Ldd+P4eY175FyMIb04ydJ2hdFUNeWmMyuVGsagndwLar4eRezdbkUKvpFREREpNSyTqUCcGT+n9RoFVpkn1WPTubHTo9R9+p2+IUFl3g9gOyUNNz9zl2C0923KlnJZwpmSDpDzIrtAMSs2Eb1FvXJTj7DjnfncM3XL9Dpjfs5tesI6fFJWLMtWNLyTg04/MtaarQu/r6rNasHNhsp+2OK7bP+uU+4fOxQrvlqNGeiEkmPTyrReiLO6nzv7c7/e4AFfUbzc9cRYIN6vS8nJTKaw/P+5Po5r9Dq0ZtI2nuMzJOnjYju9DR+QkRERERKxexZhdysHGxWK4GdW5B6JK5QHxd3M9ZsC7mZ2VgyssjNyC52PXNVD1xcXcg+nZ6/fm5mNtZsC15BNcg8dZqADmFseeObAvcRt34X/pc1yv//6cN559QfXbiBows34FHTj66Th5MWcwI3b09yzmQAEHRFK1L/6etezTvvB4F/zRVQs01D/BrX5drvXsKnQRCWtExSDsRwateR/D7JkdEsufMNTGZXen72LNHLtxHSK/yC6xmp25THaDy4JwDW3Fwy4pOJXbeTrRO+zT9VQeRiXOgzwWa15o/cyTx5mirVfQDY9+Xv7Pvyd/ya1KXNEwMLXMVKyo6KfhEREREpFb8mdbni7UfIScvEmpPL+lHTAKjbsy3u1bw5PHct13z9Ii5mV1zczRxZsJ4zUQn4t2lY5HqhA7ph9nBnz+eLCtzPxldmcNW0pzG5mNg17de8q9vUqkaLh/ux5fVvODB7BV3feZTrf3yV3Kwc1jzxPgDdP3wSr4BqWNKz2PjyDAACO7eg7XODsKRnkZOawdqnPgSg5SM3cmLrfqL+2Jx/vwfmrOTAnJVA3gRkZwv3Gi0bENStFbunLaDlozcR3Cscm9XGrk/mk3XydLHr2ZO4v3az6qF3Mbm64NMgkM4THqDHp8+w6KaXjI4mDqyoz4R/fx5smzQn732anUN2chp/v/8zANfNGYvJBJmnUtnw4mcGPwrnpaJfRERERErl5N+H+PW6UYXazw61BwrMqH+h9ao3C2HHlMLnwZ/YfoDf+o8p0JaRmMyW1/OO+FuzLawZ8X6h9dY89l6htuilW4heuqVQe9WgGuz4V+7/2v7OnPzbp3YdyS/id308v8Bl+s63nj2xZlvISEwG8iZP2/fNUjq/cX+BkRAipVXUe/vfR/uPLljP0QXrC62n2forhop+ERERETHU2aPxRlg78kPD7ttonoHVadCvM1ZLLrZcDasWcVaayE9EREREpJIIuqIldx34mrsPfcvg7dMJ6tKS3dMXYsnIAvKuiHDr5o/zL7nm6unOwHXvU61ZvfMuExH7paJfRERERKSSSNy6n/nXPMeCPqPZ/u4PJGzax7aJ3+cvT487xe5pC7h83DAgb26Co79tIHnvsfMuExH7peH9IiIiInJePg2CjI7gNIx+LnMzs/PPtd4+aTY+DYLo9Mb9/PnsJ/l99nz+G/0WT6T5AzdQ/4ZOzO/1bImW2aNGwb5GRygRe85p9N/sWfaSwxGp6BcRERGR8+r15WijI0g52f72bG5e/R77vl7CyR0HgbzLq20aO5PeP49j+X1v5Q/9v9AyezT//WuNjuDw9P53fBreLyIiIiJSSaUejiNqyWbCR99RoL1ur3akx52iehHn659vmYjYHxX9IiJFmDG+O7a/78f29/1kb7mXxFV3sWZmX567tzVenhokJSIizmPnR/Op26MtQV1aAlCtWT3q9e7Igj6jaXJnL7zrBeT3Pd8yEbFPKvpFRIqxekscQT2/o37v2fR8YBHfLjrI47e3YOvs/gTU8DA6noiISKmsHfkhfwx+rVB74uZ9zKx9K3HrdwHQZeJDbBo7k/S4U2x7axad3rg/v+/5lomIfVLRLyJSjOycXOJPZhCbmM7O/Ul8MmcvXYb8Sq3qnrw58vL8fsMHN2fX3IFkbh5G/Mo7+fHdqwFoFOJDyp9DGHl3y/y+zUL9OLNhKA/e0rTCH4+IiMiFNLnrGjJPpBC9bCsAB39YhVtVD+rd0Om8y0TEfmmMqohIKRxPSOfbhQcYemMT7h+7hrGPtuOZoa0ZPWUTf6yPwdvLjT7dggE4GJXKo6//yRevdWfVljh2H0xm9qSrWbg6iuk/7TP4kYiIiBS2/9ul7P92aYG2xQPHFlhe3DIRsU8q+kVESmnXwWT8fNwJCfJm1LA2vPzhFj6ctSd/+bY9J/Nvf7foINd0rsOsiT1Ztz0en6puPDhurRGxRURERKQS0vB+EZFSMpny/h9U0xNPDzN//Blz3v6P/289ZrOJoTc25s7nV3L6TE4FpBQRERERUdEvIlJqLRtVJ/l0FjabrUT9G4f4UqeWFzYbNK7nW87pRERERETOUdEvIlIKdQK8uKtvI35edpTdB5PJyLRw3RV1i+3v5Wlm1ls9mbX4EM++u5EPX+xCoxCfCkwsIiIiIpWZzukXESmGu5srgf6euLiY8K9WhW7tAnnh/stIOJXBC+9tIi3Dwjtf7eTVR8PJyMxlyV8xeFYxc0P3YN78/G8Apj7fGVcXE49PWE9ahoVrOtXh+4k9uWLor1gsJRspICIiIiJysVT0i4gU48r2QcStuBOLxUrKmWz2HErmg1m7+XDWHtIzLAC8/MEWEpMyeeKuFkwe1Ymk09ms3hIHwG3XhXJ3v8Z0GfIraf/0H/byanb8cDMTnujAqHc3GfbYRERERKRyUNEvIlKEe19ew70vrylR36nf7mLqt7sKtf/wx2F++ONwgbaTyVkEXzurTDKKiIiIiFyIzukXERERERERcVIq+kVERERERESclIp+ERERERERESelc/od1E0jlnAw+rTRMWgU7Mv89681OoaIiIg4sKc2QEy60Sny1PWCyZ2MTiHlxV7+1vR3JhVJRb+DOhh9mt0Hk42OISIiInLJYtLhUKrRKaQy0N+aVEYa3i8iIiIiIiLipFT0i4iIiIiIiDgpFf0iIiIiIiIiTkpFv4iIiIiIiIiTUtEvIiIiIiIi4qRU9IuIiIiIiIg4KRX9IiIiIiIiIk5KRb+IiIiIiIiIk1LRLyIiIiIiIuKkHLro37FjB/3798fPzw9fX18GDBhAbGwsPj4+3H777UbHExEREREDRTzYwOgIIiKGMxsd4GItW7aMfv36Ub9+fcaMGYOnpyczZ86kT58+nDlzhrZt2xod0e7NGN+d4MCqXPvQYqOjiFSo7u2DeGZoK9o29ad+HW/GvL+FN6ZvNzqWiIiI2ClrVgaxP04gac0ssk9G4+LuSZWgRvj3GELAjU8YHc8uWW2wPgEWRsOJTPBwhSsCoF8IeLsZna5ycciiPzExkcGDBxMeHs7SpUvx9PQEYMiQIYSGhgKo6BeRYnl7mtl9MJnvFh1kyqjORscREZEyFvXZU6TuXEHOqePsHtkWjzpNaThqttGxxIEd++RRUiNWEPLAe3iGXkZu+mnSD20jO/GY0dHs0vF0GLkBDqXm/dsE2IA/E+CDPTC2LVxb18CAlYxDFv0TJ04kKSmJGTNm5Bf8AH5+foSHh7Ns2TIV/SJSrN/WRvPb2mgAJo683OA0IiJSUlv6m8673D2gPq2nHyHkgclA3vD+FlO2V0AycXbJG36hzl2vU63zgPw2r9DLjAtkx5Ky4OF1EJtxrs32r+VZufDiFnB3hauCKjxepeSQRf+sWbPo3r07YWFhRS4PDAwkKKjgX1BGRgatW7cmLi6OM2fOVERMERERESlDbWbG5t8+s/dPDr15C80nb8Wteu28RhdXg5KJs3OrXpvTWxdT48o7MfvUMDqOXfv2YMGC/79s5B35f2cndA8El/P/lidlwOGK/ri4OGJiYhg8eHChZVarlYiICNq1a1do2SuvvEL9+vWJi4sr1f1ZLJZSr1MRLDk5RkcA8nJER0cbHUOkSPbyPrkQvY8uTeyJzHO342LB4mFgGvm3+DQ3IDDvdkI8fmmO8Z40WmZ8cv7t2NhYPKzn2Xt2Ejk5gcCFT/J1q37uoI7ZO6/wMvvWKtB+6VlyiI6OL7PtlZWcHIvREUolJ8dil99tJf1b+6/6j3/G4XfuZMfQWniGtKRq0874tb8Bv079MZlKX7Xa69/Zpcqxwk+Ha5M3X3zxz4uNvFMAFuxOJNwvq6LiXTKjP5+DgoIwm0tfwjtc0Z+WlgZQ5Jtr3rx5JCQkFBrav2XLFhYvXsw777zDwIEDS3V/cXFxhISEXHTectNkHHgYfyJMZGQkISF3GB1DpGh28j65EL2PLpG5OjSfBEDHyzuCJcngQHKWV+MONH9nEwA39utH+oHNBidyDNVdPHk34AYAOnbsSFIlKPpbvL8Tz3otjY4B/POZfH0ro2MU8rr/tdR18zU6RolFRkYyyA73oS/2b827eVdaTTtIWuRG0vatJ3XXag5OvBW/9n1o9NL8Uhf+9vp3dqmq1GlCq48jS9z/4demEjfn9XJMVLaM/nyOiooiODi41Os53CX7QkJCcHV1ZdWqVQXajx49yogRI4CCk/hZLBYefPBBPvzwQ9zd3SsyqoiIiIiIOAmTqxnv5lcQOOAZGr80jwZPziRl0wLO7FptdDS7YSrlKTal7S8Xx+GO9Lu7uzN06FBmzJhB//796du3L1FRUUyfPp3AwEBiYmIKFP2TJk2iXbt2XHnllaxcubLU9xcUFERUVFTZPYAy0uuRtUQeSzM6BmFhYSxbbn/PjwjYz/vkQvQ+ujSxJzLpODTvh+CNmzZSu6aG99uLyDQ3Ru3Lu/3rggWEVdXw/pLIjE9mbb9XAdi4cSMegdUMzVMRRuwOJCrzwv1KyyOkRanXCQsL43c73PdbP+hN0g7b3ymnxQkLCyNqzhdGxyikLP/WPIKbA2BJSSj1uvb6d3apMnJN3PO3lWybifMN7z/rnRdG0H3SA+UfrIwY/fn833nrSsrhin6AqVOn4ubmxrx581i+fDldunRh7ty5vPbaaxw4cCB/gr8DBw7wySefsG3btou+L7PZfFFDKMqb2c0+Lm5pdnOzy+dHBIp/n1T1NNO4Xt4QSXc3F4JqenJZ0xqcSc/hYFRqRUYE9D66ZOZzP+zUDqpNcFBVA8PIv6UkAf8U/YEBgQRXNzSOw0hzOXdlotq1a1O1jr+BaSqG236gHIr+Jq8sKn0WO/1MdnNzrN12Nzf73Ie+2L+1fS9eRY3ud+DVuANmv1pkxR4g5usXca1aDZ/WPUufw07/zspC32SYe/TC/aq5wy0t/XF3oIP9jvr57FifHv/w9vZm2rRpTJs2rUD7zp07ad26NS4ueWctrF27lvj4+PwfAXJyckhLS6NmzZr8/PPPXHnllRWeXUSM16FlTVZ+0Tf/34/f0YLH72jByk2x9Ly/9DuIIiIi4tz8wvtwavW3HP/+FXLTT2P2C8Cn5ZU0eGIGZt+aRsezK0Mawe8xkGEpeKm+/3ogDIcq+B2ZQxb9RUlOTiY6Opq+fc/tyA8aNIhrrrkm/9/r169n2LBhbN++nVq1ahkR067c+/IaoyOIGGLV5jhMbT43OoaIiIg4iKBbRxN062ijYziEet4wtROM3ABnirnoxINhMDi0YnNVZk5T9EdERAAFJ/Hz8vLCy8sr/9+1atXCZDI57VAaERERERERo7X1h196wfwo+OkIxKTntfcIggebQlM/Q+NVOk5d9P9Xjx49OHPmTAUlEhEREZHy4tO6B+3nnW/wsIgYqVoVGNoY2vvDPf8MML63iQp+IzjcJfuKM3z4cGw2G507dzY6ioiIiIiIiIhdcJqiX0REREREREQKUtEvIiIiIiIi4qRU9IuIiIiIiIg4KRX9IiIiIiIiIk5KRb+IiIiIiIiIk1LRLyIiIiIiIuKkVPSLiIiIiIiIOCkV/SIiIiIiIiJOSkW/iIiIiIiIiJMyGx1ALk6jYF+jIwD2k0OkKI7y9+koOUVEyktdL6MTnGNPWaTs2cvray85pHJQ0e+g5r9/rdERROye3ici9u/IkSOEh4fTpk0b0tLSeP3117n++usL9Dl06BDvvPMOH374IVOmTOG7777Dzc2N8PBw3n///QJ9d+3axcMPP4yLiwtms5nPPvuMhg0b8tlnn1GjRg0GDhxYkQ9PSmhyJ6MTSGWhvzWpjDS8X0RERAzVsWNHVq5cydy5c3nmmWcKLZ80aRKPPPIIAP369WPDhg2sW7eOxMREVq1aVaBvrVq1WLhwIatXr2bUqFGMHz8egKFDh/Lxxx+X/4MRERGxMyr6RURExC4EBweTlpZWqP2vv/6idevWADRu3BiTyQSAm5sbrq6uBfoGBATg5+dXaLm7uzt+fn4cOXKkHB+BiIiI/VHRLyIiInYhIiKCmjVrFmhLTEzML+L/be3atcTExNC1a9cit5WRkcHYsWN58skn89saNWpERERE2YYWERGxczqnX0RERAy1ceNGevTogbu7O5988skF++/Zs4dRo0Yxf/78/KP+/2axWLjzzjt59tln80cIiIiIVFYq+kVERMRQHTt2ZPHixUUuq1mzJsnJyfn/PnbsGPfccw+zZ88uNCoAwGaz8cADD3D99dczYMCAAssOHjyYPzeAiIhIZaHh/SIiImK3TCYTnTt3zh+WP2rUKE6cOMG9995Ljx498n8sGDlyJKdOneL3339nzpw5zJo1ix49ejBy5EgAsrOzSU5OJjQ01KiHIiIiYggd6RcRERHDNGjQoNij/GeNGjUq/5J9s2bNKrLPlClTAOjduzfp6emFln/11Vc8+uijl5xXRETE0ajoFxEREbvWsGFDPvzww0vaxgMPPFBGaURERByLhveLiIiIiIiIOCkV/SIiIiIiIiJOSkW/iIiIiIiIiJNS0S8iIiIiUom4erpzw69vcOfeLwnt37XQ8pDrOtB3wQR6z32NhgO7l2gdEbFfmshPRERERKQSsWZZWHHfJJoOva7wQpOJ9i/dxYI+L5CblU3vn8cRtWQLlrTM4tcREbumI/0iIiIiIpWIzWolIzG5yGUeNXzIPHEaS3omtlwrKQeOUyu8yXnXERH7pqJfREREREQAyDx5Go+avngGVMNc1YPATs2pUs3b6Fgicgk0vN+OLLvnTVKPxBkdo9z4NAii15ejjY4hIiIiduapDRCTbnSKPHW9YHIno1MYa/3zn3Llh09iycgmeV8U6fGnjI4kUiYutd6yWnLzb/9+26u4mF0velsVWRup6LcjqUfiSI6MNjqGiIiISIWKSYdDqUankLPi/9rD77eNw+zlQc/PnyVxy36jI4mUibKst04fii2T7VQEFf0iIiIiIpVMj8+exb9VKJb0TGqGN+H4yu24V/Pm8Ny1dBg7FP/WDbFactn6v++w5liKXGfT2JnGPggRKREV/SIiIiIilczKB94udtnmcV+Veh0RsV+ayE9ERERERETESanoFxEREREREXFSKvpFRERExGHse6kHR95/oFB7VvwRtvQ3cWb3WgNSiYjYL53TX8l0m/IYjQf3BMCam0tGfDKx63aydcK3pMfpciwiIiIiIiLOREf6K6G4v3Yzu80D/NjhUVY/NgX/Vg3o8ekzRscSERERERGRMqaivxKyZlvISEwmPe4U8X/tYd83Swm4vClu3p5GRxMREREREZEypKK/kvMMrE6Dfp2xWnKx5VqNjiMiIiJSJg5PuYcdQwPYNaKV0VFERAzl0EX/jh076N+/P35+fvj6+jJgwABiY2Px8fHh9ttvNzqe3Qq6oiV3Hfiauw99y+Dt0wnq0pLd0xdiycgyOpqIiDiRXNu528fTwWYrvq+ck3okLv+21ZJrYBLHVvOa+2gydrHRMUREDOewE/ktW7aMfv36Ub9+fcaMGYOnpyczZ86kT58+nDlzhrZt2xod0W4lbt3P2ic/wLWKGw1uuoI63duwbeL3RscSEREnkZ0L3xyE7w+da3thC8zcD3c1gj7BYDIZl89eHZ63jp2fzOfk9oP5bQv7vkCzYdfTanh/zJ5VDExnP1y9/MhNTynUnpuWDIDJzQMAn1ZXkRV/pAKTiYgzc/Vwp80TAwnt3xWv2jXIzcwm9Wg8B39czZ7PFxkd77wcsuhPTExk8ODBhIeHs3TpUjw9885FHzJkCKGhoQAq+s8jNzM7/yjC9kmz8WkQRKc37ufPZz8xOJmIiDi6zFwYuQE2nyi8LPI0vLIt7/9PtlDh/29bJ37P31N+gv88J5knU9j+9hyOr/6ba78fg5uXhzEB7YhHcDOS1v2ALTcXk6trfnva/o3g4kqV2o0NTCcizqrLmw8S1LUVG1/+glO7juLm44l/q1Cq1q1pdLQLcsjh/RMnTiQpKYkZM2bkF/wAfn5+hIeHAyr6S2P727NpPLgn/pc1MjqKiIg4uKm7iy74Ac6O7v/mIPweU2GR7N7RRRvyCn449ySd9c+/EzbuZePLMyo0l72q1Wc4luR4jky9l7QDW8iKPcip1d9z/NuXqdnrXsze1YyOKCJOqF7vjuz8aB7HFm/iTFQCSbuPcmDOSnZM/tHoaBfkkEX/rFmz6N69O2FhYUUuDwwMJCgoCIBhw4bh7u6Ot7d3/n+LF+v8rn9LPRxH1JLNhI++w+goIiLiwFJzYN7RC/czAd8dumC3SmPXpwsKHeEvysEfV5F58nT5B7JzVQLq03Tin+SmJXHw9RvZ/WQbYn+cQODNz1HvkY+MjiciTio9IYm6PdvhXs3b6Cil5nDD++Pi4oiJiWHw4MGFllmtViIiImjXrl2B9oceeogPPvjgou7PYrEQFxd34Y5lICfHUiH3U5SdH82n769vENSlJXHrd5XLfeTkWIiOji6XbYtI5RV7IvPc7bhYsGj4s1GWn/Qiy1rjgv1swO5k2Hggjjoexn332YPMuCQSNuwpUV9rtoXt3y4meOAV5Zyq4uXkBAJuJe7vFXoZjcf8Wk5ZcoiOji+XbV8KI/cTL4b2++Ss+DQ3IDDvdkI8fmk5hmW5lPfRn898zJUfjeT2nZ+TvC+axK2RxCzbyrHFmy46S2nfI0FBQZjNpS/hHa7oT0tLA8BUxImA8+bNIyEhoUyH9sfFxRESElJm2zuf1/2vpa6bb7nex9qRHxbZnrh5HzNr31qu9x0ZGcmgCnouRaQSMVeH5pMA6Hh5R7AkGRyo8goc8AzB975d4v5X33gLaXv/LMdE9q++uRqv1uxV4v4TXhzLr0/uLcdExmjx/k4867Us020enHgbZ/asxXL6BH/fF0zQrS8ScMPwC64XGRlJyPX2d5m/ithPLEva75OzvBp3oPk7eYXxjf36kX5gs2FZLuV9lLBpHz91foya7ZoQ0D6MwM4t6DH9WWKWb2PZPW+WensX8x6JiooiODi41PflcEV/SEgIrq6urFq1qkD70aNHGTFiBFD4fP5vv/2W7777jsDAQO6++26ef/75i/qFRERERIqXm5Faqv7WUvZ3Rpm20h11Km3/yqzR8z8YHUFEnIwt10ri5n0kbt7Hrmm/0vCW7lz5wZMEdmlB/PrdRscrlsNVvu7u7gwdOpQZM2bQv39/+vbtS1RUFNOnTycwMJCYmJgCRf8TTzzBW2+9Rc2aNdm6dSt33HEHmZmZjB8/vkT3FxQURFRUVDk9moLWD3qTtMMVcyqBEcLCwoia84XRMUTEycSeyKTj0Lwfgjdu2kjtmhreb5QT2a48tNOG9QInqJuwEeCey89rFuFSyWfwt9lsrB/0P9KPJhSexO+/TPDBsh/wCrb/maJLa8TuQKIyL9yvIoSFhfF7Be37lYaj7Sdqv0/OikxzY9S+vNu/LlhAWFXjhveX9fsoZX/erLQe/n6lXvdi3iNn560rLYcr+gGmTp2Km5sb8+bNY/ny5XTp0oW5c+fy2muvceDAgQIT/J2dzR+gQ4cOjBs3jrFjx5a46DebzRc1hOJiuLk55MtRYm5uFfdcikglYk7Lv1k7qDbBQVUNDFO5BQM9TsLy2PP3s2HijsZm6oXoOwEg7eGb+OuFzy7YL7hXOGGd25Z/IAO47QfspOh3c3Ozy/0VR9tP1H6fnJWSBPxT9AcGBBJc3bgsl/I+6v3zOA7/so4TOw6SeTIF3wa1CX/hTrKSzxD3586LylJR7xHH+vT4h7e3N9OmTWPatGkF2nfu3Enr1q1xcSn+ogQuLi7YbBf6KV1EREQuxqjWsDcFjqcX3+eKALi9YcVlsndhQ67l+Kq/ObZ4Y7F9vOr40+WthyswlYiI/FvM8m00HNidts8Nxt3bk4yTKcT/tYe1T31I1in7Pl3NIYv+oiQnJxMdHU3fvn0LtM+ePZvevXvj6+tLREQE48aN47bbbjMopYiIiHOr6QEzusHbO/OO+Of+63d2LzPcUh+GNwezQ140uHy4uLrS49On2TZpNntnLiYnNSN/mcnFhXq9L6fTG/fjFXThKyOIiEj5iPjgFyI++MXoGBfFaYr+iIgIoPAkfh999BGPPPIIOTk51K5dmyFDhvDCCy8YkLB0vINrceVHI7FaLJhcXflr9HSS9hS8+HHIdR1o88RAcnMsRH69hEM/rwHAv01Dwl+8CxezKwmb9rJt4qxi78f/skZ0fO1eTC4m9nzxG4fnri2wvNm9vQnt3xVMJlKPxrPuqQ+x5Vq54u1HCL6mPVG/b2L9858C4OrpTvf3RlClhg/ZKWmse+pDsk+f51CPiIg4JX8P+F8HSMyEPxMg3QI1qkD3wLzCXwpzcTPT/sW7aDPyFqKXbCEjIRlzVQ/q9mhL1Tr+RsezC1nxRzj8zp2YzG7Yci3Ue/RjvBq0yV+esuU3jn/3CiZXN7wahVPv4bzLNR//biyndyzFZHYj5MGpBdYREakMnOart7ii/7+z/DuKtNiTLOo/Bmw2grq2os0TA1n16ORzHUwm2r90Fwv6vEBuVja9fx5H1JIt5GZmEz76DlbcNwlL+oVPjus0/j5WPTqZzBMp9F0wgajfNxdYL/KbpeydsRiAblNHUOfKNsSs2M72t+dw6Kc1hA7omt+36d3Xkrh1P7s+mU/9vp1oObw/2978vuyeFBERcSi1PKB/PaNTOBY3L4+8H9ulEPeawTR9cy0mFxdO/72cuB8m0PC5cwc2jn//Ko1G/4x7rRD2j+tD+pG/wWol/dBWmk1cR/bJGI5MGUrY+GUGPgoRkYrnNIPrhg8fjs1mo3PnzkZHKRO2XCv8M/eAu48np3YfKbDco4YPmSdOY0nPxJZrJeXAcWqFN6FWhzBy0rO46pOnuG7OWGq1Dyti63lcq7jh4m4mLeYEuVk5JGzeh/9lBU+ytOacuzSQyQSn/5ntMj3uVKHt+TaszckdBwFI3HaA2lfY3zVuRURExDGZXM2Y/pm3yZp+Gs/Qywos96zfity0ZGy5uVizMzBXrU7m8Ui8GrUHwN2/LtkJR7HmZFV4dhERIzlN0e+MarRswA2/vkGnNx4gdk1EgWWZJ0/jUdMXz4BqmKt6ENipOVWqeeMVWJ0azeuz6tHJrB35AVdMKn7SH/dq3mSnnJv1OisljSrVvAv1a/34AG5eOxX3at6kxxcu9s9K2nOMuj3bAhByTXuqVC+8LREREZGLlX5oO3tHdeHYp4/j26ZXgWU1rryT/a9ez67HmuFRtynutULwrNeK1IgV2Cw5ZBzdSVbiUXLPJBmUXkTEGCr67dipXUdYdONLLBv2Jp0m3F9o+frnP+XKD5/kqo+fInlfFOnxp8hKPkPCpr1Y0jJJP34SS3oWbt6eRW4/OyUNd79zl7Zy961KVvKZQv0iPviFud2eIPVIHI0H9Sw27/7vl2Ou6sH1P75K1bo1ixwNICIiInKxvBq2pdlb62n80nyOffp4gWXHPhlOs3c20eqT/YCJ5L9+wbNeC6p3G0zkK9cQ/8vbeNZvjdm3ljHhRUQMoqLfTrm4n5tuIed0OrkZ2YX6xP+1h99vG8eqRyZj9qpC4pb9nNi6H9+GdTC5uuDm44Wbjyc5ZzIwV/XA3derwPq5mdlYsy14BdXAxd1MQIcwTv59qNgc2afTyc0snOMsa46FDS99zu+3vsrpw3EcWfDXxT58ERERkQL+PSzf1csPlyoF92tMLq64Vq0GgNmvFpbUkwAE3DCcphNWETjweTzrtcTk6lphmUVE7IHTTOTnbAIub0bbZwdhy7ViMpnY+OpMAOr2bIt7NW8Oz11Lh7FD8W/dEKsll63/+w5rjoXsHAv7vv6D3j+Pw8VsZvNrXwMQOqAbZg939ny+qMD9bHxlBldNexqTi4ld037FkpaJZ61qtHi4H1te/4bw0XdS87JG4GLizLEE/p7yEwCXPXUrIb0vx7NmNa6b/Qp/3D6eak1D6PzG/VgtuSTtOcrm8V9X6HMmIiIizuvMnnXEfv8quLgCNkLue5eUrYvJTT1FjavupM6d44gcczUublVw9a5O7VvzrtYU+XIvsNkw+9Yk5KEPDH0MIiJGMNlsNtuFu0lF+OWqkSRHRpfLtjuOv5cdU34i6+Tpctl+SVQLC2bAqimG3b+IOKfouDRCrsubwTvqj9sJDqp6gTVExN4MWgGHUo1OkaehD8wp/mxGw5TnfmJ50H6fnLUrCe7Ju7I4X3aHltWNy2JP76OKfI/oSH8lsfHlGUZHEBERERERkQqmc/pFREREREREnJSKfhEREREREREnpeH9dsSnQZDREcqVsz8+ERERuTh1vS7cp6LYUxYRKVv2VI9UZBYV/Xak15ejjY4gIiIiUuEmdzI6gYhUBpW13tLwfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUmajA8jFWXbPm6QeiTM6Bj4Nguj15WijY4iIiIiI2M0+8qXSPraUJRX9Dir1SBzJkdFGxxARERERsRvaRxYpTMP7RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVKayM/JdZvyGI0H9wTAmptLRnwyset2snXCt6THnTI4nYiIiIiI/en90zhOH47lz2c/KdDuHVyLWzd9zKL+Y0jYuNegdCKloyP9lUDcX7uZ3eYBfuzwKKsfm4J/qwb0+PQZo2OJiIiIiIhIOVPRXwlYsy1kJCaTHneK+L/2sO+bpQRc3hQ3b0+jo4mIiIiIiEg5UtFfyXgGVqdBv85YLbnYcq1GxxEREREREZFypHP6K4GgK1py14GvMbm4YPasAsDOj+djycgCwCuoBjcseIMF1z9P5snTuHq603/pOyy/fxLJe48ZGV1ERERExC551fGn+9QReNbyw2a1EfntUvZ8tsjoWCKFOPSR/h07dtC/f3/8/Pzw9fVlwIABxMbG4uPjw+233250PLuRuHU/8695jgV9RrP93R9I2LSPbRO/z1+eHneK3dMWcPm4YQC0fWYQR3/boIJfRERERKQYNksum8Z9yS9XPcXCvi/S7J7r8QsLNjqWSCEOW/QvW7aMzp07s2/fPsaMGcOECROIjo6mT58+nDlzhrZt2xod0W7kZmaTeiSO5H1RbJ80m9SoBDq9cX+BPns+/41qYSE0f+AG6t/QiR3v/GBQWhGRkktLz+G7RQfz//3YhD9ZuPoYuTp9SUQqicDOzbl6xvPcuuljhsX+SJuRtxgdySlkn07H3bdqoXZ3v7y23KwcMhKSORVxGABLeiYpB47jFVSjQnPaM6sN/kqAT/51kYNlx+FMjnGZKiuHHN6fmJjI4MGDCQ8PZ+nSpXh65k1IN2TIEEJDQwFU9J/H9rdnc/Pq99j39RJO7sjbWbZZrWwaO5PeP49j+X1v5Q/9FxGxV4vWRHHn8ytI+dfew/yVx5i/8hhNG/jx6/vX0qS+n4EJRUTKn9nLg+T9URyau4aOr91rdBynkXIghgY3dsHk4oLNeu6H5JrtGmO15JJ6OLZAf+/gWvi3DuXE1v0VHdUuxabD0xth/+mC7V8dhB+OwNh2cE0dQ6JVSg55pH/ixIkkJSUxY8aM/IIfwM/Pj/DwcEBF//mkHo4jaslmwkffUaC9bq92pMedonqzegYlExEpmeUbjtP/iSWcTiv6cMG+Iyn0uG8RMfFpFZxMRKRixSzfxtYJ33Fk/p9Ys3UItazs/XIxHrX86DrlMfzbNMSnfiChA7rSbtTtHJi9guzT6fl9zV4e9Pj8WTa++iU5ZzIMTG0fkrLg4T8LF/xnZebCC5thTVzF5qrMHLLonzVrFt27dycsLKzI5YGBgQQFBeX/e+HChYSHh1O1alWCgoKYNGlSRUW1Wzs/mk/dHm0J6tISgGrN6lGvd0cW9BlNkzt74V0vwOCEIiJFs9lsjHzrL3KtNmy24vsdT0xn4oy/Ky6YiIg4jbToEyy68SWq+FWl15ejuWn5O7R5YiA7P5rP+tHT8/uZzK70/PxZDv+yjqML1huY2H58dwiOpxe//OxX99s7804BkPLncMP74+LiiImJYfDgwYWWWa1WIiIiaNeuXX7bH3/8wUMPPcRXX33FVVddRXp6OseOlXyCOovFQlyc/f0MlZNjKVG/tSM/LLI9cfM+Zta+Nf/fXSY+xKaxM0mPO8W2t2bR6Y37WTbkfyXKER0dXbLQIiJlYNOuJCL2J5Wo7xdz9/HYLbWp6ulwX3ciIgWUdN/PXhi1j1iWz1PS7qMsu+fN8/bp+u5wUvZHs+vj+WV2v+C4+9g5VvjxUG3yji2biu1nA2LSYeGeRNr56rTikgoKCsJsLv0+jcPtBaWl5Q3VNJkK/xHNmzePhISEAkP7X375ZV5++WV69eoFgK+vL61atSrx/cXFxRESEnJpocvB6/7XUtfNt0y21eSua8g8kUL0sq0AHPxhFU3uuJp6N3Ti2KIN5103MjKSQXb4/IiIE/O/FuoU/uG3KGkZuTRrcxVk6mokIuLYynLfryIYtY9Ykc9TQMdmNL7tKk7tPspNS/JGEm+bNJuoPzZf8rYddR+7Sp0mtPo4ssT9Hxo3lbg5r5djIucSFRVFcHDprxDhcEV/SEgIrq6urFq1qkD70aNHGTFiBHDufP60tDQ2bdpEnz59aNasGUlJSXTq1In33nsvf8I/gf3fLmX/t0sLtC0eONagNCIiF1DEj77n7++QZ7KJiIidS9i4t8DIWQGTi2u59peL43BFv7u7O0OHDmXGjBn079+fvn37EhUVxfTp0wkMDCQmJia/6E9KSsJms/HTTz+xePFiAgICGDlyJAMHDmTr1q1Fjhb4r6CgIKKiosr5UZXe+kFvknbY+NMOwsLCiJrzhdExRKQSWbohgXvHbStRX7OriS2bllHDz72cU4mIlC972fcrKaP2ER3teSqOo+5jZ+SauOdvK9k2E+cb3n/WOy+MoPukB8o/mJP497x1peFwRT/A1KlTcXNzY968eSxfvpwuXbowd+5cXnvtNQ4cOJA/wZ+Pjw8ATz75JA0aNABgwoQJ1KpVi6ioKOrVu/As9Waz+aKGUJQ3Nzf7eOnc3Ozz+RER53V3UB1e/mQfMQnp553ID+C260Jp07JhxQQTESlHxe37mb088A3NKwRc3Mx41qpGjZYNyEnLJPWIccWvUfuI9rKPfKkceR+7bzLMPXrhfn5ucEtLf9x1sL/cOeS7wtvbm2nTpjFt2rQC7Tt37qR169a4uOQN5fTz86N+/folOqIvIiKOwWx2Ydzw9tw/dk2xfUwmqOLuyuj7L6vAZCIiFa/mZY3o/fO4/H83v68Pze/rQ9yfu1h8i07XlIp3dyP4PQYyLOdm6i/Kg01RwV9BHLLoL0pycjLR0dH07du3QPsjjzzCe++9x3XXXUetWrV4+eWXad++fYmO8ouIiH267+YwTiRl8vyUTQXaTSaw2cDLw8zcKdfQJqyGQQlFRCpG3PpdOq9c7Ep9b5jaCUZugDOWvEH+/y3+HwiDwZpircI4TdEfEREBUGDmfoBRo0aRlJREeHg4VquVbt268fPPPxuQUEREytKo+9rQp1swH8/Zw7wVxziTnkOgvydDb2rMAwObElTTy+iIIiIilVJbf5jbC+YdgwVRcCITPFyhWyDc2gCaVTM6YeXi9EW/i4sLEydOZOLEiQakMo6rpzvXzxlLtSbBrH/+Uw7PW1dguXe9ALq+OxwXNzPHftvIrk/mUy0smC6THsZmtWGz5LLumY85cyzBoEcgInJhrcNq8NGYrnw0pqvRUURExM6UZN+267vD8WkQiNnLg0M/rWb39IUAXPH2I/g2qkNuZjbrnvmY9OMni7wPk6sL13zzImavKphcXNjx7g/ErNheoI93SADdpj4OVhu52Tmsevhdsk+nE3JdB9o8MZDcHAuRXy/h0M/Fn7bmiKpXgWFN8v4TYzlN0T98+HCGDx9udAy7Yc2ysOK+STQdel2RyzuMGcLW/31H4pZIev88jqML/yLz5GmW3v0/clLTqduzLZc9dSvrnvqogpOLiIiIiFy6kuzbrn/+U6w5FkyuLty8+j32fbOEulddRm5WDotvfgX/Ng1p/9LdrHnsvSLvw2a18dfo6aQejadKdW96zx1fqOhvOvQ6Ir9dyqEfV9PqsQE0uq0He774jfYv3cWCPi+Qm5VN75/HEbVkCzmp6eX1dEglposXOymb1UpGYnKxy/2a1CVxSyQA0Uu3Eti5OZknT+d/0FhzcrHlWisiqoiIiIhImSvJvq01xwKAaxV3UqMSyM3MwbdhHU7uOAjAyb8PEdipWfF3YrORejQegNzMHIq6rEzSvmO4+1YFwN3Pi8yTKXjU8CHzxGks6ZnYcq2kHDhOrXAdEpfyoaK/kjK5nLuiQVZKGlWq++T/29XDnbbPDWL3Z4uMiCYiIiIiUmYutG971cdPccv690nctA9sNpL2HqNOj7YA1O3ZFk9/vxLdT4exQ4u8j7g/d9F06HX0X/4OdXu05djiTWSePI1HTV88A6phrupBYKfmVKnmfdGPUeR8nGZ4v5TOv3+EdPf1IvNECpB3XtKVHz3Jro/nk7z3mEHpREREREQuXUn2bVc9OhlXD3d6/zSOw7/+SczybdQKb0Lvn8ZxavcRTu258EXnWw3vjyUji/3fLi20rMNLd7N1wrdE/bGZ0AFdaf/inWx8ZSbrn/+UKz98EktGNsn7okiPP3XJj1ekKCr6K6mUyGhqtm3Mie0HCO4Vzrqn885v6vrOoxxfuYNjizddYAsiIiIiIvbtQvu2Lu5mrNkWcjOzsWRkkZuRDcD2t+cAULtba3KzcgAwV/XAxdWF7NMFz7tvfPvV1GjZgNXFnPePyUTmqVQAMk+czh9hG//XHn6/bRxmLw96fv4siVv2X/LjFSmKin4n1uOzZ/FvFYolPZOa4U04vnI77tW8OTx3LVsmfEvXdx7FZHYl6vdNnDmWQN2ebWlw0xV4hwQQ2r8rp3YdZuMrM41+GCIiIiIipVbcvm3dnm3z94mv+fpFXMyuuLibObJgPWeiEqhSw4ee05/FasklLeYEG176HIDQAd0we7iz5/NzQ/jNXh5cMelhTmw7QO+fxgGw+JaxeNaqRouH+7Hl9W/4e8qPdHnrYWy5VkxmF/58bhqQdzqAf+uGWC25bP3fd/nzC4iUNZPNVsRsE2L3frlqJMmR0UbHoFpYMANWTTE6hoiIiIhTs5d9v5Iyah+xPJ+njuPvZceUn8g6ebpctv9v2seWsqQj/SIiIiIiIhew8eUZRkcQuSiavV9ERERERETESanoFxEREREREXFSGt7voHwaBBkdAbCfHCIiIiLOzNH2uYzK62jPU3Gc5XGIfdBEfiIiIiIiIiJOSsP7RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREnpaJfRERERERExEmp6BcRERERERFxUir6RURERERERJyUin4RERERERERJ6WiX0RERERERMRJqegXERERERERcVIq+kVERERERESclIp+ERERERERESelol9ERERERETESanoFxEREREREXFSKvpFREREREREnJSKfhEREREREREn9X/KGb22TnduggAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 1, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -50,17 +50,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 2, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -87,17 +87,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJcAAAHECAYAAACEK8sWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACELUlEQVR4nOzdeVxU9f7H8ffAgIBsigoq5I6aO5m5L1mpV0vbtLpXs+WWWZb9MrPFzCxvtmm22qbtapa5ZJZpbmXuC664oYBsyiI7DMzvDwolUGEEzszwej4ePZr5nu855z0zzmHmM+f7PSar1WoVAAAAAAAAYAMXowMAAAAAAADAcVFcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANjMbHQAAAABAxVt99ytKi4wzOoZd8WkcpP6fTTI6RoV4fLMUk2l0ikINvaSZ1xidAoCRKC4BAAAATigtMk4pEdFGx0AlicmUjqUZnQIACjEsDgAAAAAAADajuAQAAAAAAACbMSyumrFarYqJz1TkqTTlWQrk5WFW66b+8vV2NzoaAAAAAABwQBSXqoGCAqt+/TNGHy46pA074pSQlF2iT4tGvvpXzxA9NLyVWjbxr/qQAAAAAADAIVFccnJrt8ZqzLTfdSgy9aL9Dp84q7dO7NNbX+3TTX2v0LvPdFdwUM0qSgkAAAAAABwVcy45qby8Aj32yib1u2/FJQtL/7R07Um1vfV7fbPiaCWlAwAAAAAAzoIzl5xQbl6+bn9ijZauPWnzNlLTcnXXpLVKOpujh++4sgLTAQAAAAAAZ8KZS07owRd/v2hhydXVpIaBXmoY6CVXV9NFt/XI9E1a9Mvxio4IAAAAAACcBMUlJ/PDmkjNW3L4on2C6ngqetWdil51p4LqeF5ymw9O+13xZ7IqKiIAAAAAAHAiDl1c2r17t4YOHSo/Pz/5+vpq2LBhio2NlY+Pj+644w6j41W5jMw8jZn2R4VvNyk1R+Nn/Fnh2wUAOLe8Aml3kvRngnQoVbJajU4EAIDtUtNytXZrrFZtitHRqLNGxwHsisPOubR69WoNGTJEjRo10nPPPSdPT0/NmzdPgwYNUnp6ujp27Gh0xCr39YqjlXaG0cJfjuvV/7taIUHelbJ9AIDzyM6XPjssfXdCSso5197UR/p3M+mmEMl08VHZACpZw2s76aqn75Jfi2BlJSRr/ycrtH/OcqNjoQqkha9VxHP9LtrnqiX8GnC+UwkZenHOLn2x7Igysy1F7f2urq9n/9tR/bs2MDAdYB8csriUmJioESNGKCwsTL/++qs8PQuHdo0cOVJNmjSRpGpZXHpv4YFK23ZBgVUfLjqkaY9cVWn7AAA4vmyL9PCfhWcs/dPxNGnarsKzmJ5sS4EJMEpAh2bqP+8p7f1gqdaNnaW6nVqo24wHlJ+Vq0Of/2J0PFSymq26q/282BLt2VEHdHjav1T3hgcMSGW/jkenqfc9yxUdn1li2W9bY7VuW6w+fbG37h7awoB0gP1wyGFxM2bMUHJysubOnVtUWJIkPz8/hYWFSap+xaXEpCztOljKJ/kKtGpTTKVuHwDg+GbuK72wJEl//w6+8Lj0Y3SVRQLwD20eGKLTu45qx/SvlXo4RkcWrtWBT39Su0eGGR0NVcDFzV1utYKK/WdydVPku/fLp21fBd/7ptER7YbVatWt/7e61MJSUR9J903ZoL2HK/e7GGDvHLK4NH/+fPXq1UuhoaGlLg8MDFRQUJAkyWKx6LHHHlPt2rXl7++v++67T9nZ2VUZt0ps33+m0vex61CS8vIKKn0/AADHdDZXWhZ16X4mSd8cZQ4mwCj1urRSzG87i7XF/LZL3iH15FW/tkGpYBSrJU9HZ9wqFzcPNX1ygUyurkZHshsbd8Rr58GLf8+yWqX8AqveW1B5o0gAR+Bww+Li4uIUExOjESNGlFhWUFCg8PBwderUqaht+vTp+u233xQeHi53d3fddNNNmjhxombPnl2m/VksFsXFxVVY/sry567IEm2urqZSrwZX/7y2+he5Wlzc6Szl55/75J+Tm68/dx5WkwY1Ly8sAMAprT7jpdyCS38xtUo6dFbacjRODT0sl+wPwDZ5eaW/vzzr+SsrMaVYW1ZC8l/Laikz1nnPwMjLsyg62jlOnczLC5TkdtnbOfnBWGWf3KdWr2+Rq5evjVnyFB0df9lZ7M1Hi/aXue8Xy4/omdGNKjENUHWCgoJkNpevXORwxaWMjAxJkqmUiRqWLFmihISEYkPiPv74Y7366qtq2LChJOmFF17Q7bffrpkzZ8q1DFX5uLg4hYSEVEz4ylR3kBR0a7GmoDqeil5150VX2/rNsAsuC77+G8X84xTQ3r2vlXJO2RwTAOC8Aoc9oeB7Xi9z//433qqMgxV/lVMAhV4KuF4N3WwrFjiriIgIDXeEz/ZlcOXbe+V5RZvL2kb8kpk689vnavHir6oR2MTm7URERChkQNvLymKXQh6U/K8uU9f0TItCQhpJYqQHHF9UVJSCg4PLtY7DDYsLCQmRq6ur1q1bV6z9xIkTGjdunKRz8y2lpKQoKiqqWLEpLCxMaWlpioyMrKLEVcRaRb/8WvOrZj8AAIeTn1m+yzLnZ3EZZ8AIWQkp8qzrX6zN46/7f5/BBOeXuv0nRc97UleMnSOfNr2MjmOfCsoxnUpBrigsoTpzuDOX3N3dNWrUKM2dO1dDhw7V4MGDFRUVpY8++kiBgYGKiYkpKialpaVJkvz9/YvW//v238suJSgoSFFRZZhAwmA/b0rQ/dOKj52PO52l4Ou/KdG3fh3PojOWrr7zB8Wezip1m3H/aDe7mnTgwGZ5uDMOGwBQUlKui+7fa1WBLn4ZOJOsCqph0fcbfpILV4wDKs2m4a8o43jJ6R0SthxUg74dtXvmoqK2hv06Kj0qwamHxElSaGioohZ+anSMCjFuf6CibJxKNuvkPh17/Q4FDntCdfqPvuwsoaGh+tkBvjOV1+otiRr9wo4y9b25fyPNXul8zwGqp7/nsC4PhysuSdLs2bPl5uamJUuWaM2aNerWrZsWL16sF198UUeOHCma6NvHx0eSlJqaWvTkpKSkFFt2KWazudyngxlhQK9akooXl/LzrSWGtf1T7OmsS/b5W9sWtdS8KeOIAQClC5bUP0ladYnR01aZdFcLN10RYv9/XwFH5uZW+kf9fR8u1+BlL6vTpDt1bNE61enUQq3vHaStL3xWxQmrnpubY3y2Lwu3w5JsKC5Zzp7WkZdulFeTjqo35DHlJZcsQJp965ZrYm83NzeneV7P95/6DTT1owhFxqTrUtegePLeqxQcHFgluQB75JDFJW9vb82ZM0dz5swp1r537161a9dOLi6Fo/38/f0VEhKiXbt2qWXLlpKknTt3ysfHR40bN67q2JWqYaCXml/hqyMnK2+IQd/O9Stt2wAA5zCxnXQwVYrKuHCfPkHS7Y2rLBKAfziz+6jW3POqwp6+S23H3KSsxBTtmPGNDn3+i9HRUAVSt/2o3Pjjyo0/rvB7G5bap+2Hx1UjsHHVBrNDrq4uWvRGf/W9d4XSMvNKLDeZCq8W9+LDYerWgcISqjeHLC6VJiUlRdHR0Ro8eHCx9vvvv1//+9//1KtXL7m5uemFF17Q6NGjyzSZtyMxmUx68LZWevLNLZW2jwdvb1Vp2wYAOIdaNaS5PaU390k/x0jnXXRUPm6FRaUHWkpmh5v1EXAu0at3KHp12Yb7wLkEXHu3Aq692+gYDiPsyjr6/fMhmvDmFv3yR0yxZY3qe2vyg510782hBqUD7IfTfLQLDw+XpGKTd0vSM888o969e6tNmzZq3ry5WrdurRkzZhiQsPLde3OofGpe/uVIS3ND94Zq1cS/UrYNAHAu/jWkF8OkWV3OtY1rLf10gzS2NYUlAIBjaRdaWz9/MFDrPv1XUds3M/rq6IrhFJaAvzjNx7sLFZfMZrNmz56t5ORkpaam6pNPPpGnp6cBCStfbb8aev2JLpfuWE6eHq5695nuFb5dAIBz83U/d7tzHcnDuU4aBgBUM02DfYtu9+wUJBeuSgEUcZri0tixY2W1WtW1a1ejoxjqv7e21IDupY+d/tvfV5ELvv6bEleEK82rj3dR8yt8L9kPAAAAAABUP05TXEIhk8mkha9fq6vb1rlgn7+vIhcTn6n8/Itf9+CJUW318B2tKzomAAAAAABwEhSXnJCvt7t+/XCQhvQOsXkbrq4mTX+0s157ootMJk73BAAAAAAApaO45KR8vd219O3rNW9ab/n7uF96hfO0D62tLV/dpKfv70BhCQAAAAAAXJTZ6ACoPCaTSXcPbaFbr2+sr348qg8XHdTOg2dkLWUknEcNV13ftaEevqO1ru/WkMnpAAAAAABAmVBcqga8vdz04O2t9ODtrZSWkatf/ojRbU+skSS9/XQ39b4qSK2b+MvNjRPZAAAAAABA+VBcqmZ8arrrmnb1iu4P69dIwUE1DUwEAAAAAAAcGaeqAAAAAAAAwGYUlwAAAAAAAGAzhsUBAAAAgINp6GV0gnPsKQsAY1BcAgAAAAAHM/MaoxMAwDkMiwMAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2MxsdAAAux+q7X1FaZJzRMSqNT+Mg9f9sktExLpuzvE7O8noAABzTTeNW6Wj0WaNjXFSzYF8tfft6o2M4PWf5bGWP+LxnG4pLABxaWmScUiKijY6BS+B1AgDg8h2NPqv9R1OMjgE7wGcr2BuGxQEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAP5h4HdT1f31MSXavYPranTsItXr0sqAVJB4bQAAAAB7RHEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNzEYHqEz/+9//tGPHDm3fvl3Hjx9Xo0aNFBkZaXQsAE7Aq0GAes0eJ8+6frIWWBXx1a868PEKo2NBvDYAAABAVXPq4tIzzzyj2rVrKywsTCkpKUbHAS4qJzVDR79dq+hV22XJypFnXX81va2PQq6/Si5mV6Pj4R+slnxtnfqZksKPy+zloRt/nqFT6/coNSLa6GjVHq8NAAAAULWcurh09OhRNW3aVJLUtm1bpaenG5wIKF3k8j+14dG3lZ+VI5kkySRZrTqxYrN8Ggfpui+ell/zhkbHrDZyz2bK3bdmiXZ3v8K2/Jw8ZSWkKCshRZJkycxW6pFT8gqqTQGjkvHaAABQUq+rgvTEqLbq2DJAjRp467m3t+vlj3YZHQsGaXhtJ1319F3yaxGsrIRk7f9khfbPWW50LDg5p55z6e/CEmDPolfv0NoH31B+dm5hg1WS1Vq0PC0yTitvnaKM2DPGBKyGUo/EKKB9U5lcih8i63RqrgJLvtKOxxZr9w6uq4B2TXR6x+GqjFkt8doAAFCSt6dZ+4+maOLMLYpNzDQ6DgwU0KGZ+s97StG/7dTS6ydo1+sLddWku9Ry1A1GR4OTc+riEmDvrFartkyZV6Kg9E9ZCSna+97SKstV3R38bKU86vqpx6yHFdC+qXwaBarJsB7qNPEOHVnwm3LPnvvQZvbyUN9PJmjLC58pLz3LwNTVA68NAAAl/bQxWs/M3qaFPx9XTm6+0XFgoDYPDNHpXUe1Y/rXSj0coyML1+rApz+p3SPDjI4GJ+fUw+IqgsViUVxcnNExKlTs6exzt+NiJYuHgWmqt6StETp79FSZ+kZ8s1pBo3rL1bNGJadyLHl5lgrfZkb0aa248VmFPXWn+n82SW6+Xko/Ea+97y3V/o9/LOpnMruq3ycTdPyH33Vi+aYKzyEVPr7oaMcfzlVRr5PRr42zvB5VJT7DTVJg4e2EePll5BkbCKhmKuNvpKNz9OO4Jc/+j6OWvDyHfo4vxp6+R13o/V2vSysd/np1sbaY33ap7dih8qpfW5mxSVURz6E5+nGiIgQFBclsLl+5iOLSJcTFxSkkJMToGBXLXEtq/ZokqcvVXSRLssGBqq9BNUM13KddmfrmZ2Sr55VhiracreRUjuWlgOvV0M23wrebvP+EVt/9ykX79HhzrFIPR2vf+5V3VllERISGO8ExqCJfJyNfG2d5PaqKV/POav3GVknSjUOGKPPINoMTAdVLZf2NdGQOfxxvMVXysO95OCMiIhQScqfRMSqHHX2PutD727Oev7ISU4q1ZSUk/7WsFsWlMnD440QFiIqKUnBwcLnWobgEGMhUzv4u5V4DlaVel1ZqfnsfJe0/oZtWFX7I2PnaAkX9wpdno/HaAAAAAFWL4tIlBAUFKSoqyugYFSr2dLa6jFonSdqydYvq12FYnFES1oVrz4RPytTXxd2stXu2yM3Hq5JTOZZNw19RxvGqH7qasOWg5tW/rdL3ExoaqqiFn1b6fipbVb5OlfnaOMvrUVUiMtw08VDh7WXLlyu0pv0P5wCciVF/I+2Zox/H+4/ZqIiTGUbHuKjQ0FCtXuNc35/+Zk/foy70/s5KSJFnXf9ibR5/3f/7DCZcnKMfJypCUFBQudehuHQJZrO53KeD2T3zuT9I9YPqKzio5GW9UTUajKivw699X3igv/B83pKkpjf3UpPWoVUTzIG4uTn3YczNzTmOQc7yOjnL61FVUpMl/VVcCqwXqOBahsYBqh1nOfZWJEc/jpvd3IyOcElmNzeHfo4vyo6+R13o/Z2w5aAa9O2o3TMXFbU17NdR6VEJDIkrI0c/ThiFq8UBBnIxuyrsqTsKC0sXGvFmMslc00Ntxw6tymgAAABwEDU9zerQsrY6tKwtdzcXBdXxVIeWtdUsxMfoaKhi+z5crrqdmqvTpDvl17yBmt3eR63vHaTwd34wOhqcnFP/nPHFF1/oxIkTkqTExETl5ubqpZdekiQ1atRII0eONDIeIElqcWd/5aSka9uLXxRfYJJkldy8PXXd55PkH0r1HAAAACV1blNHaz8dXHT/kTuv1CN3Xqm1W2PV774VBiZDVTuz+6jW3POqwp6+S23H3KSsxBTtmPGNDn3+i9HR4OScurj0ySefaN26dcXaJk+eLEnq06cPxSXYjbYPDVVw/6u0642Filz6hyTJp1GQWt59g5oP7yeP2vzqBAAAgNKt2xYnU/uyzeMJ5xe9eoeiV+8wOgaqGacuLq1du9boCECZ+YcGq82Ym4qKS73fG6+6nZobnMrx/OfYVzq984gkaf/HP+rkT1uKLe/4xHA1v6OfUg9Ha9VdL0sqfO67vfagrAVWWS35+v2J95V+MuGC+wjo0ExdXrxHJheTDnz6k44v3lhsefPhfdXh/25XRsxpSdKqf7+s/OzcUtfzDq6rG395VckHTkqStk//SonbIyrs+bBH3sF11fu98SqwWGRyddWfkz5S8oETxfr0eHOsfBoHyuzloWPfrdf+j36UdOnX93wDv5sqFzezCvIsitu0T7teX1hs+ZX/HawmN/dUQV6+ksKPafNzn5ZpPQAAAADFOXVxCUD1kxFzWitvnXLB5Ye++EVHvl2rbq/8t6gt+8xZ/fqf/ykvLVMN+3VUh8dv0++Pv3fBbVwz7V6te2imsk+navDy6Yr6eZssmdnF+kR8uarE2PbS1pOk07uOFBW6qoOM2DNaMfQ5yWpVUI+2av/oLVr30MxifTY99aEK8iwyubro5vVv6dCXq5SflXvJ1/effrvvNWUlppS6LGrV9qKiVZ/3H1dgtysVv2n/JdcDAAAAUBwTegNwKp6BtTTw+6nq8/7j8gjwLbE8KyFFKih+ab7sM2eVl5YpSSrIy5c1v+CC23et4SYXd7MyYk4rPydPCdsOKaBD0xL9mo/op0FLpqnNQzddcr3abZto0A/T1O21B2X2rGHrQ3cY1vwCyVr4Grj7eCppf2SJPgV5FkmSaw13pUUlKD+78BL2l3p9i+3HalXfj57QDfMnK6BDsxLL0yLPXb63wGIpet0vtR4AAACA4jhzCYBT+a7rw8pJSlOTm3vq6hfu1oZxb5d5XVcPd3V8crg2PfXRBfu4+3srN/XcZWhzUjNUw9+7WJ+TK7fo6KL1Mrm6qN8nTyop/LhSDkeXul7i9gh91+0RWTKy1e7RW9Ru3M3a+er8cjxix1S7TWN1feW/qtmgjn6777VS+/R5/3EFdb9Shz5fVVSMKs/ru/aBN5STlCbfZg107adP6oc+j5far16XVvIKqq2ELQfLtR4AAACAQpy5BMCp5CSlSZIil/6h2m2blHk9k6uLer/3mPa9v1QpB09esF9uaobc/WoW3Xf3ramclPTifc5mylpQoII8i06s2Kza7ZpccL2CXIssGYVD6o7/sFG125U9syNL2hepFTc+q9WjX9E10+8rtc+6h2Zq0TUPq+G1neT319USy/P6/t337NFTyk5KU41SznTya9FQnZ8bqbUPvlmu9QAAAACcQ3EJgNMwe9aQyaXwsBbY9cpiw54upccbD+nU2t06uXLrue3V9JC7r1exfvnZuSrItcgrqLZc3M2q1zlUZ/YcK9bHzefcOkHdrlTa8dgLrufm7Xmub/e2SjseW67H7Ihc3M+dNJt3NlP5WbkX7JOfnStLVo7ys3Iv+PqW9jpJKnpuawT4yrOuf1HR6G81G9ZRz7ce0fqH3yq27FLrAQAAACiOYXEAnIZfi4bq/voY5WVkqyAvX5smzpEkNezXUe7+3jq+eKNC/3Odmt3eR37NG+qGBc9rw6Nvq/aVjdT4pu7yDqmnJkN7KGnfcW15fp6aDOsps4e7Dnyyoth+tjw/V33m/J9MLibtm7NMloxsedb115UPDtH2l75UmzE3qmHfjrIWFOj0rqNFBavS1gu+7ip1fHK4LJk5ykvL0sbH363y562q1bu6lTpOGC5rfoFMJpO2vDBPUvHX6bovnpGL2VUu7mZFLt+k9KgEBbRvWurrW+rrZDJpwHcvKD87Vy5ms7Y8P1eyWou9Tp2fGymP2r7qOethSVL4O4sVs3Z3qesBAAAAuDCKSwCcxpk9x7Tshokl2mN+21V0O+LLXxXx5a/Fl8cn68um/y6xXq1WIdo967sS7ad3HdFPQ58r1paVmKLtL30pSdr12gLtem1BmdaL/nW7on/dfuEH5YTift+rlb/vLdF+/uv0y4gXSyy/0Otb6utktWr5gKdK9D3/dfrnFer+Vtp6AAAAAC6M4hIAXMCWyXONjoAy4HUCAAAAjMWcSwAAAAAAALAZxSUAAAAAAADYjGFxAByaT+MgoyNUKmd5fDwOAAAAwHlRXALg0Pp/NsnoCCgDXicAAADAeTEsDgAAAAAAADajuAQAAAAAAMrlhgXPq+esh42OATtBcQkAAAAAAAA2Y84lAAAAAACqoVajB6rVPQPk0yhIuWmZit98QGvvf123bXlPEV+v1p5Z3xX17f76GPk2qa+Vt05Rz1kPq0Hv9pKk5iP6SZJW3jJFcZv2XXR/t215T0cXrVeN2j5qOqyn8vMs2v3mt4r46ldd/fwoNb21tyxZOQp/e7EOzl1ZtJ5nPX91mXqPGvbrKBd3s07vPKKtL36uM7uPSiaTbtv6ng59vkrhs78vWsfF3awRuz/Wtmlf6PDXqwsf772D1PqegfIOrquMU2d0ZOFvCn/nB1nzCyrsOa2uKC4BAAAAAFDNdJwwXG3G3KjtL3+lU+t2y1zTQ8HXdirTupsnz5V3o0BlxSdry+S5kqSclPQyrdv63kHaNfNbLRv4lJoM66Gu0+9XcP8wndqwR8sHTVLjG7vpmpfuVezve5UaES1JunbuU3J1N+vXUf9T7tlMdRh/q26YP1nf9xinnKQ0Hftug5rd1rtYcemKAVfLtYabIpdtKny8TwxX8zv6acvzc5W0N1J+LRqq26sPyLWGu3a+Or88Tx1KwbA4AAAAAACqEbNnDbUdO1S7Xv9WB+eu1NljsUoKP649b31/6ZUl5aVlqiDXovzsXGUlpigrMUUFeZYyrRu3aZ/2z1mutMg47Xnre+WmZcqaX1DUFv7OD8o9m6n6PdpKkur3bKe6YS207uG3lLDloFIOntSGR99Wfk6eWt09QJJ09Nu18m8RrIAOzYr20+z2vjq5cqvy0jLl6umutg8P1aaJc3Typy1Kj0pQzJqd2jljvlrfO6iczx5Kw5lLAAAAAABUI/4tQ2T2rKFT63ZX+b6T9kWeu2O1KvvMWSUdOFG87XSqPOr4SSrMmp10tugsJkkqyLXo9M7D8m8ZIklKPXJKiTsOq9ltfXRm91F5BPiqYd8OWj16RuE2Qgsfb9+PJ0hWa9F2TC4uMnvWUI0AX+WcOVt5D7oaoLgEAAAAAACKWAuskslUrM3FrWLKBwWW/H/szCprXn6JfiYXU4m2izn67Tp1eOJ2bZ36mZre0kvZSWk6tXb3X9sqHLS19r9v6Oyx2BLr5iaXbUgfLoxhcQAAAAAAVCMpEdGyZOWoQZ8OpS7PPp0qr8Baxdpqt21S7H5BnkUm18ovKaQcipJHbV/5hQYXtbm4m1WnUwslH4oqajv2w0a5+3ipYb+OanZ7Hx37foOsBQVF27Bk5cinUaDSIuNK/Pd3P9iOM5cAAAAAAKhGLJnZ2jdnmTpOuF352bk6tX63XD3cFdw/TOFvL9apDXvU6u4BhfMTRSeq5agb5B1cR0nnTdqddjJB9Xu0kU+jQOWmZSr3bKas/zwrqQLEbgxX4o7D6vPuY/rzmY8LJ/R+/Da51nDToc9+LuqXm5Ku6NU71OnJOxTQrok2PPpOsce75+3FCnv6LskqndqwRy6uLqrVupFqt22i7S9/WeG5qxuKSwAAAAAAVDM7Z8xX9pmzan3fIF099W7lpmYo/s8DkqTwd36Qd3Bd9fngcRVY8nVo3s+KXLZJvk3qF62/74OlqtX6Ct20+nW51fTUylumKG7TvkrJuuaeGeoy9R5d98UzcnE36/SuI/rljmnKSUor1u/IwrXqP+8pnQk/rpSDJ4st2zNzkbLik9X6noG6esooWbJzdfZYrI4s+K1SMlc3FJcAAAAAAKiGDny8Qgc+XlGi3ZKRrQ3j3r7ouuknE7Ty5ufLtb9FXcaWaPu++7gSbYt7PVbsflZCitY9NPOS24/6eavm1b/tgssPf71ah79eXYakKC/mXAIAAAAAAIDNOHMJAAAAAABclnaP3qL2j958weVfNR9ZhWlQ1SguAQAAAACAy3Lo818UufQPo2PAIBSXAAAAAADAZclNSVfueVeTQ/XCnEsAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANjMoYtLu3fv1tChQ+Xn5ydfX18NGzZMsbGx8vHx0R133GF0PAAAAAAAgHJJiYjWqfV7lLD1oCzZuUbHKROz0QFstXr1ag0ZMkSNGjXSc889J09PT82bN0+DBg1Senq6OnbsaHREAAAAAACqVGDX1mrz4E2q3baxvIPraseMb7Rn1ndGx0IZRC77Q+HvLdGZXUeL2mrU8laLf1+nDo/dKjdvTwPTXZxDFpcSExM1YsQIhYWF6ddff5WnZ+ETPHLkSDVp0kSSKC4BAAAAAKods5eHUg5H6djiDery4j1Gx0EZ7X7zW+18bYFkKt6ek5Kuve/8oFNrd2nAoqmq4VfTmICX4JDD4mbMmKHk5GTNnTu3qLAkSX5+fgoLC5NEcQkAAAAAUP3ErNmpHdO/VuTSP1SQm2d0HJRB9OodhYUlSbL+Y+Ff95P2RmrTxDlVmqs8HLK4NH/+fPXq1UuhoaGlLg8MDFRQUJAkaeHCherZs6e8vb3VuHHjKkwJAAAAAABwcfs/+rFM/SKXb1JGzOlKTmMbhxsWFxcXp5iYGI0YMaLEsoKCAoWHh6tTp05FbbVq1dIjjzyi+Ph4zZw5s9z7s1gsiouLu6zM9ib2dPa523GxksXDwDQ4X2pCfNHthIR45UTz2gBwXPEZbpICC28nxMsvg19PgaqUl2cxOoLdycuzKDo62ugYNrPk2f9x1JKX59DP8cXY0/co3t+Vp6qPE7kp6Tq1bnfZOhdYteuLn9ToP/0qNVNQUJDM5vKVixyuuJSRkSFJMplMJZYtWbJECQkJxYbEXX/99ZKkH374wab9xcXFKSQkxKZ17Za5ltT6NUlSl6u7SJZkgwPhb43NtTSlzrWSpCFDblQkrw0AB+bVvLNav7FVknTjkCHKPLLN4ERA9fJSwPVq6OZrdAy7EhERoeGO/Nm+xVTJo6HRKS4qIiJCISF3Gh2jctjR9yje35Wnqo8TQa7e+l/dAWXuP+vlV7Xo6VGVmEiKiopScHBwudZxuGFxISEhcnV11bp164q1nzhxQuPGjZPEfEsAAAAAAMD+ZVnLdxZaltU+z2B0uDOX3N3dNWrUKM2dO1dDhw7V4MGDFRUVpY8++kiBgYGKiYmp0OJSUFCQoqKiKmx79iD2dLa6jCoszm3ZukX16zD0yl6k7juhraMLh28uX75Mfm0aGZwIAGwXkeGmiYcKby9bvlyhNe3zwxDgrDYNf0UZx51reofLFRoaqqiFnxodw2b9x2xUxMkMo2NcVGhoqFavca7vT3+zp+9RvL8rjxHHiS2j39TZ/SdLTuZditdXfKkPmgZVap6/57AuD4crLknS7Nmz5ebmpiVLlmjNmjXq1q2bFi9erBdffFFHjhy54ETftjCbzeU+Hczumc/9QaofVF/BQfZ5KcPqqEbiuXHc9eoFqq6z/dsDUK2kJkv6q7gUWC9QwbUMjQNUO25uDvlRv1K5uTn2Z3uzm5vRES7J7Obm0M/xRdnR96iLvb/NXh7ybVJYHHBxM8uzrr9qt2msvIxspUVSkLoUI44TOQ8O1YZH375kv6AebdWqd+cqSFR+DvkXx9vbW3PmzNGcOcUvw7d37161a9dOLi4ON9oPAAAAAIDLVqdDMw38fmrR/db3DlLrewcp7o99WnnrFAOT4UKa3tZbpzbs0dFv10kmlXoGk2dgLfWc+XCVZysrhywulSYlJUXR0dEaPHhwsfb8/Hzl5eUpLy9PVqtV2dnZMplMqlGjhkFJAQAAAACoHHGb9mle/duMjoFyMJlM6jnrYfk2baD9Hy1XTlLauWUuJoUMuFrXTLtXNRvWMTDlxTlNcSk8PFxSycm8v/jiC91zzz1F9z09PdWoUSNFRkZWYToAAAAAAIDSmVxc1GH8rWr70E06+t16/fHE+5Kkfy3/n+p2am5wuktzmvFjFyoujR49Wlartdh/FJYAAAAAAIC9ca3hpoZ9Oxbd9wp0jEkrnaa4NHbsWFmtVnXt2tXoKAAAAAAAANWG0xSXAAAAAAAAUPUoLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJuZjQ4AAAAAAADKzqdxkNERnBbPrW0oLgEAAAAA4ED6fzbJ6AhAMQyLAwAAAAAAgM0oLgEAAAAAAMBmDIsDAAAAACc2d1ovjR4aKknKyytQanquDh5P0dJ1J/Xu/APKzLIYnBCAo6O4BAAAAABObv32OA2fsEYuLiYF+NdQz06Bevq+Drrv5lD1Hv2jEpKyjY4IwIExLA4AAAAAnFxuXr7iz2QpNjFTew8n64OFB9Vt5DLVreWpV8ZfXdRv7IjW2rf4FmVvG634tXdp0ZvXSpKahfgo9Y+RGv+fNkV9WzXxU/rmUfrvrS2r/PEAsC8UlwAAAACgGjqVkKmvfjyiW/o3lskkvTC2k2Y8frXeW3BA7W79XgMf+lk7DpyRJB2NStNDL/2hV8ZfrU6tA1TD3VULXrtWP66P0kffHTL4kQAwGsPiAAAAAKCa2nc0RX4+7goJ8tbE0e01+d3tenf+gaLlO/8qLknS1yuO6rquDTR/Rj/9vitePjXd9N+pG42IDcDOcOYSAAAAAFRTJlPh/4PqeMrTw6xf/oi5aP9H/rdJZrNJo25srrueWquz6XlVkBKAvaO4BAAAAADVVJtmtZRyNkdWq7VM/ZuH+KpBXS9ZrVLzK3wrOR0AR0FxCQAAAACqoQb1vPTvwc30/eoT2n80RVnZFt3QveEF+3t5mjX/1X6av/KYJry5Re8+003NQnyqMDEAe8WcSwAAAADg5NzdXBUY4CkXF5MC/GuoZ6dAPX1fByUkZenpt7YqI8uiNz7fqxceClNWdr5W/Rkjzxpm/atXsF75ZI8kafZTXeXqYtIj0zcpI8ui665poG9m9FP3UctksZTtzCcAzoniEgAAAAA4ud5XBSnut7tksRQoNT1XB46l6J35+/Xu/APKzLJIkia/s12Jydl69N9XaubEa5R8Nlfrt8dJkm6/oYn+M6S5uo1cpoy/+o+evF67v71Z0x/trIlvbjXssQEwHsUlAAAAAHBi90zeoHsmbyhT39lf7dPsr/aVaP/2l+P69pfjxdrOpOQo+Pr5FZIRgGNjziUAAAAAAADYjOISAAAAAAAAbMawOABAhVl99ytKi4wzOkaV82kcpP6fTTI6BuyEvbwP7Pnfpb08R2Vhz88jAAD2guISAKDCpEXGKSUi2ugYgKF4H1wazxEAAM6FYXEAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGzGnEsAAAAAAJTCarVqS3ii/tyToA074ova739hg65pV09XXRmg/tc0UE0vNwNTAsajuAQAAAAAwHly8/L18XeH9O6CA9p/NKXE8p//iNHPf8RIkvx83DX6phZ6fGQbNWrgU8VJAfvAsDgAAAA4jIHfTVX318eUaPcOrqvRsYtUr0srA1IBcCbb95/WVSOW6OHpm0otLP1Talqu3vpqn9rc/L3eX3BABQXWyg8J2BmKSwAAAAAASPpsyWFd8++l2nskudzrZmRZNPblP3T7E2uUk5tfCekA+0VxCQAAAABQ7X2+9LBGT16v/PzSzzxydTWpYaCXGgZ6ydXVdMHtfL86Urc/sUZ5eQWVFRWwOxSXAAAAAADVWnhEku5/YeNF+wTV8VT0qjsVvepOBdXxvGjfZetOavrHuyowIWDfmNAbAAAATsWrQYB6zR4nz7p+shZYFfHVrzrw8QqjYwGwU3l5BRo9eb3yLBV7ptFLH+3S0H6N1LFVQIVuF7BHDn3m0u7duzV06FD5+fnJ19dXw4YNU2xsrHx8fHTHHXcYHc8upablau4PEUX3x0z7XcvWnlR+PqdsAgAA52C15Gvr1M/0Q5/H9ePgZ9Tq7gHyCw02OhYAOzV/5VHtOHCmwrdrsVj19FvbKny7gD1y2OLS6tWr1bVrVx06dEjPPfecpk+frujoaA0aNEjp6enq2LGj0RHtznerjqtB/2/0/Hs7itp+3BClmx5dpTY3f68jJ88amA6AMwvs2lrXzn1Kt219X6NjF6n9+FuNjgTYnZ6zHtYNC54vddno2EVqemuvKk5kn3LPZsrdt2aJdne/wrb8nDxlJaQoKfy4JMmSma3UI6fkFVS7SnMCcBzvLThQadv++Y9oHYvmexacn0MWlxITEzVixAiFhYVp586devLJJ/XII49o9erVOnnypCRRXPqHFRuiNHzCGmXlWEpdfigyVX3v/VGxiZlVnAxAdWD28lDK4Shtm/aFMuPLf/UVAPhb6pEYBbRvKpNL8Y+xdTo1V4ElX2nHY4u1ewfXVUC7Jjq943BVxgTgIA6fSNWfexIrbftWq/Tl8qOVtn3AXjhkcWnGjBlKTk7W3Llz5el5biI1Pz8/hYWFSaK4dL6CAqvGz/hTVhUe3C4kJiFTr38WXmW5AFQfMWt2asf0rxW59A8V5OYZHQeAAzv42Up51PVTj1kPK6B9U/k0ClSTYT3UaeIdOrLgN+WePfdDmdnLQ30/maAtL3ymvPQsA1MDsFdb9lZeYakq9wEYzSEn9J4/f7569eql0NDQUpcHBgYqKChIOTk5RWc0JSYmqn79+ho3bpzGjRtX5n1ZLBbFxcVVVHRDbNh5RofLOOTt4+8OaszNQfKs4VrJqVCa1IT4otsJCfHKifYwMA1Qfnl5pZ8d6ezy8iyKjo42Oobdic9wkxRYeDshXn4Z1aOwaC/vA3v+d3k5z1FG9GmtuPFZhT11p/p/Nkluvl5KPxGvve8t1f6PfyzqZzK7qt8nE3T8h991Yvmmy8pqr8/jpdjLv0V74sivpyRZ8uz/OGrJy3Oo53jdlshi911dTRe8Elz989rrX+RqcXGns5Sff+5X/a17ExzqOYHxsuNTim7HxsbKo6BqfyAJCgqS2Vy+cpHDFZfi4uIUExOjESNGlFhWUFCg8PBwderUSVJhYSgoKEi//PKLmjZtqj179mjAgAEKDAzU8OHDy7y/kJCQCn0MVa7uICmobPObnM2wKLRNdynnVCWHQmkam2tpSp1rJUlDhtyoSAvDh+BYXgq4Xg3dfI2OUeUiIiI03NH/VlQCr+ad1fqNrZKkG4cMUeaR6jGp6eW8D4K6t9G/j3xRITns+d/l5R4rkvef0Oq7X7lonx5vjlXq4Wjte3+pzfuR7Pt5vJTqeky+GEd+PSVJLaZKHg2NTnFRERERCgm50+gYZRd8n1SrW9HdoDqeil516fxbvxl24U1e/41i4s+dRZlwJtPxv1OiStVy8dSb9f4lSerSpYuSq7i4FBUVpeDg8l0Iw+GKSxkZGZIkk8lUYtmSJUuUkJBQNCSuZs2amjZtWtHyjh076qabbtLGjRvLXFxyDuUc/WhyyNGSAAA4vMQdh7XxsXdKtN+6qWQbLqxel1ZqfnsfJe0/oZtWvSZJ2vnaAkX9Uj0KnADKo+T3SsfcB2AshysuhYSEyNXVVevWrSvWfuLEiaLhbheabykvL08bNmzQhAkTyry/oKAgRUVF2ZzXHvz0e7weeHlXmfq6u7lo56718q3pVrmhUKrUfSe0dfRMSdLy5cvk16aRwYmA8tk0/BVlHHfsocS2CA0NVdTCT42OYXciMtw08VDh7WXLlyu0pv0P56gIl/M+yM/OVVpkxbyH7PnfZWUfKxK2HNS8+rdVyLbs+Xm8lOp6TL4YR349Jan/mI2KOJlhdIyLCg0N1eo1jvP9afL7BzRv2cmi+3GnsxR8/Tel9q1fx7PojKWr7/xBsadLP5sk7h/t/r41FO7g3ylRtbLjU7RxyAuSpC1btsgj0L9K9x8UFFTudRyuuOTu7q5Ro0Zp7ty5Gjp0qAYPHqyoqCh99NFHCgwMVExMzAWLS4888oh8fHw0atSoMu/PbDaX+3QwezP6lgZ6fs4hxZ/JuuiE3pL078HNdGXLJlUTDCXUSMwuul2vXqDqOvi/PVQ/bm4O92elQri5Of7fisqQmizpr+JSYL1ABdcyNE6VsZf3gT3/u7SX56gs7Pl5vBRHep6riiO/npJkdrP/H4DNbm4O9Rz3vCqjWHEpP99abEjbhcSezipTP0m66sq6DvWcwHgZLufN71W/vmo2CDAwTdk45Pin2bNn64EHHtDmzZv1xBNPaPPmzVq8eLEaNGggLy+vUif6/r//+z9t2rRJP/30k9zd3Q1IbRw3NxdNHRt20cKSySR5e5k18Z72VRcMQLVh9vJQ7TaNVbtNY7m4meVZ11+12zSWT+Py/yoCAABQUTq3qeMU+wCM5pA/Z3h7e2vOnDmaM2dOsfa9e/eqXbt2cnEpXjMbP368Vq9erTVr1qhOner5xn7gtlY6k5KjZ2YXn2vAZJKsVsm3ppuWvX2DWjXxNyYgAKdWp0MzDfx+atH91vcOUut7Bynuj31aeesUA5MBAIDqrH1obbVq4qeDx1MrbR93DGxaadsG7IVDFpdKk5KSoujoaA0ePLhY+6OPPqo1a9bot99+U926dQ1KZx+evr+Dbup7hd5bcEDL1p1URpZF9et66u4bW+ieYaGqU4vL3gOoHHGb9lXY/CeAs9o4/t0LLuP9AwCVw2Qy6aHhrfXYjD8rZftd29dVx1b2P6QJuFxOU1wKDw+XVHwy7xMnTujtt99WjRo11KTJuXmEevXqpZ9++qmqI9qFNs1r6d1nu+vdZ7sbHQUAAFRzrp7uGrBwivxbBGvTUx/q+JLfS/Tp9c6j8rkiUCZXFx2ct1JHv11XypYKXfnfwWpyc08V5OUrKfyYNj9XcuLma16+TwHtm8rk6qJdry1QzG+7dMW/rlGbB2+UtaBAeWlZWj92lvLSq/ayzwCMc+/NoXrzi706cSq9wrf94sNXVfg2AXvk1MWlRo0ayXqpGawBAABgiIIci3679zW1HHXDBfvsemOh0o7HycXdrKFr3tTxH35XQZ6l1L5Rq7Zr/0c/SpL6vP+4ArtdqfhN+4uW+7VoKL8WwVpx47PyrOuv/l8+rZjfdil61XadXLFZktTxyRFqeksvHfr8lwp8pADsmbeXmz6d2kv9/1uxJyD899aWur5bwwrdJmCvHHJC79KMHTtWVqtVXbt2NToKAAAAysBaUKCsxJSL9kk7HidJKsi1SFbrRX84TIuMK7pdYLHIml9QbHlWfLLyc3JlcnWRu5+XcpLSCvueV6wye9ZQ8iEuGQ5UN9de00BTxnS6aJ+401kKvv4bBV//jeJOX/zsxrDWAXpjQpeKjAjYNac5cwkAAADOq+3DwxT545+yWvIv2bdel1byCqqthC0Hi7Xnns1U+skE3fL72zJ7umvdQ7OKljUf3ldXPnij8rNzFf7uDxWcHoAjmPJQJ+XmFeh/n+wudXl+vlUx8ZmX3M5VV9bRyvcHyKdm9bpKOao3pzlzCQAAAM6pydAeCmjXRDtnzL9kX78WDdX5uZFa++CbJZY16NNBnvX89V23R7S4z+PqMu1emVwLPw4fWbhWS/s/oeNLf1fbh26q8McAwP6ZTCZNf6yzFrzWz+aLHT1615Va9+m/uFgSqh2KSwAAALBbDfp2UIs7r9WGR9+WzhsSV7NhnRJ9azaso55vPaL1D79VNOStGJOUk5IuWa3KS8+Sq7tZLmZXubifO5k/NzVT+dm5lfJYADiG4QOaat/3t2jcXVfK19utTOsM7BGs9XMH661J3VTTq2zrAM6EYXEAAAAwTN+PJyigbRNZMrNVJ6yFtk6Zp4b9Osrd31vHF29Ur7ceUWZ8sm74ZrIkad2YmcpOTtO1cydq2Q0Ti22r83Mj5VHbVz1nPSxJCn9nsWJ+26UuL47WrjcXKXZ9uJoO66lBP0yTaw03HfjkJ+Xn5KnNmJsUcn3hFZ1yz2Zo4/h3q/ZJAGB36gV4avakbpr+aGd9/2uk/tyToG37Tys2MUv5BVb51nRTh5a1dVXrOrrlusZqfoWv0ZEBQ1FcAgAAgGHW3v96ibaY33YV3V7Q4b8llte7uqUOf7OmRPu6h2aWuo8tz88rul1a4WjfB0u174OlZUgLoLrx9nLTqJtaaNRNLYyOAtg1iksAAABwKAlbDylh6yGjYwAAgL8w5xIAAAAAAABsRnEJAAAAAAAANmNYHAAAQAXyaRx0WesXWPJ19lisJMm3aX25mF0NyVGZ7DnbPzlSVgAAjEJxCQAAoAL1/2zSZa2fceqMvr3qQUnSgG9fUM0GARURy65c7nMEAADsC8PiAAAAAAAAYDOKS4CDWrt2rcaMGVN0PzIyUgMHDrzker///rtefvnlYm0RERFyc3PTn3/+Waw9MzNT3bp1k7+/v+bPn1/Uvm/fPvXs2VO9e/fWtddeq2PHjikpKUn/+c9/LvNRAQAAZ3HDgufVc9bDRscAAFQBiktANTNjxoxiRSlJmjZtmvr06VOib40aNbR48WKNHz++WHvdunX1448/av369Zo4caKmTZum2rVry8/PT3v37q3M+AAAoBpxcWMWDwBwBBytgWrk7NmzSk1NVUDAufk7Nm/erKCgILm6lpww1tXVVUFBJScyrVevXtFtNze3onUHDRqkRYsWqW3btpWQHgAAVLVWoweq1T0D5NMoSLlpmYrffEBr739dt215TxFfr9aeWd8V9e3++hj5NqmvlbdOUc9ZD6tB7/aSpOYj+kmSVt4yRXGb9l10f7dteU9Hv1uvGv7eanxTD6VFxunMnqMK7h+mpddNUO7ZTElSjzfHqt7VLbVswFPyrOevG395VbteX6j9Hy6XJPm1aKghK2do65R5ivjy18p4agAA56G4BFQjhw4dUpMmTYq1vfzyy5o7d66eeOKJcm8vKytLU6ZM0fvvvy9JatasmebOnVshWQEAgLE6ThiuNmNu1PaXv9Kpdbtlrumh4Gs7lWndzZPnyrtRoLLik7VlcuFng5yU9DKt2/q+f2n/nOVaceMzMpldlX4iXvW6tFb31x/S2gfeUJObe6rpLb3045BnZMnMVlpknP6c9JF6vDlWcZv2KTUiWn0++D9F/7qDwhIAVBGKS4CD8vT0VHZ2dtH97OxseXp6au/evXr99dc1cOBA3XHHHRfdxo8//qjOnTsXO5OprCwWi+666y5NmDBB7dq1K/f6AADAfpk9a6jt2KHa+eoCHZy7sqg9Kfx4mdbPS8tUQa5F+dm5ykpMKde+T+86ql1vLCzWtm7MmxqycobCnrlLrUYP1LaXvlDS3nNZjn2/QfV7tVOf9x9XwtaDcvP20B8TPijXfgEAtmPOJcBBtWzZUnv27FFOTo4kac2aNQoLC1Pbtm01evToUtcJDQ3VsWPHiu7v2rVLa9eu1cCBA7Vq1So9/vjjio2NveS+rVar7r//fg0YMEDDhg0raj969ChD4gAAcAL+LUNk9qyhU+t2V/m+T+86XKIt9XCMtk39XO3H3aKELQd14OMVJfpsfuYTuZhd1ez2Plo/9i3lpWVWRVwAgDhzCXBY/v7+mjBhgvr16yd3d3fVq1dPn3zyyUXX8fPzk5+fn86cOaOAgAA9++yzevbZZyVJo0eP1pgxY1S/fn2NGjVKn3/+uSTp1ltv1c6dO1WzZk1t3rxZM2fO1M8//6yFCxcqMjJS8+fPV8eOHTVr1iz99NNPJSYLBwAAzsdaYJVMpmJtFTX5tiUzp9T2oG5tVGDJV80GAXKt4ab8nLxiy32aBMkrsJZkLbyduD2iQvIAAC6N4hLgwO666y7dddddxdqio6O1aNEipaWlKSwsTKGhocWWP/XUU/rggw+Kikp/mzdvXtHtvwtLkvTdd9/pnwYOHKjMzOK/BiYlJSk1NZUhcgAAOIGUiGhZsnLUoE8HJR84UWJ59unUwkLOeWq3baLc8+ZVKsizyORaMQMlWtx5rUIGdNZPNz+vPu89pqunjtafkz4qWm72rKE+Hzyu40t+V9K+SHWdfr8St0UoLTKuQvYPALg4ikuAkwkODtY777xzweU9e/ZUz549K3y/tWvX1pdfflnh2wUAAFXPkpmtfXOWqeOE25WfnatT63fL1cNdwf3DFP72Yp3asEet7h6gkz9tUXp0olqOukHewXWUdF5xKe1kgur3aCOfRoHKTctU7tlMWS355c7i26yBuky7R1uen6vEbYe07qFZGrT4RZ1at1snf9oiSery0r0yubjoz2c+kSUzW/V7tVef98frxxuftWmfAIDyYc4lAAAAACXsnDFfO175Rq3vG6Shv72pG+ZPVkC7ppKk8Hd+UPTqHerzweMa9MM05Z3NVOSyTcXW3/fBUmUnpemm1a/rzn1zFXh1q3JncHE3q8/7jyvmt11FV35L3B6hna8vVPfXH5JXgwA1vrGbmt3aW+semilLZuHFTjaOf0eegbV01dN3XWzzAIAKwplLAAAAAEp14OMVpU6ebcnI1oZxb1903fSTCVp58/Pl2t+iLmOL3S/ItWjZDU+W6Bc++3uFz/5ekhR5alOJwlZOUpq+DXuwXPsGANiOM5cAAAAAAABgM85cAgAAAFDp2j16i9o/evMFl3/VfGQVpgEAVCSKSwAAAAAq3aHPf1Hk0j+MjgEAqAQUlwA4rZvGrdLR6LNGx7ikZsG+Wvr29UbHAIALWn33K1zSvYL4NA5S/88mGR3DELkp6co972pyQFWzp2NZdT4WwDlRXALgtI5Gn9X+oylGxwAAh5cWGaeUiGijYwDAZeFYBlQeJvQGAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGRN6AwAAAABwnp6zHlbzEf0kSQX5+cqKT1Hs73u1Y/pXyoxLMjgdYH84cwkAAAAOaeB3U9X99TEl2r2D62p07CLV69LKgFQAnEXcn/u1oP39WtT5Ia1/eJYC2jZW3w+fMDoWYJcoLgEAAAAA8A8FuRZlJaYoMy5J8X8e0KEvf1W9q1vKzdvT6GiA3aG4BAAAAADARXgG1lLjIV1VYMmXNb/A6DiA3WHOJQAAAAAA/iGoexv9+8gXMrm4yOxZQ5K09/2lsmTlSJL6fvSETq3brYgvf5Uk1W7bRL3fe0zLrn9S+Tl5huUGjODQZy7t3r1bQ4cOlZ+fn3x9fTVs2DDFxsbKx8dHd9xxh9HxgHIrsOQX3U47GS+r1WpgGgAAAKD6StxxWEuve1LLB03Srje/VcLWQ9o545ui5Vsmz1W7cTerRm0fyWRSt1f+q83PfEJhCdWSwxaXVq9era5du+rQoUN67rnnNH36dEVHR2vQoEFKT09Xx44djY4IlJklK0c7X1+gNXf/r6ht/ZiZWjZgoo59v8HAZM5rUM9g7Vw4TNnbRuv4T8P1+Mi2RkcCAACwCZ9rKkd+dq7SIuOUcihKu15boLSoBF3z8n1FyzPjkrRvznJ1njxSLUder9RjsYrdGG5gYsA4DjksLjExUSNGjFBYWJh+/fVXeXoWTqg2cuRINWnSRJIoLsFh5GVma9Ud05Sw9VCJZUl7j2v9w28p6cAJdX72Pwakc05XXVlHS966Xq9/Fq47n/pN17Srpw8md1dmtkVzvj1odDwAQBnlns2Uu2/NEu3ufoVtnD2A6oDPNVVn1+sLdPP6t3Toi1U6s/uoJOng3JUa/ON01e/RVssGTTI4IWAchzxzacaMGUpOTtbcuXOLCkuS5Ofnp7CwMEkUl+A4tkyeW2phSZL016i4ve/8oMjlm6oulJP7v1FttXVfop6ZvU0Hj6fqs6WH9fY3+zXp3vZGRwMAlEPqkRgFtG8qk0vxj7R1OjVXgSVfacdjDUoGVB0+11SdtONxilq1TWGT7jzXaLXq0OerFL16h3LOnDUuHGAwhywuzZ8/X7169VJoaGipywMDAxUUFCRJGjt2rEJCQuTr66uGDRtq/Pjxys3Nrcq4wAVlnzmro9+uvXRHk7T/w+WVnqe66NExUCt/jy7WtvL3aDVu6KOGgV4GpQIAlNfBz1bKo66fesx6WAHtm8qnUaCaDOuhThPv0JEFvyn3bKbREYFKx+eaqrX3vaVq2Lejgrq1OddYUCBrAXOlonpzuGFxcXFxiomJ0YgRI0osKygoUHh4uDp16lTU9sgjj+i1115TzZo1dfr0ad1+++2aPn26XnjhhTLtz2KxKC4urqLiA8VEf/+HCvLyL93RKiVsPaTDW/fIs37tyg/mJCx5pQ+HqF/XU3Gns4q1/X2/fh0vxcRX7ZcRS16eoqOjL93RAeTlWYyOYIi8PIvTvIYVKT7DTVJg4e2EePllMESpLLLjU4pux8bGyqMg68Kdq4i9vrczok9rxY3PKuypO9X/s0ly8/VS+ol47X1vqfZ//KPR8UpVlccLe33djOTox+vSPtvwuabsyvOe2Dj+3VLbE7cd0rz6t1VIFnt9nmA8oz8LBAUFyWwuX7nI4YpLGRkZkiSTyVRi2ZIlS5SQkFBsSNyVV15ZdNtqtcrFxUWHDx8u8/7i4uIUEhJie2DgIm6s2Uq3+LS5dMe/3NC9jyItKZUXyNm0mCp5NDQ6xSVFREQoJOTOS3d0AC8FXK+Gbr5Gx6hyERERGs7fihK8mndW6ze2SpJuHDJEmUe2GZzIMdRy8dSb9f4lSerSpYuS7aC4ZM/v7eT9J7T67leMjlFmVXm8sOfXzSgOf7x2gM829vy5xp7eEw7/bxGVyujPAlFRUQoODi7XOg43LC4kJESurq5at25dsfYTJ05o3LhxkkrOt/TKK6/I29tb9erV0+7duzV+/PgqSgtcXJa1fL/iZ1v5BbIixCZmKaiOZ7G2wIDC+7GnGUIBAAAcB59rjHdk4VptfvYTo2MAhnK4M5fc3d01atQozZ07V0OHDtXgwYMVFRWljz76SIGBgYqJiSlRXJo0aZImTZqkAwcO6KuvvlL9+vXLvL+goCBFRUVV8KMACmXFnNHvN08rmrj7gkySV6NAbdmyv9Sz9lC6/mM2KuJkRon233fFa0D3YE2bs6uobWCPYEXGpFX5qeOSFBoaqtVrnOM4s2n4K8o4Xv2GEoeGhipq4adGx7A7ERlumvjX9QqWLV+u0JoMiyuL7PgUbRzygiRpy5Yt8gj0NzSPVH3f25WhKo8XvG4lOfrxurTPNnyuKTt7ek84+r9FVC6jPwv8PYd1eThccUmSZs+eLTc3Ny1ZskRr1qxRt27dtHjxYr344os6cuTIBSf6bt26tTp06KCRI0fqt99+K9O+zGZzuU8HA8osOFgnr++sqF8uMVTEKrV7YAhDNMvJ7OZWavvML/bqj89v1EvjrtIXy47omvZ1Ne7OK/X4a5urOGEhs5ub0xxn3Nwc8s/KZXNz429FaVKTJf1VXAqsF6jgWobGcRgZLufOQKhfv75qNggwME2h6vrergxVebzgdSvJ0Y/XpX224XNN2dnTe8LR/y2ictnjZ4FLsZ93Vzl4e3trzpw5mjNnTrH2vXv3ql27dnJxufBov7y8PEVERFR2RKDMus14QEn7I5URffqCfa4Y1EUtR91Qhamc27Z9pzVs/K+a/uhVmnB3O8WdztKzb2/XnG8PGh0NAACgXPhcA8AeOGRxqTQpKSmKjo7W4MGDi9pSU1O1ePFiDRs2TH5+fgoPD9dLL72kAQMGGJgUKM4rqLYGL/+fNj/3iU6u2CJrQUHRMjcfL7W+Z6A6PjlCLq6uBqZ0Pis2RGnFBvs8ZRsAAKA8+FwDwGhOU1wKDw+XVHwyb5PJpC+//FL/93//p9zcXNWrV0+33HKLpk6dalBKoHRegbXU76MJyog9o1PrdsuSkS3Pev4K7n+VzF41jI4HAAAAAMAFOXVxydfXV7/++qtBiYDyq1k/QC3uuNboGAAAXNJ/jn2l0zuPSJL2f/yjTv60pdjyHm+OlU/jQJm9PHTsu/Xa/9GPZVrvfAEdmqnLi/fI5GLSgU9/0vHFG0v0affIMNXv1V4uZlftmPGNErYcVOjI69ViRD8VWPK16/WFit0YLu/gurrxl1eVfOCkJGn79K+UuP3iUyW4+3vr1j/e1p9Pf6zjS34vtqzuVaHq/PwoWfPzFbVqu/a9v7RM6wGwfxc7TjW8tpM6PTlCBXn5OhN+rOgqcR0nDFf9Xu1lteRr83OfKvnACUOyA0ZxmuLS2LFjNXbsWKNjAAAAVAsZMae18tYpF1y+6akPVZBnkcnVRTevf0uHvlyl/KzcS653vmum3at1D81U9ulUDV4+XVE/b5MlM7toecNrO8nVs4Z+GfFiUZtHgK9a3HmtVtz4rFxruGvAt1O04sZnJUmndx3RqrteLvNjbD/uZiVsK70A1WXaPfrt3teUGZeka+c+paift+rssdhLrgfA/l3sONXxieFac99ryjx1Rtd99axqtW4kk4tJAe2a6qehz8krqLZ6zh6nX4YzWgbVy4VnvgYAAAAuwDOwlgZ+P1V93n9cHgG+JZYX5FkkSa413JUWlaD87Lwyrfc31xpucnE3KyPmtPJz8pSw7ZACOjQt1qfxjd1k9qqhGxZOUc9ZD8tc00PeIfWUGhEta36BLJnZysvIlk/jQElS7bZNNOiHaer22oMye1582HnNhnXkGVhLZ3YfLXW5W00PZcYlSZJO7zmqoO5tyrQeAPt3seNU8sGTcvetKZOLi8we7spJTZdv0/o6s+eYJCkzLknewXXk4u4053EAZUJxCQAAAOX2XdeHtfKWKTr5y1Zd/cLdpfbp8/7junXT20rcekiyWsu8nlQ4tCw3NaPofk5qhmr4exfr4xVUW9a8fP0yfKqS9kWq7ZibdDYyTrXbNZW5poc86/kroG1j1fD3VmZCsr7r9oh+GjZZ6VGJajfu5os+vg7/d7v2vPXdBZfnpGTIv2WITGZXNejdvijbpdYDYP8udpw6vnijbvjmOd284S2lHo1R5qkzSj4UpaAebWQyu8q/ZYi8g+uqhp/3BbYOOCeKSwAAACi3nKQ0SVLk0j9Uu22TUvuse2imFl3zsBpe20l+ocFlXk+SclMz5O5Xs+i+u29N5aSkF8+QnK6Y33ZJkmJ+26laVzZSbkq6dr+5UNd98bSuefk+Je2LVGZ8sgpyLbJkFA6pO/7DRtVud+F9+7e6QrJalXo45oJ9Nj35ga6eMkrXfT5J6VGJyoxPLtN6AOzfxY5TXf93v5YPmqTve4yTrNIVA69WakS0ji/5QwMWPq+2D92k5IMnlX3mrBHRAcNwrh4AAADKxexZQ/k5ebIWFCiw65VKi4wr0cfF3ayCXIvys3NlycpRflbuBdcz1/SQi6uLcs9mFq2fn52rglyLvIJqKzvprOp1DtX2l78sto+4TfsU0KFZ0f/PHi+c8+jEj5t14sfN8qjjpx4zxyoj5rTcvD2Vl54lSQrq3lZpf/V19/cuLDydN5dTnfZN5de8oa7/+ln5NA6SJSNbqUdilLQvsqhPSkS0Vt31skxmV/X7eIKi1+xUSP+wS64HwL5d6vhmLSgoOqsy+8xZ1ajlI0k69NnPOvTZz/Jr0VDtH71F1oKCKs8OGIniEgAAAMrFr0VDdX99jPIyslWQl69NE+dIkhr26yh3f28dX7xR133xjFzMrnJxNyty+SalRyUooH3TUtdrMqynzB7uOvDJimL72fL8XPWZ838yuZi0b84yWTKy5VnXX1c+OETbX/pSRxb8ph5vPKQBi15Qfk6eNjz6tiSp17uPyauevyyZOdoyea4kKbDrler45HBZMnOUl5aljY+/K0lqM+ZGnd5xWFG/bCva75GFa3Vk4VpJhZP3/l0gqt2msYJ6ttX+OcvV5qGbFNw/TNYCq/Z9sFQ5Z85ecD0AjqO049v5x7adry0sPObk5ik3JUN73v5eknTDwikymaTspDRtfuZjgx8FUPUoLgEAAKBczuw5pmU3TCzR/vcQNUnFruB2qfVqtQrR7lkl5yk6veuIfhr6XLG2rMQUbX+p8AymglyLNox7u8R6Gx5+q0Rb9K/bFf3r9hLtNYNqa/d5uf9p1xsLi24n7YssKhbte3+p9r2/tEzrAXAcpR2nzj976cTyTTqxfFOJ9bg6HKo7iksAAAAw1N9nFxlh4/h3Dds3AADOggm9AQAAAAAAYDPOXAIAAMBF+TQOMjqC0+C5xOVoFuxrdIRLsueM9vT+s6csQEWguAQAAICL6v/ZJKMjAJC09O3rjY7g0DiWAZWHYXEAAAAAAACwGcUlAAAAAAAA2IxhcQBQirnTemn00FBJUl5egVLTc3XweIqWrjupd+cfUGaWxeCEAAAAAGAfKC4BwAWs3x6n4RPWyMXFpAD/GurZKVBP39dB990cqt6jf1RCUrbREQEAAADAcAyLA4ALyM3LV/yZLMUmZmrv4WR9sPCguo1cprq1PPXK+KuL+o0d0Vr7Ft+i7G2jFb/2Li1681pJUrMQH6X+MVLj/9OmqG+rJn5K3zxK/721ZZU/HgAAAACoDBSXAKAcTiVk6qsfj+iW/o1lMkkvjO2kGY9frfcWHFC7W7/XwId+1o4DZyRJR6PS9NBLf+iV8VerU+sA1XB31YLXrtWP66P00XeHDH4kAAAAAFAxGBYHAOW072iK/HzcFRLkrYmj22vyu9v17vwDRct3/lVckqSvVxzVdV0baP6Mfvp9V7x8arrpv1M3GhEbAAAAACoFZy4BQDmZTIX/D6rjKU8Ps375I+ai/R/53yaZzSaNurG57npqrc6m51VBSgAAAACoGhSXAKCc2jSrpZSzObJarWXq3zzEVw3qeslqlZpf4VvJ6QAAAACgalFcAoByaFDPS/8e3Ezfrz6h/UdTlJVt0Q3dG16wv5enWfNf7af5K49pwptb9O4z3dQsxKcKEwMAAABA5WLOJQC4AHc3VwUGeMrFxaQA/xrq2SlQT9/XQQlJWXr6ra3KyLLojc/36oWHwpSVna9Vf8bIs4ZZ/+oVrFc+2SNJmv1UV7m6mPTI9E3KyLLoumsa6JsZ/dR91DJZLGU78wkAAAAA7BnFJQC4gN5XBSnut7tksRQoNT1XB46l6J35+/Xu/APKzLJIkia/s12Jydl69N9XaubEa5R8Nlfrt8dJkm6/oYn+M6S5uo1cpoy/+o+evF67v71Z0x/trIlvbjXssQEAAABARaG4BACluGfyBt0zeUOZ+s7+ap9mf7WvRPu3vxzXt78cL9Z2JiVHwdfPr5CMAAAAAGAPmHMJAAAAAAAANqO4BAAAAAAAAJsxLM5B3TRulY5GnzU6hpoF+2rp29cbHQMAADiwxzdLMZlGpyjU0EuaeY3RKYBL430DwJ5QXHJQR6PPav/RFKNjAAAAXLaYTOlYmtEpAMfC+waAPWFYHAAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAAAAAsBnFJQAAAAAAANiM4hIAAAAAAABsRnEJAAAATin8v42NjgAAQLXg0MWl3bt3a+jQofLz85Ovr6+GDRum2NhY+fj46I477jA6HgAAAADACZzOlj4+JI39Q3rgd+nFXdKeJMlqNToZYB/MRgew1erVqzVkyBA1atRIzz33nDw9PTVv3jwNGjRI6enp6tixo9ER7d7cab0UHFhT1z+w0ugoQJXqdVWQnhjVVh1bBqhRA2899/Z2vfzRLqNjoQLcsOB5Zcae0cbx7xodBYCBoj5+XGl7f1Ne0intH99RHg1aqunEBUbHAuxCQU6WYhdNV/KG+co9Ey0Xd0/VCGqmgL4jVe/GR42OZ3esVunzI9J7B6X8vwpJJkk7zkhLT0pd6kivdJZ83Q2NCRjOIYtLiYmJGjFihMLCwvTrr7/K09NTkjRy5Eg1adJEkiguAbggb0+z9h9N0dcrjmrWxK5GxwEAlNH2oaaLLnev10jtPopUyP0zJRUOi7ty1q4qSAY4jpMfPKS08N8Ucv9b8mzSQfmZZ5V5bKdyE08aHc0ufXVMevtA8bbzT1bacloav1n6oLvk7lql0QC74pDFpRkzZig5OVlz584tKixJkp+fn8LCwrR69WqKSwAu6KeN0fppY7Qkacb4qw1Og39qNXqgWt0zQD6NgpSblqn4zQe09v7XdduW9xTx9WrtmfVdUd/ur4+Rb5P6WnnrFPWc9bAa9G4vSWo+op8kaeUtUxS3ad9F92dydVH7x25Vs9v7qGb9AGUnndXJFZu1+blPVbdzSw36fqrWPvimTv60RZIU1L2Nbpg/Wb+O+p9Ord1dSc8CgNK0nxdbdDv94B869sqtaj1zh9xq1S9sdOGbHXApKZt/UIN/vyT/rsOK2ryadDAukB07myu9d+DS/fYkS7/ESEOuqPxMgL1yyOLS/Pnz1atXL4WGhpa6PDAwUEFBQcXasrKy1K5dO8XFxSk9Pb3M+7JYLIqLi7usvJXBkpdndARJhTmio6ONjgGUyl7eJ5fiTO+jvDzLZa3fccJwtRlzo7a//JVOrdstc00PBV/bqUzrbp48V96NApUVn6wtk+dKknJSLn287/HmWDW8tpO2Tv1MiVsPySPAV3U7t5QkJW47pF1vLFSPNx7SmT3HZMnOVa93HtW+D5cXKyzl5Vmc5jWsSPEZbpICC28nxMsvwzHek0bLjk8puh0bGyuPgizjwlSRvLxASW6X7OdW69znO7N37cL/+9Yt1n75WfIUHR1fYdsz0uUek52RMx2vy/q++Se3WvV1dsdK1e59l8w+tSsoi/O8b863NMFbuQX+Zehp1VcReeroklDZkVBNGP1ZICgoSGZz+cpFDldciouLU0xMjEaMGFFiWUFBgcLDw9WpU8kvIs8//7waNWpU7kJRXFycQkJCbM5baVpMlTwaGp1CERERCgm50+gYQOns5H1yKc70Pnop4Ho1dPO1aV2zZw21HTtUO19doINzz80FlxR+vEzr56VlqiDXovzsXGUlppRpHZ/GQWo+vK9+u/91nfjxT0lS2ol4Je44XNRnz+zFCureVr3ffUx56VnKjEvSjle+KbadiIgIDbfHvxUG82reWa3f2CpJunHIEGUe2WZwIsdQy8VTb9b7lySpS5cuSq4GxaUr394rzyvaGB1D0l/H5AFtjY5RIS7nmOysnOl4bev7ptEjH+v4G3dp96i68gxpo5otu8rvqn/J75qhMpkuPvT0QpzpfXO+xv/3pQL6/LsMPU2KSHdVyBVXMMM3KoTRnwWioqIUHBxcrnUc7mpxGRkZklTqgW/JkiVKSEgoMSRu+/btWrlypZ566qmqiAgAsIF/yxCZPWvo1LqqG2oW0K5wnr6L7tNq1YZxs1Wr1RUK7Npa68bMlNWSX0UJAQCoWN6te6jtnKNqOX2DAq69W3kp8To64zYdffkmWSmMFGMqx1Bbk4urZGNxDnAGDnfmUkhIiFxdXbVu3bpi7SdOnNC4ceMkFZ/M22Kx6L///a/effddFRQUlHt/QUFBioqKuqzMlaH/mI2KOJlhdAyFhoZq9Rr7e34AyX7eJ5fiTO+jTcNfUcbxyhlKbC2wlvjQ5uJWNX/GardtIrNXDclkUs2GdZR+svhp76GhoYpa+GmVZHEkERlumnio8Pay5csVWpNhcWWRHZ+ijUNekCRt2bJFHoH+huapCuP2Byoqu+K36xFyZbnXCQ0N1c92+NnPFpV5THZUznS8vpz3jcnVLO/W3eXdursChz2hM2u/VOTMkUrft14+bfuUe3vO9L453/xYH82PvXQ/k6wKqmFR1IkTlR8K1YLRnwX+Oc1QWThcccnd3V2jRo3S3LlzNXToUA0ePFhRUVH66KOPFBgYqJiYmGLFpddee02dOnVS7969tXbt2nLvz2w2l/t0sKpgdiv/+OrKYHZzs8vnB5Ds531yKc70PnK7jGJPSkS0LFk5atCng5IPlPxwln06VV6BtYq11W7bRLnnzatUkGeRybXsJ+We+WvIXYM+HYqGxf2TZ11/9XzrEe1563u5+3mp99uPasl1E4rt183NPv9WGC01WdJfxaXAeoEKrnXR7vhLhsu5i5XUr19fNRsEGJimargdllQJxaUWz68ofxaOyU7NmY7XFfm+8QhuLUmypNo2Z5AzvW/ONzJAWhgrXeoUBatMuqO5cz4HMIYjfhZwyL84s2fPlpubm5YsWaI1a9aoW7duWrx4sV588UUdOXKkaKLvI0eO6IMPPtDOnTsNTgzAntT0NKv5FYVzULi7uSiojqc6tKyt9Mw8HY1KMzhd9WXJzNa+OcvUccLtys/O1an1u+Xq4a7g/mEKf3uxTm3Yo1Z3D9DJn7YoPTpRLUfdIO/gOko6r8iTdjJB9Xu0kU+jQOWmZSr3bOZFh7ClRcbp6Hfr1fWV/8rVw02J2yLk7u+tele31IGPC7+U9nx7nFKPxGj3zEUyuboosOuV6jlzrNbc82qlPycAAFS0Q8/0Ue1ed8qreWeZ/eoqJ/aIYr54Rq41/eXTrp/R8exKoKd0a2Pp28iL96vvKd3EleJQzTlkccnb21tz5szRnDlzirXv3btX7dq1k4tL4a/WGzduVHx8fFGxKS8vTxkZGapTp46+//579e7du8qzAzBe5zZ1tPbTwUX3H7nzSj1y55VauzVW/e4r/6/cqDg7Z8xX9pmzan3fIF099W7lpmYo/s/CawCHv/ODvIPrqs8Hj6vAkq9D835W5LJN8m1Sv2j9fR8sVa3WV+im1a/LraanVt4yRXGb9l10nxvHv6uO/3e7wp66U56BtZR9+qxO/LhJktT24WGq076pllw3QdaCAlkLCrRuzEzd+POrajV6oA7OW3nRbQMAYG/8wgYpaf1XOvXN88rPPCuzXz35tOmtxo/Oldm3jtHx7M4TbaV0i/TTBS4y2MBLerer5OMYJ8wDlcYhi0ulSUlJUXR0tAYPPveFcfjw4bruuuuK7m/atEmjR4/Wrl27VLduXSNi2pV7Jm8wOgJgiHXb4mRq/4nRMXABBz5eUXTW0PksGdnaMO7ti66bfjJBK29+vlz7s1rytfPV+dr56vwSy/a++4P2vvtDsbazx2L1VYuR5doHAAD2Iui2SQq6bZLRMRyG2UV6sZM07Arp4whp6+nC9ibe0l3NpIENJU+n+VYN2M5p3gbh4eGSik/m7eXlJS8vr6L7devWlclkYiwsAACAg/Np11dXLeHKVgAqn8kkXVVH8nCV7v7r9/kXOkltmEsQKOLUxaV/6tu3r9LT0y+4HADgXNo9eovaP3rzBZd/1ZwzkAAAAIDL5TTFpbFjx2rs2LFGxwAA2JFDn/+iyKV/GB0DAAAAcGpOU1wCAOCfclPSlZvCGasAAABAZXIxOgAAAAAAAAAcF8UlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2o7gEAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmZqMDwDbNgn2NjiDJfnIApXGUf5+OkhMAKktDL6MTnGNPWYCLsad/q/aUBYAxKC45qKVvX290BMDu8T4BAMcw8xqjEwCOh/cNAHvCsDgAAGCYyMhI1a5dW3379tXVV1+tn3/+uUSfY8eO6eGHH5YkzZo1S126dFGPHj00bty4En337dunnj17qnfv3rr22mt17NgxSdLHH3+s77//vnIfDAAAQDVFcQkAABiqS5cuWrt2rRYvXqwnnniixPLXXntNY8aMkSQNGTJEmzdv1u+//67ExEStW7euWN+6devqxx9/1Pr16zVx4kRNmzZNkjRq1Ci9//77lf9gAAAAqiGKSwAAwC4EBwcrIyOjRPuff/6pdu3aSZKaN28uk8kkSXJzc5Orq2uxvvXq1ZOfn1+J5e7u7vLz81NkZGQlPgIAAIDqieISAACwC+Hh4apTp06xtsTExKJi0fk2btyomJgY9ejRo9RtZWVlacqUKXrssceK2po1a6bw8PCKDQ0AAAAm9AYAAMbasmWL+vbtK3d3d33wwQeX7H/gwAFNnDhRS5cuLTqL6XwWi0V33XWXJkyYUHTGEwAAACoPxSUAAGCoLl26aOXKlaUuq1OnjlJSUorunzx5UnfffbcWLFhQ4iwnSbJarbr//vs1YMAADRs2rNiyo0ePFs3dBAAAgIrDsDgAAGC3TCaTunbtWjScbeLEiTp9+rTuuece9e3bt6goNX78eCUlJennn3/WwoULNX/+fPXt21fjx4+XJOXm5iolJUVNmjQx6qEAAAA4Lc5cAgAAhmncuPEFz1r628SJE/XGG2/o3Xff1fz580vtM2vWLEnSwIEDlZmZWWL5559/roceeuiy8wIAAKAkiksAAMCuNW3aVO++++5lbeP++++voDQAAAD4J4bFAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwGcUlAAAAAAAA2IziEgAAAAAAAGxGcQkAAAAAAAA2MxsdAOesvvsVpUXGGR2j0vg0DlL/zyYZHQMAANiZxzdLMZlGpyjU0EuaeY3RKQAAjuxyv9sXWPKLbv98+wtyMbvatJ2q/A5OccmOpEXGKSUi2ugYAAAAVSomUzqWZnQKAAAqRkV+tz97LLZCtlPZGBYHAAAAAAAAm1FcAgAAAAAAgM0oLgEAAAAAAMBmFJcAAAAAAABgM4pLAAAAcBiHnu2ryLfvL9GeEx+p7UNNSt+/0YBUAABUb1wtrprpOethNR/RT5JUkJ+vrPgUxf6+Vzumf6XMuCSD0wEAAAAAAEfDmUvVUNyf+7Wg/f1a1PkhrX94lgLaNlbfD58wOhYAAAAAAHBAFJeqoYJci7ISU5QZl6T4Pw/o0Je/qt7VLeXm7Wl0NAAAAAAA4GAoLlVznoG11HhIVxVY8mXNLzA6DgAAQIU4Putu7R5VT/vGtTU6CgAATs+hi0u7d+/W0KFD5efnJ19fXw0bNkyxsbHy8fHRHXfcYXQ8uxXUvY3+feQL/efYVxqx6yMFdWuj/R/9KEtWjtHRAABOJN967vapTMlqvXBfnJMWGVd0u8CSb2ASx1bnunvVYspKo2MAAFAtOOyE3qtXr9aQIUPUqFEjPffcc/L09NS8efM0aNAgpaenq2PHjkZHtFuJOw5r42PvyLWGmxrf1F0NerXXzhnfGB0LAOAkcvOlL49K3xw71/b0dmneYenfzaRBwZLJZFw+e3V8ye/a+8FSndl1tKjtx8FPq9XoAWo7dqjMnjUMTGc/XL38lJ+ZWqI9PyNFkmRy85Ak+bTto5z4yCpMBgDA5XH1cFf7R29Rk6E95FW/tvKzc5V2Il5HF63XgU9WGB3vohyyuJSYmKgRI0YoLCxMv/76qzw9C+cKGjlypJo0aSJJFJcuIj87t+hX0V2vLZBP4yBd8/J9+mPCBwYnAwA4uux8afxmadvpkssizkrP7yz8/2NXUmA6344Z32jPrO+kfzwn2WdStev1hTq1fo+u/+Y5uXl5GBPQjngEt1Ly79/Kmp8vk6trUXvG4S2Si6tq1G9uYDoAAGzX7ZX/KqhHW22Z/KmS9p2Qm4+nAto2Uc2GdYyOdkkOOSxuxowZSk5O1ty5c4sKS5Lk5+ensLAwSRSXymPX6wvUfEQ/BXRoZnQUAICDm72/9MKSJP09Ku7Lo9LPMVUWye6dWLG5sLAknXuS/vbX/YQtB7Vl8twqzWWv6g4aK0tKvCJn36OMI9uVE3tUSeu/0amvJqtO/3tk9vY3OiIAADa5YmAX7X1viU6u3Kr0qAQl7z+hIwvXavfMRUZHuySHLC7Nnz9fvXr1UmhoaKnLAwMDFRQUJEkaPXq03N3d5e3tXfTfypWMvz9f2vE4Ra3aprBJdxodBQDgwNLypCUnLt3PJOnrY5fsVm3s+3B5iTOWSnN00Tplnzlb+YHsXI16jdRyxh/Kz0jW0Zdu1P7H2it20XQF3vykrhjzntHxAACwWWZCshr26yR3f2+jo5Sbww2Li4uLU0xMjEaMGFFiWUFBgcLDw9WpU6di7Q888IDeeecdm/ZnsVgUFxd36Y4VIC/PUiX7Kc3e95Zq8LKXFdStjeI27auUfeTlWRQdHV0p2wZgH4w8jhmJ41uhNWe8lFNQ+5L9rJL2p0hbjsSpgUf1/Dfzt+y4ZCVsPlCmvgW5Fu36aqWCb+leyamqXl5eoCS3Mvf3atJBzZ9bVklZ8hQdHV8p265q1fWYfDEcr3E54jPcJAUW3k6Il19GnrGBYLdsPf7+8cT76v3eeN2x9xOlHIpW4o4IxazeoZMrt9qcw5ZjXlBQkMzm8pWLHK64lJGRIUkylTJRw5IlS5SQkFChQ+Li4uIUEhJSYdu7mJcCrldDN99K3cfG8e+W2p647ZDm1b+tUvcdERGh4VX0XAIwRlUcx+wRx7dCgcOeUPA9r5e5/7U33qqMg39UYiL718jsrxfq9C9z/+nPTNGyxw5WYiJjXPn2Xnle0aZCt3l0xu1KP7BRlrOntefeYAXd9ozq/WvsJdeLiIhQyIC2FZrFKNX1mHwxHK9xObyad1brNwq/5N84ZIgyj2wzOBHsla3H34Sth/Rd14dVp1ML1bsqVIFdr1TfjyYoZs1Orb77lXJvz9ZjXlRUlIKDg8u1jsMVl0JCQuTq6qp169YVaz9x4oTGjRsnqeR8S1999ZW+/vprBQYG6j//+Y+eeuqpclfhAADAxeVnpZWrf0E5+zujbGv5ftksb//qrNlT3xodAQCAcrPmFyhx2yElbjukfXOWqemtvdT7nccU2O1KxW/ab3S8C3K4Cou7u7tGjRqluXPnaujQoRo8eLCioqL00UcfKTAwUDExMcWKS48++qheffVV1alTRzt27NCdd96p7OxsTZs2rUz7CwoKUlRUVCU9muI2DX9FGcerZgieEUJDQxW18FOjYwCoRM5+HLsQjm+FTue66oG9VhVcYgIhk6yq556v7zeskEs1v2Kc1WrVpuH/U+aJhJKTef+TSXpn9bfyCrb/K8aU17j9gYrKNjpFodDQUP1cRZ/9Klt1PSZfDMdrXI6IDDdNPFR4e9ny5QqtybA4lK4ij7+phwuvguIR4FfudW095v09h3V5OFxxSZJmz54tNzc3LVmyRGvWrFG3bt20ePFivfjiizpy5Eixib7/vnqcJHXu3FlTp07VlClTylxcMpvN5T4dzFZubg75cpSZm1vVPZcAjOHsx7EL4fhWKFhS3zPSmtiL97PKpDubm3VFCM+ZJGU8eJP+fPrjS/YL7h+m0K4dKz+QAdwOS7KT4pKbm5vTvJ+r6zH5Yjhe43KkJkv6q7gUWC9QwbUMjQM7Zuvxd+D3U3X8h991evdRZZ9JlW/j+gp7+i7lpKQr7o+9NuWoqmOeQ/7F8fb21pw5czRnzpxi7Xv37lW7du3k4nLhi+C5uLjIar3UT4MAAMAWE9tJB1OlU5kX7tO9nnRH06rLZO9CR16vU+v26OTKLRfs49UgQN1efbAKUwEAgKoWs2anmt7SSx2fHCF3b09lnUlV/J8HtPHxd5WTZN/TCThkcak0KSkpio6O1uDBg4u1L1iwQAMHDpSvr6/Cw8M1depU3X777QalBADAudXxkOb2lF7fW3gGU/55v+d4maVbG0ljW0vmC/8OVO24uLqq74f/p52vLdDBeSuVl5ZVtMzk4qIrBl6ta16+T15Bl74SHwAAcFzh7/yg8Hd+MDqGTZymuBQeHi6p5GTe7733nsaMGaO8vDzVr19fI0eO1NNPP21AQgAAqocAD+l/naXEbOmPBCnTItWuIfUKLCwwoSQXN7Oueubfaj/+VkWv2q6shBSZa3qoYd+OqtkgwOh4AAAAF+U0H/EuVFz651XlHIV3cF31fm+8CiwWmVxd9eekj5R84ESxPiE3dFb7R29Rfp5FEV+s0rHvN0iSAto3Vdgz/5aL2VUJWw9q54z5F9xPQIdm6vLiPTK5mHTg0590fPHGYstb3TNQTYb2kEwmpZ2I1++PvytrfoG6vz5Gwdddpaift2rTUx9Kklw93dXrrXGqUdtHuakZ+v3xd5V79iLjIgAATq2uhzT0CqNTOBY3L4/Cv7soISc+UsffuEsms5us+RZd8dD78mrcvmh56vafdOrr52VydZNXszBd8eA7kqRTX0/R2d2/ymR2U8h/ZxdbBwAAVAynKS6NHTtWY8eONTpGhcmIPaMVQ5+TrFYF9Wir9o/eonUPzTzXwWTSVc/+W8sHPa38nFwN/H6qolZtV352rsIm3anf7n1NlsxLz4x5zbR7te6hmco+narBy6cr6udtxdaL+PJXHZy7UpLUc/Y4NejdXjG/7dKu1xfq2Hcb1GTYuQ/ALf9zvRJ3HNa+D5aq0eBr1GbsUO185ZuKe1IAAEC15V4nWC1f2SiTi4vO7lmjuG+nq+mT535AO/XNC2o26Xu51w3R4amDlBm5RyooUOaxHWo143flnolR5KxRCp222sBHAQCAc2LGAztlzS+Q/pp43N3HU0n7I4st96jto+zTZ2XJzJY1v0CpR06pblgL1e0cqrzMHPX54HHdsHCK6l4VWsrWC7nWcJOLu1kZMaeVn5OnhG2HFNCh+AyrBXmWotsmk3T2r8spZsYlldieb9P6OrP7qCQpcecR1e/e1qbHDgAA8E8mV7NMf120pSDzrDybdCi23LNRW+VnpMian6+C3CyZa9ZS9qkIeTW7SpLkHtBQuQknVJCXU+XZAQBwdhSX7FjtNo31r2Uv65qX71fshvBiy7LPnJVHHV951vOXuaaHAq9prRr+3vIKrKXarRtp3UMztXH8O+r+2oWvLOPu763c1Iyi+zmpGarh712iX7tHhunmjbPl7u+tzPiSRaW/JR84qYb9OkqSQq67SjVqldwWAACArTKP7dLBid108sNH5Nu+f7FltXvfpcMvDNC+h1vJo2FLudcNkecVbZUW/pusljxlndirnMQTyk9PNig9AADOi+KSHUvaF6kVNz6r1aNf0TXT7yuxfNNTH6r3u4+pz/uPK+VQlDLjk5STkq6ErQdlychW5qkzsmTmyM3bs9Tt56ZmyN2vZtF9d9+ayklJL9Ev/J0ftLjno0qLjFPz4f0umPfwN2tkrumhAYteUM2GdUo9uwkAAMBWXk07qtWrm9T82aU6+eEjxZad/GCsWr2xVW0/OCzJpJQ/f5DnFVeqVs8Rinj+OsX/8Lo8G7WT2beuMeEBAHBiFJfslIv7uemw8s5mKj8rt0Sf+D8P6Ofbp2rdmJkye9VQ4vbDOr3jsHybNpDJ1UVuPl5y8/FUXnqWzDU95O7rVWz9/OxcFeRa5BVUWy7uZtXrHKoze45dMEfu2UzlZ5fM8beCPIs2P/uJfr7tBZ09HqfI5X/a+vABAACKOX84m6uXn1xqFP9cY3JxlWtNf0mS2a+uLGlnJEn1/jVWLaevU+AtT8nzijYyubpWWWYAAKoLp5nQ29nUu7qVOk4YLmt+gUwmk7a8ME+S1LBfR7n7e+v44o3qPGWUAto1VYElXzv+97UK8izKzbPo0Be/aOD3U+ViNmvbi19IkpoM6ymzh7sOfLKi2H62PD9Xfeb8n0wuJu2bs0yWjGx51vXXlQ8O0faXvlTYpLtUp0MzycWk9JMJ2jPrO0lSh8dvU8jAq+VZx183LHhev9wxTf4tQ9T15ftUYMlX8oET2jbtiyp9zgAAgPNKP/C7Yr95QXJxlWRVyL1vKnXHSuWnJal2n7vU4K6pinjuWrm41ZCrdy3Vv+1pSVLE5P6S1Sqzbx2FPPCOoY8BAABnRXHJTsX9vlcrf99boj3mt11Ft7dN/bzUdY9+u05Hv11XrK1WqxDt/qswdL7Tu47op6HPFWvLSkzR9pe+LNzHi6XvY/fMRdo9c1GxtpSDJ7Xy1iml9gcAALgcvu2vlW/7ay+4vFaP21Wrx+0l2rk6HAAAlY/iUjWxZfJcoyMAAAAAAAAnxJxLAAAAAAAAsBlnLtkRn8ZBRkeoVM7++AAAgG0ael26T1WxpywAAMdkL999qzIHxSU70v+zSUZHAAAAqHIzrzE6AQAAFac6frdnWBwAAAAAAABsRnEJAAAAAAAANqO4BAAAAAAAAJtRXAIAAAAAAIDNKC4BAAAAAADAZhSXAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADajuAQAAAAAAACbUVwCAAAAAACAzSguAQAAAAAAwGYUlwAAAAAAAGAziksAAAAAAACwmdnoALDN6rtfUVpknNEx5NM4SP0/m2R0DAAAAMDp2Mtn/svB9wWgeqC45KDSIuOUEhFtdAwAAAAAlYTP/AAcBcPiAAAAAAAAYDOKSwAAAAAAALAZxSUAAAAAAADYjOISAAAAAAAAbEZxCQAAAAAAADbjanFOruesh9V8RD9JUkF+vrLiUxT7+17tmP6VMuOSDE4HAAAAoLIN/G6qzh6P1R8TPijW7h1cV7dtfV8rhj6nhC0HDUoHwBlw5lI1EPfnfi1of78WdX5I6x+epYC2jdX3wyeMjgUAAAAAAJwAxaVqoCDXoqzEFGXGJSn+zwM69OWvqnd1S7l5exodDQAAAAAAODiKS9WMZ2AtNR7SVQWWfFnzC4yOAwAAAAAAHBxzLlUDQd3b6N9HvpDJxUVmzxqSpL3vL5UlK0eS5BVUW/9a/rKWD3hK2WfOytXTXUN/fUNr7ntNKQdPGhkdAAAAQBXwahCgXrPHybOun6wFVkV89asOfLzC6FgAHIRDn7m0e/duDR06VH5+fvL19dWwYcMUGxsrHx8f3XHHHUbHsxuJOw5r6XVPavmgSdr15rdK2HpIO2d8U7Q8My5J++cs19VTR0uSOj4xXCd+2kxhCQAAAKgmrJZ8bZ36mX7o87h+HPyMWt09QH6hwUbHshtnsqVl5309+vSwtDfZuDyAvXHY4tLq1avVtWtXHTp0SM8995ymT5+u6OhoDRo0SOnp6erYsaPREe1Gfnau0iLjlHIoSrteW6C0qARd8/J9xfoc+OQn+YeGqPX9/1Kjf12j3W98a1BaAM6q4bWddNOq1zQy8hvdtuU9XfngEKMjAUC1FNi1ta6d+5Ru2/q+RscuUvvxtxodCZUs92ym3H1rlmh39ytsy8/JU1ZCipLCj0uSLJnZSj1ySl5Btas0pz2yWqUvj0iDV0mLTpxrXxcnjd4gPbJJSsszLh9gLxyyuJSYmKgRI0YoLCxMO3fu1JNPPqlHHnlEq1ev1smTheVkiksXtuv1BWo+op8COjQrarMWFGjrlHm6Ztq92jbti6IhcwBQEQI6NFP/eU8p+redWnr9BO16faGumnSXWo66wehoAFDtmL08lHI4StumfaHMeE69qA5Sj8QooH1TmVyKf/2r06m5Ciz5SjseW6zdO7iuAto10ekdh6sypl365pg0a79ksZa+/M9EafyfUm5+1eYC7I1DFpdmzJih5ORkzZ07V56e56545ufnp7CwMEkUly4m7XicolZtU9ikO4u1N+zfSZlxSarV6gqDkgFwVm0eGKLTu45qx/SvlXo4RkcWrtWBT39Su0eGGR0NAKqdmDU7tWP614pc+ocKcjnlojo4+NlKedT1U49ZDyugfVP5NApUk2E91GniHTqy4Dflns0s6mv28lDfTyZoywufKS89y8DUxkvLk945cOl+u5OlX05Vfh7AnjnkhN7z589Xr169FBoaWurywMBABQUFFd3/8ccfNXnyZB06dEg+Pj564okn9OSTT5ZpXxaLRXFxcRWSuyLl5Vkua/297y3V4GUvK6hbG8Vt2if/VlfoioFdtHzQJP1r2cs6+t16pZ9MKFOO6Ojoy8oCwHlc6NhUr0srHf56dbG2mN92qe3YofKqX1uZsUlVEa/ScCwEYI8u9/OiM3K043VFvYYZ0ae14sZnFfbUner/2SS5+Xop/US89r63VPs//rGon8nsqn6fTNDxH37XieWbKmTfjvacn29ZgrdyC/zL0NOqrw7lqqMpsbIjAVUiKChIZnP5ykUOV1yKi4tTTEyMRowYUWJZQUGBwsPD1alTp6K2X375RQ888IA+//xz9enTR5mZmUVD58q6v5CQkArJXpFeCrheDd18L9lv4/h3S21P3HZI8+rfVnS/24wHtHXKPGXGJWnnq/N1zcv3afXI/11y+xERERpuh88PAGNc6NjkWc9fWYkpxdqyEpL/WlbL4YtLHAsB2KOyfl6sThzteF2Rr2Hy/hNaffcrF+3T482xSj0crX3vL62QfUqO95yfr/H/famAPv8uQ0+TItLNCrniisJJmgAHFxUVpeDg8k3o73DD4jIyMiRJJpOpxLIlS5YoISGh2JC4yZMna/Lkyerfv7/MZrN8fX3Vtm3bqorrEFr8+zpln05V9OodkqSj366TW00PXfGvawxOBgAAAKAq1OvSSs1v76OgHu1006rXdNOq1xRyQ2ejYxnK5OJavr6lfEcFqguHO3MpJCRErq6uWrduXbH2EydOaNy4cZLOzbeUkZGhrVu3atCgQWrVqpWSk5N1zTXX6K233lKTJk3KtL+goCBFRUVV6GOoCJuGv6KM4xUzXO/wV7/q8Fe/FmtbecuUMq0bGhqqqIWfVkgOAI7vQsemrIQUedb1L9bm8df9v89gcmQcCwHYo4r8vOgsHO14XZWvYcKWg8VGNlQUR3vOz/fNKV8tKMPTb5JVQTUsijpx4tKdAQdw/jRDZeVwxSV3d3eNGjVKc+fO1dChQzV48GBFRUXpo48+UmBgoGJiYoqKS8nJybJarfruu++0cuVK1atXT+PHj9ctt9yiHTt2lHr20z+ZzeZynw5WFdzc7OOlc3Ozz+cHgDEudGxK2HJQDfp21O6Zi4raGvbrqPSoBIcfEidxLARgn+zl86I9cbTjtTO8ho72nJ9vZIC0ME661EA3q0wa0dzNYR8nUBEcblicJM2ePVsPPPCANm/erCeeeEKbN2/W4sWL1aBBA3l5eRVN9O3j4yNJeuyxx9S4cWN5eXlp+vTp2rVrl12ejQQAzmrfh8tVt1NzdZp0p/yaN1Cz2/uo9b2DFP7OD0ZHA4Bqx+zlodptGqt2m8ZycTPLs66/ardpLJ/G5f+lGnBmQZ7SrY3L1u8mx5xWCqgwDlkK9/b21pw5czRnzpxi7Xv37lW7du3k4lJYM/Pz81OjRo3KdIYSAKDynNl9VGvueVVhT9+ltmNuUlZiinbM+EaHPv/F6GgAUO3U6dBMA7+fWnS/9b2D1PreQYr7Y59W3lq2qRGA6mJCWyk9T1oZU7zdpMIzmup7Su92k3zdjUgH2A+HLC6VJiUlRdHR0Ro8eHCx9jFjxuitt97SDTfcoLp162ry5Mm66qqrdMUVVxiUFACqp+jVO4ouHAAAME7cpn2VMrcO4IzMLtK0MGlYI2nhcWnnGSmvQAquKd3cSBoULHk5zbdqwHZO8zYIDw+XpGJXipOkiRMnKjk5WWFhYSooKFDPnj31/fffG5Cwarl6umvAwinybxGsTU99qONLfi+23PuKeurx5li5uJl18qct2vfBUvmHBqvbaw/KWmCV1ZKv3594X+knEwx6BAAAAAAklelzeo83x8qncaDMXh469t167f/oR0lS99fHyLdZA+X/f3v3Hxt1fcdx/HnXy/UoBSo/NysJMBm6oTbQTCZE6GZIlywDpy6LYyTbPwRc5tgwbrBhGhdJ53C4ZZKpbCaCf2yCxjmHg6jg+DFYEUwQqQykBTLoD2mr7fV+7g+yiuMQ/DK4u/b5SO6Py/dyn/fnc8nnPnndfT7feIJtP1pN94m2nG2ESsLctnYpkbJSQuEw+x75E8df3fuR15SPHc2MX38PMlnSiSRbFjxCorObsbOrufH7XyedTNH49CYOb3j9soxDvoRCUD3yzENSbv0+XAqHw9TX11NfX5+HqvIn05vi1e8+zKT5s3Ner/7pt9mz4hlaGhqp3VDH0b/sJN7WyeZ5K0h2dVNZU8VNi+9k2+LHrnDlkiRJks52Mev0Hfc/TiaZIlQS5vatj3Jw7SYqZ95EujfJxtuXM+LGCUxdNo/X73k0ZxvZTJadP36CrqMnKb2qnNrnHjwnXJo0fzaN6zZz+NmtTL5nLp+5axYHfv9Xpi77Fi9+5SekexPUbqijeVMDya7uyzUckgpQUR7oncuiRYvIZrNMmzYt36UUhGwmQ0/L6fNeHzaxkpaGRgCObd7DmGnXE2/r7PsSyCTTZNOZK1GqJEmSpI9xMev0TDIFQElplK7mU6TjSYZOuJq2ff8CoO3Nw4y5+brzN5LN0nX0JADpeBKy594j7b2DTUSHDgYgOqyMeFsHseFDiLd2kuqOk01n6Dh0glFTJl5SfyUVn34TLumTCYU/POS8t+MDSq8a0ve8JBal6r5v8NaTL+WjNEmSJEk5XGidPnP1Yu7Y8Rtadh+EbJb33m7i6llVAFTWVDFoxLCLaqf6gfk52/j39v1Mmj+bOa+spHJWFU0bdxNv6yQ2ciiDRlcQGRxjzM3XU1pRHriPkopTv9kWp0/m7B8iokPLiLd2AGf2Wt/62L3sX/0Cp99uylN1kiRJks52Mev0LQt/RUksSu36Oo78eTvHX3mDUVMmUru+jva33qX9wNELtjN50RxSPb28s27zOdeql81jz0PraP7bPxk/dzpTl97NruVPseP+x7n1t/eS6klw+mAz3SfbL7m/koqL4dIA1dF4jJFV19K69xDXfHkK2354Zs/29JULOfHaPpo27s5zhZIkSZL+60Lr9HA0QiaRIh1PkOrpJd2TAGDvL/8IwKdn3EC6NwlAZHCMcEmYROdHz0W69ptfYvjnx7H1POcyEQoRb+8CIN7a2bf74eTOA7x8Vx2Rshg1a5bQ0vDOJfdXUnExXOrHZj25hBGTx5PqjjNyykROvLaXaEU5R577Ow0PrWP6yoWEIiU0v7yb95tOUVlTxbiv3UL52NGMnzOd9v1H2LX8qXx3Q5IkSRrQzrdOr6yp6lvf3/b0UsKREsLRCO++uIP3m09ROnwINU8sIZNK88HxVv6xbA0A4+fOIBKLcmDNh1vfImUxbnl4Aa1vHKJ2fR0AG+94gEGjKvjcgq/S8PO1vLnqWb74iwVk0xlCkTDb7/sdcGYb3YgbJpBJpdmz4pm+858kDRyhbDbHSW0qeM/P/AGnG4/luwwqPnsNc7esyncZkgpEocxNV5pzoaRCNFDn5I9TbPP15foMv/Dgd9i3aj29bZ3/9/f+X8U25pKC8Z9LkiRJkjSA7PrZH/JdgqR+xrvFSZIkSZIkKTDDJUmSJEmSJAXmtrgiNWTcp/JdAlA4dUgqDAN1Thio/ZZU2JybzlVsY1Js9ebSH/og6cI80FuSJEmSJEmBuS1OkiRJkiRJgRkuSZIkSZIkKTDDJUmSJEmSJAVmuCRJkiRJkqTADJckSZIkSZIUmOGSJEmSJEmSAjNckiRJkiRJUmCGS5IkSZIkSQrMcEmSJEmSJEmBGS5JkiRJkiQpMMMlSZIkSZIkBWa4JEmSJEmSpMAMlyRJkiRJkhSY4ZIkSZIkSZICM1ySJEmSJElSYIZLkiRJkiRJCsxwSZIkSZIkSYEZLkmSJEmSJCkwwyVJkiRJkiQFZrgkSZIkSZKkwAyXJEmSJEmSFJjhkiRJkiRJkgL7D/MgGEUiW1xWAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAH4CAYAAAC8Fx1oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACGg0lEQVR4nOzdd1yV5f/H8fcBDrJRQIEEcYV775GaaZo4K1NLzbZZtmyalbkqW99MU3/2TRuWfRuOzJHbsnLlQFPJDQg4EBmyOb8/KOwICihwnwOv5+Phw5vrvu77fh84h3OfD/d13SaLxWIRAAAAAACADXMwOgAAAAAAAEBhKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGyek9EBypt5G6VzyUankHw9pIe6GZ0CAOxX1vzNspxLMjpGmTP5esrpvi5GxwAAu2UrnwckPhOg/KGAUcLOJUuxF4xOAQC4XpZzSVJcotExypzF6AAAYOf4PACUHoaQAAAAAAAAm0cBAwAAAAAA2DwKGAAAAAAAwOZRwAAAAAAAADaPAgYAAAbpsWiyHln9f/naj184I+d37taWqIMGpAIAALBNFDAAAAAAAIDNo4ABAAAAAABsnpPRAZArOytDM0dVuubtn/zCUoJpAAAAAACwLRQwbETUgY0a/tZ++VZvaHQUAICN6b5okhLTU5WZk6XOQfU145b75OjARZQAAKBiseuznz179mjAgAHy9vaWl5eXBg4cqJiYGHl6emro0KFGxyuW+OgDFC8AAAVaMuhZ7bj3De0eNV1nLibq24jfjY4EAABQ5uz2Cox169apb9++CgkJ0YQJE+Tq6qoFCxbotttuU3Jyspo3b250RKDCslikC6ek6L3SxfOSyUHyvkEKaiq5VjY6HcpCdo4UHiXtOCYlpUqVzFKj6lKb2pKbs9HpbIdXJTddSL+Yrz0hPUWS5OLknNdPkrJyspWRnSWTTGUXEgBQJiwWi5ZOv00ZaYm685Wf5eDgmLfu9LE/9PXE9uo9ZqFubDfYwJSAseyygHHmzBkNGTJELVu21Nq1a+Xq6ipJGjFihGrVqiVJdlXAiD91UD431Dc6BlAistKlvcuk+BPW7QlR0oltUs12Up3OkonPX+VW7AXp/zZI8SnW7RGx0vLd0vCOUrMahkSzOfV8btD3Eb8rOyfHakjIjpgjcjQ5qE5l/7y2nl9P0e7Tx9W7VnPdEdrOiLgAgFJkMpnU8+H5Wji+qXYse0NtB06QJGVlpGr17OGq1/Eeiheo8OxyCMlbb72l8+fPa/78+XnFC0ny9vZWy5YtJdlXASP6wCZVb9DN6BjAdcvJlnZ9n7948W/Ht0pHt5RdJpSt8ynSzLX5ixf/yMyWFvws/Rldtrls1ejmPRSXkqgHV83RH7FHdSQhTosO/KqJW77RvY27qrKLe17fNUMm6OToj5SalaENJ/cbmBoAUFrcqwTqlgfmaeviSYo7ukOS9MuiF5Sdla5uI2cYnA4wnl0WMBYtWqSbbrpJoaGhBa739/dXQECAJCkrK0tPPvmkfHx8VLlyZT3wwANKS0sry7iFyspMk5M59w4kFotF3027Rd9M7iJLTo5Vvx/eG6CvXmmt7KxMI2IChTr9l3ShCB9Mj2+V0q/wARf2bd1+KbmQX7EWSUv/yB1qVNGFeFfVprsn6nxaigYtfketFryot7Yu1TNt+urDHvfl6+9qdlb/uq31w+EdBqQFAJSFOq0HqmGXUVo9e7iO7lym8HVz1OvRL+Ts6ml0NMBwdjeEJDY2VtHR0RoyZEi+dTk5OQoPD1eLFi3y2qZNm6YNGzYoPDxczs7O6t+/v55//nnNmFG0CmZWVpZiY2OLnC8z01+S+ep90i/K/Pd45vSLiarkVjlvnclk0q2PfJp76djyt9Sm/0uSpPB1c3Vy3xoNm/KHHJ2uvv/cHJmKioorcm6gJJzYWlWSs1TI+HyLRTrwywX5NUoqk1woGxlZJm09Eqjcn//VnwNxidLv+08ruHJGmWS7Fr6ZWWXyJtmsWoiW3P7cFddfSL+ojOwsVXXzUlZOtlYc/UNdg0tv0ueszCzFRUWV2v4BoLwryueBwnS55319OaGFlv9nkNoOfEWBN3a4xix8JoDtCggIkJNT8c627K6AkZKS+2dbUwED6JcuXarTp09bDR/5+OOPNX36dFWvXl2SNHHiRA0ePFjvv/++HB0d8+3jcrGxsQoODi5yvuFv7pNvUKMC1+VkZ2nL1y/J0VxJHQdPkSSd3PeTajTpadXP0zdI3e+brdWzRyikaW+Znd20+ctn1HnY20WeKyMiIkLBtzcucm6gJPwwNUUuzoVPbmGxWLTkq/V6/dPbyyAVykrVmi1095Q/itz/seff1K6V75diouuze9R0NfQLMjqGEtJSNGTZf5SRnaVsS456hDTRQ81uKbXjRUREqHnwwFLbPwCUd1f7PFBUZhd3tQp7TuvnP5o3F8a14DMBbFlkZKSCgop3rmV3BYzg4GA5Ojpq06ZNVu0nTpzQ2LFjJV2a/yIhIUGRkZFWBY2WLVsqKSlJx48fV506dcoqtiTJwdFJ7e94XYvf7JHXlnL+lDyq3JCvb2j7ITr6xw9a/dE9cqrkpur1uqhZz8fKMi5QbA6moo9KczQVXkCEfTEV4+cvSSYHngNFEeJdVb+PmGp0DABAGXNwNP/9v919ZANKjd29GpydnTVy5EjNnz9fAwYMUFhYmCIjIzVv3jz5+/srOjo6r2CRlJR7eXrlypXztv9n+Z91hQkICFBkZGSR883f7q9z+e+Il8dcyU2uXtWUePakPH2Dr3rCf/O9M/XxE9VlMjmo/7jlRc4gSaGhocXKDZSEY6sdlH7eosKGD5hMJoXd2U33TeY5Wp6kZpo0+zeLcixSYc8BSXp/6guqPefJUs91rXw/3ynFX+UXejnF+wcAXJ/CPg+UJX6nw5b9M29lcdhdAUOSZsyYIbPZrKVLl2r9+vXq0KGDFi9erEmTJunw4cN5k3t6euZOdHPhwoW8b05CQoLVusI4OTkV67IW8+7C+9Rq3lfHdi2Xf61W8q/d5or9Dm75QrJYlJVxUaeP7VStFmFFz2E2F/tyHOB6mdpIB34qWt/6nbzkVtmrdAOhzLWMkXYcK7xfFTepcxM/OdjwVNKZ5j1GRzCEk7l473sAAGtF+TxQVvhMgPLGhk8dr8zDw0Nz585VbGyskpKS9NNPP6lDhw7at2+fmjRpIoe/z4grV66s4OBg7d69O2/bXbt2ydPTUzVr1jQmvKRazcN0bPdyxR3dLv86bQvsEx99QL8sel5dR3ygZr2e0NqPH1Rq0tkyTgoUT0B9yd2n8H7Vm0r/mrsW5UiPRpJzEUrjfZrJposXAAAAsD3l5vQxISFBUVFRVvNdSNKDDz6oN954Q6dOndKZM2c0ceJEjRo1qkgTeJYW9yqBykxNUmbGxQInI83OytTq2cMV3KiHGt/8kDrd9YZcPX217pNHDEgLFJ2js9RisOTue+U+AQ2keqU3/yAMFuAtPdJNcrnK5OuDWkltapdZJAAA7FLDLqP0xGdZRscAbIpdDiEpSHh4uCTlK2CMHz9eZ8+eVaNGjZSTk6M777xTb731lgEJrdVo0lPe1Qo+g//9u1eVFB+lAc+tlCQ5Obuo16NfaNGrbXXg58/U4KaRZRkVKBYXT6ndCOn0X1LkLunCqdx2vzpSSBupcnWpgLodypE6/tIrA6RtR6Utf0ln/55yqGWIdFtTqSojhwAAAHANyn0Bw8nJSTNmzNCMGTMMSHVljbo9KGfX/Gfx0Yd+0c4f31bfpxbLzbtaXnvVkOZqf8fr2vj5E6reoJu8/GqUZVygWByccq+0qBwk/TI3t61+j9ziBioG90rSzQ2k2tWk91fltnVtYN/Fi/1no/TYmo/lYHKQk8lBc3o9pNqV/a36rDq6W69v+VZmR0e1qFZTH/S4TycTz+r+FbMlSZk52ToYH624x+dd8TgPrJyj8DMn5eXsqlCfQH1064NX7Dtj50otOrBFZgcntfCvqf/cMipfH+//jFKbgNy7bj3eqrcG3thGEfExGvPTxzKZTGpeLUTTuw0v8IpAAAAAW1JuChhjxozRmDFjjI5RZAXdOlWSqtfrfMVLxdr0f0lt+r9UmrEAAFdQ1dVTS29/Xt6V3LT62B5N+22xPr5ttFWfyb9+p/8NeFrBXr7q9+1b2nvmpJpWraG1Q1+RJC39a7tWHyt8ctAPe9yndjfcWGi/PrVbaGzL3jKZTLrnhxnaHHlAXYIbWPUJ9vLNO/4/Xtr8pd7qdo9aBdTWU+sWaN2JfepRs0mhxwMAADBSuZkDAwCA0lTN3VveldwkSWYHRzkWMAtpI79gJaSnKDsnR6lZGapSyd1q/VcHtmhog06FHuuZ9Z/plkWTCi121K0SkHflhNnRSY4FXEURk5ygWxZN0j0/zNDplAuSpCPn49TCv6YkqXVAHW2M3F9oJgAAAKOVmyswAAAoC6mZGZr067f6sMf9+dYNbdBRfb99U+7mSupWo5GCvS7NaJuYflF7z5zUTUH1r7r/t7reLT83L8WlXFDPr6eoXWBdVXZxv+o2W6IO6lRSvDpWr5dv3aEH35efm5e+OrBFz29aqAV9xqihX5DWHA/XrTWbavWxPfKq5FrERw8AAGAcrsAAAKCIsnKyNeLHmXq6dZiaVM0/F9HYtfP16/Ap+vPB92UymbT0r+156xZHbFP/uq0LnWvCzy13ohB/d2+1Cqilw+djr9r/wLlovbT5K33Z74kC9/3P/gbXa6/dccclSdO73aN5e9apz7dvyLuSqwLdq1z1GAAAALaAAgYAAEVgsVj0yOp5urVmUw24sU2BfRxNDqr89zATP1dPxacl56376sAWDfvX8JHUzAyduZiYbx8X0i/mrd9z+oRqePlJkk4mns3X92TiWT2wcrY+7fNYXqHi31Iy0pSdkyNJ+jnqoOpUyZ10NMjTV98OfEYr7nxJaVmZGniFxwMAAGBLGEICAEAR/HR8r7499LtOXDij/x38Tc2qhejd7iO1+tgexacla1iDTnq10x269X9TVcnJrMqV3PVCuwGSpJjk8zp9MVHNqoXk7W9L9CGtPrZbb988wuo4I5Z/qAvpqcrMydJTrcNUzd1bmdlZunPJe9o2cppV35c2falzqUl6aFXu7X6ea9dfvWo107j1n+nlDrfr+IXTGv3Tx/JwdpHZwVGzej4gSfpi/8/6dN8mOZhMurtBJzWuGlya3zoAAIASYbJYLBajQ5Qnby6XYi8YnUIK8JZe7Gt0ClR0aUmXbqPa+RFuo1oRnTh36TaqT/eWQnyv3t+WZL7zoxSX/wqJkvLW1qXqU7tFgUNRLvdr9CHtjjuuMS17lVqePP5eMj8bVvrHAYByylY+D0h8JkD5wxUYAAAY4J+rM4qiY/V6BU7QCQAAUJEwBwYAAAAAALB5FDAAAAAAAIDNYwhJCfP1MDpBLlvJAQD2yuTrqYo4SZTJl8lqAOB6XO95eHaOdCYpd7mqp+R4HX9y5jMByhsKGCXsoW5GJwAAlASn+7oYHQEAYIeu9/NAwkVp4uLc5cd6SJXdrjsSUG4whAQAAAAAANg8ChgAAAAAAMDmUcAAAAAAAAA2jwIGAAAAAACweRQwAAAAAACAzaOAAQAAAAAAbB4FDAAAAAAAYPMoYAAAAAAAAJtHAQMAAAAAANg8ChgAAAAAAMDmUcAAAAAAAAA2jwIGAAAAAACweRQwAAAAAACAzaOAAQAAAAAAbB4FDAAAAAAAYPOcjA4AAEBZ2L1YSk0wOkX55FpZaj7I6BQAAKC8o4ABAKgQUhOklHNGpwAAAMC1YggJAAAAAACweRQwAAAAAACAzWMIiQ25mC6dTpIysyRHB8nXQ/J2MzoVAAAAAADGo4BhsJgEaUuEdDBGOpucf72Xi1THX+p4o1S3mmQylXlEAAAAAAAMRwHDIOeSpW+25RYuriYxTdp1IvdfYGXprrZSraplEhEAAAAAAJtBAcMAW49I3+2QMrKKt11MgjRjjdS9gRTWTHJgBhMAAAAAQAVBAaOMrd0vLd997dtbLNK6P6XzKdLwjhQxAAAAAAAVAx9/y9C2o4UXLxxMkrdr7j+Hq8x38ccJafEfJRoPAAAAAACbVa4LGG+88YYGDx6s2rVry2QyqWbNmoZliU+WvtteeD9PF+n123P/ebpcve/Ph6RDhcyhAQAAAABAeVCuCxjjx4/X+vXrVadOHVWpUsXQLN/tkNKLOedFUSzaKmVll/x+ARgjJV36Ky63OHmugDsTAQAAABVVuZ4D48iRI6pdu7YkqXHjxkpONubTQNwFaX906ez7fIq0N1JqWbN09g+gbMQnS6vCpT+OS1k5l9rrB0q3NpZqVzMsWrm39cAKfbJyvCJPH5CPV6AGdnpCd3Z9xuhYAAAAuEy5vgLjn+KF0X49XLr7/yWidPcPoHTFXZDeW5U7T86/ixdS7q2WZ66Vdp80Jlt5dyhyh15bMEBt69+m2U/v1oieE/XJqvH64bc5RkcDAADAZcr1FRi2orTnqTh2Nnd4SiV+moDdycmR5m2SktOv0scifb5FCqoi+XmWXbaK4LvN76lecBs90OcNSVKIfwOdiNuvrze8qX4dRhucDgAAAP9Wrq/AsAXpmbl/XS1NFosUHV+6xwBQOg7ESGeTCu+XnVP6V3NVRPuPb1Hrer2t2lrX66248yd0JiHKoFQAAAAoCH+zL0RWVpZiY2Ovefu4JLMs8rdqczBd+Q4jXq4FL/9bUlruX2T/7eCJeDlnXLzmnEBpyLzoKClQkhQTEyPzBWacvdwvB6pIci9CT4u2Hc5Wy6rX/vvICKcTzdLfvwNPx8XJMTXTsCyZmf6SzFZt8Ukx8vEMsGr75+v4pBhVrRxUVvHsWmZmpqKi4oyOAQDlQlK69flTciXOn1A+BQQEyMmpeCUJChiFiI2NVXBw8DVvH3hjB9312q9Wbf/cKrUw424ruP2176ULqdZtL738qvaumXWNKYHS4eddXV9NyP0rdtu2bXT2QinNZmvHBjy/UiFNbpXJVNgFcSYlJGdd1+8jI1Sr3VrDJuXeQ7pvv746fXSHYVnmjdunmgGNDDt+eRYREaGujzQ2OgYAlAsePtX1wIxL50/J8Zw/oXyKjIxUUFDx/ljEEJJSlp15lYHtJSgnK6NMjgOgZGWkJkoyFdrPYrEoIy2x9ANVMD6egYpPsr6q5XxyXN46AAAA2A6uwChEQECAIiMjr3n7tEyTZlpfgKGktNyrKAri5Xrpyot3V0qJqfn7JKXlb5v7wVTVqPLqNecESkPmRUcdWZa7vG3bdpnduATycgdOu+rHA4UXMEwmkzrUc9Or1/H7yAgxiWYt3JW7vPyH5Qr0Mm4IydEV/sq4rAbUqGYn7Ti0WiN6Xvr9uePgKvlXCWH4SDGEhoZe13slAOCSpHRHzf09d3nbtu3yZAgJyqmAgIDCO12GAkYhnJycin1Zy+X89kpnky99nWPJPwSkIImpResnSc3rVZWb87XlA0pLWpJ05O/lwMBAuXAHjXwCAqXNxwouTF6uVwsP3VDFo/RDlaDsc5eWq/n7K8jXuCyRZunya9Xu6PK0npzZUZ+sfFk9Wo3QwZNbtWTLhxrd/31DMtors9l83e+VAIBcCf+a1i4wMFCV3YzLAtiacl3A+Pzzz3XixAlJ0pkzZ5SRkaEpU6ZIkkJCQjRixIgyyVHX37qAUdKqVxHFC8BOOTlK990kzV4vZV7lDywDW0k3VCm7XBVFveA2en3UEn2ycry+3fSOqngG6L7eU7mFKgAAgA0q1wWM//73v9q0aZNV2yuvvCJJ6tq1a5kVMDreKP1+pPB+17N/APardjVpbE9p2S7p8GU3cqjqKfVuKrWqaUi0CqFdgzC1axBmdAwAAAAUolwXMDZu3Gh0BElSDV+plp907GzJ79vNWWpds+T3C6Bs1fCVHu8h7Twufb4lt+3ONlKnGyVT4VNkAAAAAOUedyEpI4PbSo6l8N2+o41UyVzy+wVgDL9/zRMS7EvxAgAAAPhHub4Cw5bcUEXq3UT6cc/V+/37DiWFTerXLFhqGVIy+QAAAAAAsGVcgVGGejSSOta9ep9/7lByITV3+UrqVJPu6chfZwEAAAAAFQNXYJQhkyl3KImHi7Rmv2S5SoHiaprXkO7uIDnz0wMAAAAAVBB8BC5jJpPUp5nU4Abpq9+l04lF39a9knRHa6lFCFdeAAAAAAAqFgoYBqlVVXoxTDpwSvrlLykiVsrOyd/PZJKCfXJvldoyhKsuAAAAAAAVEx+HDeTgIDUKyv2XlS3FXpCOnpG+35G7/v4uUr1AqRI/JQAAAABABccknjbCyVEK8pGaBl9qq+FL8QIAAAAAAIkCBgAAAAAAsAMUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAIAy8PzcHpq+aJTRMQAAAOwWBQwAAAAAAGDzKGAAAFBES7fM0gNvN1SfFytp8MRqev3TOyRJw6fV1MK1U6z6vvvNgxo3u5skafqiUdp1eJ3W7PxUPZ8zqedzJu05srHQ4w2fVlMLVr2iD757VANfqazBE6tpyZaZyshK18wlYzXo1SoaOrm6lmyZabXducQYTf1iqAa+UllhL7lq3OxuOhS5Q5KUk5Oju6fW0Jfrplltk5GVrkGvVtGKrR/ntS355UPdP72++rzkonvfulEL101VdnZWcb9tAAAAJcLJ6AAAANiDT1e/pm83v6sH+ryp1qG3KjU9WdsOrSzSto8N+ECx8Ufl4xWoMf0/kCR5uvkUadslWz7U8B6vataTO7Rx9yLNWjJW2w6uUMu6PTTzie3avPcbfbT0CbWo210h/g1lsVg0ccFAZWSla8r9y+Xu4q2F66boxXk9teCFv+Tt7qdbWg7X2j8+1923jM87zm/7lyojM01dmw6WJH3200St3j5fj/b/j+pUb66TcQf0wfejlZmZplG9JxfzuwcAAHD9uAIDAIBCpGak6H8bp2tkz4ka2OlxBVUN1Y1BLXXPLS8XaXt3V285OTrL2clVPl4B8vEKkNnJuUjbNqvTTXd2fUbV/epqWPfxcqvkKUeTY17bkG4vyN3FW7sOr5ck7Tq8Xgcjt2n8PV+qca3OqhXYRM8P/UzOTi5a9utHkqSerUYq8vRBHYrcnnecNTs/U8fGA+Xu6q20jIv638bpeuqOuercZJACfWqpXYM+uq/XFC3Z8mExv3sAAAAlgyswAAAoxInY/crISlOr0FvL/Ni1A5vlLTs4OMjbvapqBTa1aqvsUU0Jyadzs8btl5ebr0L8G+b1cXaqpPo12ulE3H5JUo1q9VU/uK3W7vxc9YLb6Hzyae04tFqT7luWt4/0zFRN+uwOyWTK209OTrYystKUkHxGlT2qlurjBgAAuBwFDAAArpPJ5CCLxWLVlp2dWSL7dnI0X3YsU/42mWSx5BRrvz1ajdQXa17XI/3e1YZdX8rb3S+vQJPz974mjPhGQVVD821b1OEvAAAAJYkhJAAAFCLEv6GcnVy0M+KnAtdX9qimc4mnrNoOR++y+trJyVk5luxSy/iPEP9GSrx4Tifi/sxry8hK18GTW1XTv3Fe280thikl7YK2H1qlNTs/U/cW98jRwVGSVNO/kZydXBQTf1TV/erm+/dPPwAAgLLEFRgAABTCtZKH7uw6Tp+tmShns6tahfZUemaqth1coWHdX1LLG3voh18/UqfGg+RfJUTLf5+juIQTVlcqBFSppT1HNujU2SNyd/WWu4t3vispSkKLut1VP7itpi28W2MHzZK7q7cWrp2sjKw09ev4aF4/LzcftW0Qpk9Xv6ojp3br+SGfWj3eYd3Ha/7K8TLJpJY39lB2TpaOxYbrcPQuPRT2VonnBgAAKAwFDAAAimBUr8nydq+qJVtmaM4PT8vDtYqa1O4iSRrS7QXFnT+hqQuHyMnBrH4dx6hL08E6dfZw3vaDu47T8dhwPfJ+M6VlpOid0RvUrE63Es9pMpk0cdQSzVn2tCZ8EqbMrHTVq9FWbz60Rt7uflZ9b211r177dKDq3NBctQKbWK0b3vMV+XgFaumWmZq7fJwqmV0V5BeqW1uPKvHMAAAARWGyXD5oF4ZKuChNXJy7PHGQVNnN2DzA9UhLkn6Zm7vc+RHJxdPYPPbgxDnp/VW5y0/3lkJ8jc1zvWzp8fw2X0o5Z9zxyzN3X6nDfUanAIDygc8DwJUxBwYAAAAAALB5DCEBAMAAX66bpq/WT7vi+h+mJpdhGgAAANtHAQMAAAP07TBaXZvdZXQMAAAAu0EBAwAAA3i5+cjrX3cpAQDA1uxeLKUmGJ2ifHKtLDUfZHQK+0MBAwAAAACQT2oCE2DDtjCJJwAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHl2XcDYs2ePBgwYIG9vb3l5eWngwIGKiYmRp6enhg4danQ8AAAAAABQQpyMDnCt1q1bp759+yokJEQTJkyQq6urFixYoNtuu03Jyclq3ry50REBAHZg79HN+nbTuzpyardOJ5zUqF6TdU+PCUbHgo25ECNF75UuxksySd6BUlAzybWy0cmA4jufIv12WDp6RsrJkXw9pQ51pFpVJZPJ6HSwF1sPrNAnK8cr8vQB+XgFamCnJ3Rn12eMjoVyzi4LGGfOnNGQIUPUsmVLrV27Vq6urpKkESNGqFatWpJEAQMAUCSp6ckK8W+o7i3u1uxlTxkdBzYmK0Pat1w6e9S6PSFKOrFdCmkj1e3Chz7YB4tFWr1PWr1Xsvyr/egZaftR6UZ/6b6bJLdKhkWEnTgUuUOvLRigwV2f1fh7vtLBk1v1wfejVcnZTf06jDY6HsoxuxxC8tZbb+n8+fOaP39+XvFCkry9vdWyZUtJFDAAAEXTrkEfPdDnDXVrPkRmJ87acUlOjrR3af7ixb+d2C4d+bnsMgHXY+1+adVlxYt/+ytO+r+NUlZ2WaaCPfpu83uqF9xGD/R5QyH+DdSrzSgN7DRWX2940+hoKOfssoCxaNEi3XTTTQoNDS1wvb+/vwICAiRJ//vf/9S5c2d5eHioZs2aZZgSAADYs7NHpPgThfc7vl1KSyr9PMD1SE6TVoUX3u/4WWn3ydLPA/u2//gWta7X26qtdb3eijt/QmcSogxKhYrA7oaQxMbGKjo6WkOGDMm3LicnR+Hh4WrRokVeW5UqVfT4448rLi5O77//frGPl5WVpdjY2OvKXBxJ6Y6SAiVJMTExSq5ECRz2K/Oi9fPZfIHnc2FOJ5ol+ecux8XJMTXT2EDXyZYeT2amvySzYccvzzIzMxUVFWd0jBJ38nc/SZUkFTI+xCId+CVRVZsklkUs4JpsO+mh7JzKRehp0bp9GQownyntSLgCW/o8cKX3zvikGPl4Bli1/fN1fFKMqlYOKot4dq28vncWR0BAgJycileSsLsCRkpKiiTJVMBg06VLl+r06dNWw0d69uwpSVqyZMk1HS82NlbBwcHXtO218PCprgdm5FYt27Zto+T46DI7NlDS/Lyr66sJl57PZy/wfC5MtdqtNWzSdklS3359dfroDoMTXR9bejzzxu1TzYBGhh2/PIuIiFDXRxobHaPELZ4ULw9Xl0L7WSw5WvntL3q5T1gZpAKuzW1jv1Zou7uK0NOkqHhTmZ7/wpotfR7gvbP0lNf3zuKIjIxUUFDxil12N4QkODhYjo6O2rRpk1X7iRMnNHbsWEnMfwEAAK6fyVS00ySLJAcHx9INA1ynoj6fi9sXFZOPZ6Dik6yvUj+fHJe3DigtdncFhrOzs0aOHKn58+drwIABCgsLU2RkpObNmyd/f39FR0eXaAEjICBAkZGRJba/wiSlO2ru77nL27ZtlydDSGDHMi866siy3OVt27bL7MbzuTAxiWYt3JW7vPyH5Qr0su8hJLb0eI6u8FcGV/iXitDQ0DJ9rywrx9e4KO2cRYUNIXEwOahnv44a/lr5+x6g/PjlmJd+L9LcFhZV9bSUy9e0vbClzwNXeu9sVLOTdhxarRE9X81r23FwlfyrhDB8pIjK63tncfwzb2Vx2F0BQ5JmzJghs9mspUuXav369erQoYMWL16sSZMm6fDhw1ec3PNaODk5FfuyluuRcPHScmBgoCq7ldmhgRKXliQd+Xs5MDBQLp6GxrEL2ecuLVfz91eQr3FZSoItPZ5Is5RRQHtqerKizx6WJGVmZyg+KVaHo3fLtZKHqvvVLduQdspsNpfpe2VZcWgj/bmqaH3rd/KUuy+/5GC7bq0sbT155TuQXGJSt4bl8zVtL2zp88CV3jvv6PK0npzZUZ+sfFk9Wo3QwZNbtWTLhxrdv/hzDlZU5fW9s7TZZQHDw8NDc+fO1dy5c63a9+3bpyZNmsjBgcveAABFExG1Q8/OuTnv62W/ztKyX2epae2uevfRjcYFg+H860kndkgpZ6/eL6Ch5G7nxUaUfz4eUscbpS1/Xb2fn4fUpnbZZIL9qhfcRq+PWqJPVo7Xt5veURXPAN3Xe6r6dRhtdDSUc3ZZwChIQkKCoqKiFBZmPYFWdna2MjMzlZmZKYvForS0NJlMJlWqVMmgpAAAW9KsTjetebvwv0mi4nE0Sy3vlHZ9JyVf4YYM1W6UGt5atrmAa3V7ayk9S9pxrOD1VT2l0d0lF27YhCJo1yBM7RoweTHKVrkpYISH597Y+vL5Lz7//HPdd999eV+7uroqJCREx48fL8N0AADAHlXykNreI53+Szr5h5QYk9vuW0sKaSNVCZYKuDEaYJMcHaR7Okgd60rrD0j7cm90oRq+UudQqUWIZGY+WgA2rNyMtbhSAWPUqFGyWCxW/yheAACAonJwkgIaSE37X2prcKvkU4PiBeyPySTVribd2eZS2/1dpLa1KV4AsH3lpoAxZswYWSwWtW/f3ugoAAAAAACghJWbAgYAAAAAACi/KGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDznIwOAABAWXCtbHSC8ovvLQAAKAsUMAAAFULzQUYnAAAAwPVgCAkAAAAAALB5FDAAAAAAADbp+bk9NH3RKKNjwEZQwAAAAAAAADaPAgYAAAAAoNQs3TJLD7zdUH1erKTBE6vp9U/vkCQNn1ZTC9dOser77jcPatzsbpKk6YtGadfhdVqz81P1fM6kns+ZtOfIxkKPN3xaTS1Y9Yo++O5RDXylsgZPrKYlW2YqIytdM5eM1aBXq2jo5OpasmWm1XbnEmM09YuhGvhKZYW95Kpxs7vpUOQOSVJOTo7unlpDX66bZrVNRla6Br1aRSu2fpzXtuSXD3X/9Prq85KL7n3rRi1cN1XZ2VnF/bahAEziCQAAAAAoFZ+ufk3fbn5XD/R5U61Db1VqerK2HVpZpG0fG/CBYuOPyscrUGP6fyBJ8nTzKdK2S7Z8qOE9XtWsJ3do4+5FmrVkrLYdXKGWdXto5hPbtXnvN/po6RNqUbe7QvwbymKxaOKCgcrISteU+5fL3cVbC9dN0YvzemrBC3/J291Pt7QcrrV/fK67bxmfd5zf9i9VRmaaujYdLEn67KeJWr19vh7t/x/Vqd5cJ+MO6IPvRyszM02jek8u5ncPl+MKDAAAAABAiUvNSNH/Nk7XyJ4TNbDT4wqqGqobg1rqnlteLtL27q7ecnJ0lrOTq3y8AuTjFSCzk3ORtm1Wp5vu7PqMqvvV1bDu4+VWyVOOJse8tiHdXpC7i7d2HV4vSdp1eL0ORm7T+Hu+VONanVUrsImeH/qZnJ1ctOzXjyRJPVuNVOTpgzoUuT3vOGt2fqaOjQfK3dVbaRkX9b+N0/XUHXPVuckgBfrUUrsGfXRfrylasuXDYn73UBCuwAAAAAAAlLgTsfuVkZWmVqG3lvmxawc2y1t2cHCQt3tV1QpsatVW2aOaEpJP52aN2y8vN1+F+DfM6+PsVEn1a7TTibj9kqQa1eqrfnBbrd35ueoFt9H55NPacWi1Jt23LG8f6ZmpmvTZHZLJlLefnJxsZWSlKSH5jCp7VC3Vx13eUcAAAAAAAJQ5k8lBFovFqi07O7NE9u3kaL7sWKb8bTLJYskp1n57tBqpL9a8rkf6vasNu76Ut7tfXoEm5+99TRjxjYKqhubbtqjDX3BlDCEBAAAAAJS4EP+GcnZy0c6InwpcX9mjms4lnrJqOxy9y+prJydn5ViySy3jP0L8Gynx4jmdiPszry0jK10HT25VTf/GeW03tximlLQL2n5oldbs/EzdW9wjRwdHSVJN/0ZydnJRTPxRVferm+/fP/1w7bgCAwAAAABQ4lwreejOruP02ZqJcja7qlVoT6VnpmrbwRUa1v0ltbyxh3749SN1ajxI/lVCtPz3OYpLOGF1pUJAlVrac2SDTp09IndXb7m7eOe7kqIktKjbXfWD22rawrs1dtAsubt6a+HaycrISlO/jo/m9fNy81HbBmH6dPWrOnJqt54f8qnV4x3Wfbzmrxwvk0xqeWMPZedk6VhsuA5H79JDYW+VeO6KhgIGAAAAAKBUjOo1Wd7uVbVkywzN+eFpebhWUZPaXSRJQ7q9oLjzJzR14RA5OZjVr+MYdWk6WKfOHs7bfnDXcToeG65H3m+mtIwUvTN6g5rV6VbiOU0mkyaOWqI5y57WhE/ClJmVrno12urNh9bI293Pqu+tre7Va58OVJ0bmqtWYBOrdcN7viIfr0At3TJTc5ePUyWzq4L8QnVr61ElnrkiooABAAAAACgVJpNJt9/0pG6/6cl869xcPPXisM+vun2gb229N2ZzsY75xfjj+do+ffFwvrZPnj9o9bWvV6BeHr6o0P13bDxAa962XHF9n3YPqk+7BwsPimJjDgwAAAAAAGDzuAIDAAAAAGAXvlw3TV+tn3bF9T9MTS7DNChrFDAAAAAAAHahb4fR6trsLqNjwCAUMHBFuxdLqQlGp8jlWllqPsjoFAAAoDQM2rVTR1MvGh1DklTb1U2LW7QyOka5ZkvnmEXBeaht8XLzkde/7lJSUfC6yUUBA1eUmiClnDM6BQAAKO+Opl7UgRQu+64oOMcEio/XTS4m8QQAAAAAADaPAgYAAAAAALB5FDAAAAAAAIDNo4ABAAAAAABsHpN4okRMXzRKa3Z+KklyMDnIxytQzet01wN93pCfd3WD0wEAAAAA7B1XYKDENKl1k75+JUYLXz6pl+7+UodP7dLkzwcbHQsAAAAAUA5QwECJcXJ0lo9XgPy8q6tp7S4Ka/ew/jzxm1LSEo2OBgAAAACwcxQwUCrOXjilzeHfysHBUQ4OjkbHAQAAAADYOebAQInZc3Sj+r3sIYslR+mZqZKkO7uMk6uzuyRp0md3qlXorQpr/7Ak6XD0Lk378m7NeWqXnM0uhuUGAAAAANg+u74CY8+ePRowYIC8vb3l5eWlgQMHKiYmRp6enho6dKjR8YrNYpFiL1z6OjvHuCzXon5wO815erc+fGKb7unxihqGdNB9vafkrR8z4AMtWv+GLqScVU5Ojj74/lE9PnAmxQsA+Je0RCn+pHQ+UspMMzoNAACA7bDbKzDWrVunvn37KiQkRBMmTJCrq6sWLFig2267TcnJyWrevLnREYvMYpG2HpU2HrAuYLy/SrqpnnRLQ8nJDkZhVDK7qrpfXUlSrYDGijl3RDOXjNUzg+dJkvy8q+uOLs/o/5Y/p/o12inIL1Qtb7zFyMgAYDMSoqVjv0vnjl1qc3CUAhpItTpIrt7GZQNsVc6evcp+7sWr9jH/tKKM0qAkbD2wQp+sHK/I0wfk4xWogZ2e0J1dnzE6Fgqw9+hmfbvpXR05tVunE05qVK/JuqfHBKNjVUgV6XVjlwWMM2fOaMiQIWrZsqXWrl0rV1dXSdKIESNUq1YtSbKbAobFIn23Q/olIv+65HRp5V7przjp4W6Ss539tEb0nKgH3mmgsPaPqF5wa0lS/46P6YmZ7bXnyAbNfGK7wQkBwDac/ksK/0GyXHblXU62dGqfdOaI1Hqo5O5rTD7AVpkaNpDToi/ytVtORip7wmty6NPbgFS4Vocid+i1BQM0uOuzGn/PVzp4cqs++H60Kjm7qV+H0UbHw2VS05MV4t9Q3VvcrdnLnjI6ToVV0V43djmE5K233tL58+c1f/78vOKFJHl7e6tly5aS7KeAse1owcWLfzscJ/2wu0zilKigqjeqQ4N+mr/q5bw2BwcH9W0/Wm3r91Flj6oGpgMA25B6QQpfnr948W+ZqdLuxVfvA1REJrNZJh8fq39yclL2+x/I1LSJHB55yOiIKIbvNr+nesFt9ECfNxTi30C92ozSwE5j9fWGN42OhgK0a9BHD/R5Q92aD5HZqZLRcSqsiva6scsCxqJFi3TTTTcpNDS0wPX+/v4KCAhQenq6HnroIdWuXVuenp4KDQ3Vhx9+WMZpr8xikTYdLFrf3w9LqRmlm6c0DO72nHZG/KQ9RzbmtZlMDjKZ7PKpBwAlLnqPZMkuvF9qgvXwEgD5WbKylD1pquTsLMeXX5LJ0Q7G4CLP/uNb1Lqe9VUzrev1Vtz5EzqTEGVQKsC2VbTXjZ0NSpBiY2MVHR2tIUOG5FuXk5Oj8PBwtWjRQpKUlZWlgIAA/fTTT6pdu7b27t2rXr16yd/fX3fddVeRjpeVlaXY2NgSfQz/OJfipFMJAUXqm5kt/Rwer4b+F0slS4HHzPSXZC5S3+eHLiiwvVHNjlrztqUEsmQqKiruuveDspV50VFSoCQpJiZG5gtF+JRWwZ1ONEvyz12Oi5Njaqaxga5TeXs8pSFqX4AkR0mmQvse/SNFaZXOl3omFIzfaaUnK7NkfjdkfzhLlhMn5DTjPzK5u11zlqio8nfSf7mkdOvnc3Klsns+X+kcMz4pRj6e1ufG/3wdnxSjqpWDyiJePmV9Hmrkz+Zyxfk8gOIp7vOqPL5uAgIC5ORUvJKE3RUwUlJSJEkmU/4TvaVLl+r06dN5w0fc3d01efLkvPXNmzdX//799csvvxS5gBEbG6vg4ODrD16AG+rdpMGvbC5y/xcnTNauVf8plSwFmTdun2oGNCqz411NRESEuj7S2OgYKCY/7+r6akLuSWDbtm109kK0wYlsX7XarTVsUu78MH379dXpozsMTnR9ytvjKQ0/TE2Ri3PhH7RyLDnasGaLXryrVxmkQkH4nVZ6nP5vtkw1Q65rH9nfLZZl7To5vjlNpsCi/YGoIBEREQruVv4nGffwqa4HZlx6PifHl93z2ZbOMYuirM9DjfzZXM7eflb2pLjPK3v7WRTl8UVGRiooqHgFFru7jj84OFiOjo7atGmTVfuJEyc0duxYSVee/yIzM1M///yzmjZtWtoxiyQjNbFU+9uqXm1GaeygmUbHAACbcDE9URZL4VeqmWRSSuqFQvsBFVHOtu3KmfdfOT45Vg5N+IOHvfLxDFR8kvWVz+eT4/LWAcivor1u7O4KDGdnZ40cOVLz58/XgAEDFBYWpsjISM2bN0/+/v6Kjo6+YgHj8ccfl6enp0aOHFnk4wUEBCgyMrKE0luzWKR5W7OUmF74pcMmk0XffTJZ7s6vl0qWghxd4a8MG6mZhIaGltrPAaUn86KjjizLXd62bbvMblxuXZiYRLMW7spdXv7DcgV62feQi/L2eEpD7A4PJRwufPiIyWTSkEe66+E3+F1oFH6nlZ5eRyL0V0b6NW1rOX5C2dPeksOdt8vh1p7XnSU0NFSrK8A5R1K6o+b+nru8bdt2eZbhMIUrnWM2qtlJOw6t1oier+a17Ti4Sv5VQgy7DF4q+/NQI382l7OlzwPlTXGfV+XxdRMQUPyr5eyugCFJM2bMkNls1tKlS7V+/Xp16NBBixcv1qRJk3T48OECJ/d85pln9Ntvv2n9+vVydnYu8rGcnJyKfVlLcXRLkpbtKrxf8xom1at9Q6nlKEikWbKVeUPNZnOp/hxQOtKSpCN/LwcGBsrF09A4diH73KXlav7+CrLz22aWt8dTGipXyp2ouTBmV6lBe1852OU7d/nA77TS43TymHQNBQzLhQvKevV1merUlsOgAbLEx+fv5O1drMk8nSrIOUfCv6ZVCwwMVOVrmzLkmlzpHPOOLk/ryZkd9cnKl9Wj1QgdPLlVS7Z8qNH93y+7cAUo6/NQI382l7va54HU9GRFn819A8vMzlB8UqwOR++WayUPVferW3Yh7VRxn1e8bnLZ5WmQh4eH5s6dq7lz51q179u3T02aNJGDg/XImKeeekrr1q3T+vXr5efnV5ZRC9W1fu5tUv88deU+VT2lO1qXXSYAQNnxqCrd2E36a+OV+zg4Sk37i+IFcBnL1u1SbKwssbHKGjaiwD5On82XAvzLOBmuRb3gNnp91BJ9snK8vt30jqp4Bui+3lPVr8Noo6OhABFRO/TsnJvzvl726ywt+3WWmtbuqncf3WhcsAqmor1uys2pUEJCgqKiohQWFmbV/sQTT2j9+vXasGGDqlatalC6K3N0kO7vIq3YK/36l5SWab2ueQ1pUCvJw8W4jACA0hXSWqrkLh3Zknu71H+rXD23wOFd/oaxAtfN4dYecri1h9ExUILaNQhTuwZhhXeE4ZrV6VYidxvE9atIr5tyU8AIDw+XZD2B54kTJ/Thhx+qUqVKqlWrVl77TTfdpJUrV5Z1xCtycpT6t5B6NZEOnJKSUiUXs1T/BsnTRgsXK7Z+rNXbP5HJ5KAnb5+tWoFN8ta987/7dercEaVlpKhHy+G6/aandDx2v/7z3SNyMDnI0cFJzwz+WIG+tfXr/mX6eMULOpMQqR+mJhv4iADAWAENJP/6UtRu6dC63LZGfaTAhobGAgAAsBnluoAREhJSpJndbUUlp9wrLmxd4sV4Lf9ttmaM/V0x545qxveP6u3R6/PWP3n7HJmdnJWdnaX732mgPu0elrdHVU29/0e5u3pr+8FV+mLtZD03ZL4a1+ykOU/t0uj3mxv3gADARphMkte/5rNyq2JcFgAAAFtjd7dRvZIxY8bIYrGoffv2Rkcp9w6d3KamdbrJydGs4Gr1dCHlrHJycvLWm51yJ0nNyEpTQJVacnZyURWPanJ39ZYkOTqa5eCQO5mWl7uvnM02epkJAAAAAMBmlJsCBspOUmq8PF0v/VnQtZKnUtIuWPWZ+sVQ3ftmXTWq2dFqUtX0zFR99tNrur3zk2WWFwAAAABg/yhgoNg8XKso+V+zzKWmJ8ndxduqz8vDF+nz8ce0/eBKnYj7U5KUnZ2lNxbercFdn7WaMwMAAAAAgMJQwECx1a/RTuHHNis7O0vRZw/L293P6iqLjKzc+7g7O7mokrObnM2uslgsevebB9WqXi91ajzQoOQAAAAAAHtVbibxRNnxcvPRbW0f1DOzu8hkctDYQbO0/eAqJaXGq3uLuzXhv2HKzslSZla6ujQdrECfWtp+cJU27/2f4s4f18bdi1TnhuYaM+A/OnByq+avfFlnEiL1/NweurPrOLWtf5vRDxEAAAAAYGMoYOCahLV/WGHtH877us4NzfKWpz+yNl//NvV7a/m0i/naG9RoV2B/AAAAAAD+jSEkAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHnMgYErcq1sdIJLbCkLAAAoWbVd3YyOkMeWsgBG4xy89PC9vTYUMHBFzQcZnQAAAFQEi1u0MjoCgALweQC2hiEkAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACb52R0gPJm92IpNcHoFJJrZan5oOvbx7yN0rnkkkhz/Xw9pIe6GZ0CAGDPrvc92pJzafmP/0mm6/gzUEm8T6Niu97ztOx/PZ9nrZUcr+P5zHkagLJCAaOEpSZIKeeMTlEyziVLsReMTgEAQMkoyffoi+dLZj/AtSrJ87QzSSWzHwAobQwhAQAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGwek3gaZPqiUVqz81NJkoPJQT5egWpep7se6POG/LyrG5wOAAAAAADbwhUYBmpS6yZ9/UqMFr58Ui/d/aUOn9qlyZ8PNjoWAAAAAAA2hyswDOTk6CwfrwBJkp93dYW1e1izlj6hlLREubt4GZwOAAAAAFCe2PtIAK7AsBFnL5zS5vBv5eDgKAcHR6PjAAAAAADKIXseCcAVGAbac3Sj+r3sIYslR+mZqZKkO7uMk6uzuyRp0md3qlXorQpr/7Ak6XD0Lk378m7NeWqXnM0uhuUGAAAAANgnex4JYNdXYOzZs0cDBgyQt7e3vLy8NHDgQMXExMjT01NDhw41Ol6h6ge305ynd+vDJ7bpnh6vqGFIB93Xe0re+jEDPtCi9W/oQspZ5eTk6IPvH9XjA2dSvAAAAAAAXDd7Gwlgt1dgrFu3Tn379lVISIgmTJggV1dXLViwQLfddpuSk5PVvHlzoyMWqpLZVdX96kqSagU0Vsy5I5q5ZKyeGTxPUm417I4uz+j/lj+n+jXaKcgvVC1vvMXIyEWWlZGq7Uun6dDvi5QcHyUnZ1d5V6ujBp1HqHmvJ4yOBwBAkU1fNEpnL0Rp+iNr863r+ZxJLwz9XD1aDTcgGVB8FotFS6ffpoy0RN35ys9WH1hOH/tDX09sr95jFurGdvZxOXl5k3BR2nDg0tdLdkpd60s1/SSTybhcKF8KGwnwS/hifb7mdattTp7+U2P6f6AOjfrriZkdNOvJHariUU1pGRf1yPvNNHHk96oV2KTUs9tlAePMmTMaMmSIWrZsqbVr18rV1VWSNGLECNWqVUuS7KKAcbkRPSfqgXcaKKz9I6oX3FqS1L/jY3piZnvtObJBM5/YbnDCols//1FF/blBXUd8IL8azZSRmqgzJ3Yp6dxJo6MBAABUWCaTST0fnq+F45tqx7I31HbgBEm5f3xaPXu46nW8h+KFASwWae1+acXe3OV/7D6Z+y80QBp1k+TmbFxGlB/1g9vp+aGfKiMrTZv2/E+7/lprNRKgc5NB6txkUN7XW/Yt0Scrx6tn63vl4uymO7s8o7nLntGLd3+hz3+aqM6NBpVJ8UKy0yEkb731ls6fP6/58+fnFS8kydvbWy1btpRknwWMoKo3qkODfpq/6uW8NgcHB/VtP1pt6/dRZY+qBqYrniM7l6hV2HOq03qgvKvVUtWQZmrYZZTaDXrV6GgAAAAVmnuVQN3ywDxtXTxJcUd3SJJ+WfSCsrPS1W3kDIPTVUzr/pR+3GNdvPi3iFjp/zZIWdllmwvl0z8jAWoFNNaoXpMU4FNLM5eMLbDvmYQofbj4Mb18zyK5OLtJkgZ0Gqvjcfv1/c8f6Jd932v4ra+VWXa7LGAsWrRIN910k0JDQwtc7+/vr4CA3ElJxowZo+DgYHl5eal69ep66qmnlJGRUZZxi2Vwt+e0M+In7TmyMa/NZHKQyWRfPyr3yoE6vneV0pLjjY4CAACAy9RpPVANu4zS6tnDdXTnMoWvm6Nej34hZ1dPo6NVOCnp0qq9hfc7flb640Tp50HFM6LnRK3eMV+HIndYtefk5OjNr4Zr6M0vqvYNTfPaHR0c9Wj/9zV72VN6KOztvKEnZcHuhpDExsYqOjpaQ4YMybcuJydH4eHhatGiRV7b448/rrffflvu7u46e/asBg8erGnTpmnixIlFOl5WVpZiY2OLnC8z01+SudB+zw9dUGB7o5odtebtK5ReiyEzM1NRUXHXuY+iPZaC9HjwY62adbf+79Gq8glqpMC67VWzWR/VbjVApmsYwFcSjwdlL/Oio6RASVJMTIzMF/izQWFOJ5ol+ecux8XJMTXT2EDXqbw9nrKQeu5f37PTcUrK5ntWUq7nfe2f8cIll4X3NVyf63k+/6PLPe/rywkttPw/g9R24CsKvLHDNWYp3vO5JLKXpdJ+vW6P9FBWTuUi9LRow74M3eB8ptSywHaV5uvm3yMB3nxodV77wnVT5ObipYGd81+dse3ACvl4BepYbLjVcJNLeQt/3QQEBMjJqXglCbsrYKSkpEhSgR+Cly5dqtOnT1sNH2nYsGHessVikYODg/76668iHy82NlbBwcFF7j9v3D7VDGhU5P6lJSIiQl0faXxd+xj+5j75Bl3bY7khtJNGvXdEsUe2Kfbwb4o+uFk/zrhTNZvdpn7PLCt2ESMiIkLBt1/f40HZ8/Ourq8mREmS2rZto7MXog1OZPuq1W6tYZNy57vp26+vTh/dUcgWtq28PZ6yEBrUWrOe/Pt71revIqL4npWU63mP/me88OVGvXXjNe2vJN6nUbFdz3naP8wu7moV9pzWz380by6Ma1Hc8zRbOV8uqtJ+vfZ+7EvV6zCsCD1Nik5wLNZnE5Qfpf26GdztOT01q5P2HNmoZnW6ad+xLVq17b+a/dQf+foeiwnXlv1LNOuJ7XpyZkf1aDlcgb61rfoU5XUTGRmpoKCgYuW0uwJGcHCwHB0dtWnTJqv2EydOaOzY3MrQ5fNfvPnmm5oyZYpSUlLk6+urN998s6zilohebUapV5tRRscoNgdHJ90Q2lE3hHZUyz7jdPCXL7R6zghFH9ysoAZdjY4HAECR/fvOYUB54uBo/vt/u/tYUG6YinHrSpPJIfd2JFeaLAMoRFFGAiSnJuitRSP03JAF8nL3tepnsVj0n+9G69H+78vPu7ru7TVJM5eM1dQHfizt6JLssIDh7OyskSNHav78+RowYIDCwsIUGRmpefPmyd/fX9HR0fkKGC+++KJefPFFHThwQAsXLlRgYGCRjxcQEKDIyMgi9z+6wl8ZiUXuXmpCQ0OLlbsg87f769zFEgokqUr1BpKk1MTTxd62JB4Pyl7mRUcdWZa7vG3bdpndGEJSmJhEsxbuyl1e/sNyBXrZ9/CB8vZ4ykLqObNOrMldXr58uVx9+Z6VFFt5j5Z4X8P1K+nztOtR3OezLb0Wi6K0X69bjnvptyLNbWGRr3u2Ik9yV7+KqCxfNz/8NlvxiTGavexpq/ZbW98r10oequLpr3YNwvLaVm3/RD+Hf6+bmtye17cor5t/5q0sDrsrYEjSjBkzZDabtXTpUq1fv14dOnTQ4sWLNWnSJB0+fPiKk3s2aNBAzZo104gRI7Rhw4YiHcvJyalYl7VEmiVbmCLUbDYX+3KcfPvYfe3bfjulq0I7DJN/rdZy9aqqhNjD+vWb8arkVllBDW8ufpYSeDwoe2lJ0pG/lwMDA+XCvGCFyj53abmav7+CfK/c1x6Ut8dTFi44Sv+cx1ar5i/votfcUQhbeY+WeF/D9bue87SSVtznsy29FouitF+vt1aRfj8hFX5NhUldG/K7o6Iqy9fNsO4vaVj3l664vk+7h6y+fu/RTfn6lNbrxi4LGB4eHpo7d67mzp1r1b5v3z41adJEDg5XvmNHZmamIiIiSjtihRfS9DYd2rJQv3/3qjJSE+XqVU3V63VRz4fny9XTz+h4AAAAgE2o4i51vFHaUsg0fb4eUtvaV+8DlHd2WcAoSEJCgqKiohQWFpbXduHCBS1evFgDBw6Ut7e3wsPDNWXKFPXq1cvApBVDm/4vqk3/F42OAQDAdbvSeGFJJXLnMMBIDbuMUsMuo4yOUeHd3lpKz5R2HC94vZ+HNLq75OpcprEAm1NuChjh4eGSrCfwNJlM+uKLL/TMM88oIyND1apV0+23367XX3/doJQAAAAAYM3RQbqno9ShrvRzhHT0jJSdk1u46HCj1DJEci43n9yAa1duXgYFFTC8vLy0du1agxJdXdSZCD34TiO9N+ZnNQxpn9cec+6o3v3mAWVmZahz40Ea3O1ZSVLf8W6qF9xWkjSo85MF3msXAAAAgH0ymaQ6/rn/ABSs3BQwxowZozFjxhgdo8i+WDtZTWvnv5XovBUv6P7e09QgpL3Gzemmzk3vUKBPLVWrXEPvPrqx7IMCAAAAAGADrjzbJUrNgZNb5eMZID/v/LOyRsYdUMOaHWQymdSufpjCj26WJJ1LPKVnZnfV1C+G6nxy8W9DCgAAAACAPaOAYYAv103V0JsLnuAyx5KTt+zpVkVJF+MlSZ+9dFTvPbpJHRr119wfxpVJTgAAAAAAbAUFjDK29cCPCg1qLS933wLXm0ymvOXk1AR5uvlIkrzdc2892rXpXToSvav0gwIAAAAAYEMoYJSxw6d2a++RjXppXm/98dcazVn2tM4lxuStr+HfUAdPbpPFYtG2gyvUpNZNSs1IUXZOtiRp77HNusGvrlHxAQAAAAAwRLmZxNNe3HPLy7rnlpclSdMXjVLfDqN19NQe7TmyQd1b3K0HbntD733zoLKyM9Wx0QAF+tZWRNROvf/tQ3J19pCjo1lP3THX4EcBAAAAAEDZooBhoOeHLsjXVt2vbr67jYQGtdLsp/4om1AAAAAAANgghpAAAAAAAACbRwEDAAAAAADYPAoYAAAAAADA5jEHRglzrXx921typIvnc5fdqkimaywxXW8OSfL1uP59lBRbygIAsE8l8d5YUmwpC+yTLZ0b2VIWAOUbBYwS1nzQ9W2fliT98vdNRlreJbl4Xn+ma/VQN+OODQBASbve92jAlnCeBqAiYggJAAAAAACweRQwAAAAAACoII7H7tdTszrrmY+66Lk53RVz7qjV+s9+mqh7pobopXm989rSMi7qiQ87aOArlbVh96KyjpyHAgYAAAAAABWEt0dVTb3/R703ZrPu6va8vlg72Wp9WPtH9M7oDVZtZqdKmnjvYt1+01NlmDQ/ChgAAAAAAFQQVTyqyd3VW5Lk6GiWg4Oj1Xpfr0CZLrubhKODo3y8Asos45VQwAAAAAAAoIJJz0zVZz+9pts7P2l0lCKjgAEAAAAAQAWSnZ2lNxbercFdn1WtwCZGxykyChgAAAAAAFQQFotF737zoFrV66VOjQcaHadYnIwOAAAAAAAAysaOQ6u1ee//FHf+uDbuXqQ6NzRXm3q9lZQar+4t7taPv/+f1uz8TJGnD+r5uT30/NDP5Od9g17/9A4dPrVLLs7uOnhyqx7t/36ZZ6eAAQAAAABABdGmfm8tn3bxiuvD2j+ssPYP52t/7d7vSjNWkTCEBAAAAAAA2DwKGAAAAAAAwOZRwAAAAAAAADaPAgYAAAAAALB5FDAAAAAAAIDNo4ABAAAAAABsHrdRxRXN2yidSzY6RS5fD+mhbte3j0G7dupo6pVvF1RWaru6aXGLVkbHAACbtnuxlJpgdAr74lpZaj7I6BTXprydcwAASgcFDFzRuWQp9oLRKUrO0dSLOpBiI2dHAICrSk2QUs4ZnQJlpbydcwAASgdDSAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPAoYAAAAVzFudje9+82D+dpj44+r53Mm7Tv2iwGpAACoeChgAAAAAAAAm0cBAwAAAAAA2DwKGAAAAAAAwObZdQFjz549GjBggLy9veXl5aWBAwcqJiZGnp6eGjp0qNHxAAAAAABACXEyOsC1Wrdunfr27auQkBBNmDBBrq6uWrBggW677TYlJyerefPmRkes0LIyUrV96TQd+n2RkuOj5OTsKu9qddSg8wg17/WE0fGKzGKxKPuF8VJWlhzfeUsmh0s1v6zXJklnz8rxg/dkcrLblxIAAHbrp7mjlBwfpdtfWptv3QfDTeo1+nPV7zzcgGQAUHb2Ht2sbze9qyOndut0wkmN6jVZ9/SYYHSsUmGXn7rOnDmjIUOGqGXLllq7dq1cXV0lSSNGjFCtWrUkiQKGwdbPf1RRf25Q1xEfyK9GM2WkJurMiV1KOnfS6GjFYjKZ5PjcOGWNHqOcr7+R47AhkqTs5Stk+WOXnGbNoHgBAOWcu4u3UtIu5GtPTk2QJJmdXMo4EQAAl6SmJyvEv6G6t7hbs5c9ZXScUmWXn7zeeustnT9/XvPnz88rXkiSt7e3WrZsqXXr1lHAMNiRnUvU8c4pqtN6YF5b1ZBmxgW6DqaqfnIc+5iyp78rhzatpUqVlDN3nhweul+mGsFGxwMAlLLgavW1ee83ys7JlqODY177ochtcnBwVHW/ugamAwBUdO0a9FG7Bn0kSR+veMHgNKXLLufAWLRokW666SaFhoYWuN7f318BAQFWbampqapbt648PDzKImKF5145UMf3rlJacrzRUUqEQ7euMnW5SVlvTlf2m9NlatJYjv37GR0LAFAG+ncco4SkOL3z9X2KiNqpU2ePaP2ur7Rg9Svq1fo+ebhWNjoiAAAVgt1dgREbG6vo6GgNGTIk37qcnByFh4erRYsW+da9+uqrCgkJUWxsbLGOl5WVVextrkfmRUdJgZKkmJgYmS9kl9mx82XJ9JdkvqZtezz4sVbNulv/92hV+QQ1UmDd9qrZrI9qtxogk8l0DVkyFRUVd01Z/pGVmXld2zs+/qiyho2QxcFBTpMnXleOqKio68piL2zp+WwvTieaJfnnLsfFyTH1+p63Ritvj6cspJ771/fsdJySsivm9+x63oNKmn+VEP3n8V+1YNUEvTK/ny6mXlCAb23d1fU5DbrpSaPj5SmJ90qjXM/PO+rARn30QMn9gcqev4/2wpZe30XBcwK2oDy+bgICAuRUzOH4dlfASElJkaQCPwQvXbpUp0+fzjd8ZOfOnVq1apXeffdd3X777cU6XmxsrIKDy26YgJ93dX01IffDbdu2bXT2QnSZHftyw9/cJ9+gRte07Q2hnTTqvSOKPbJNsYd/U/TBzfpxxp2q2ew29XtmWbGLGBEREQq+vfE1ZfmH0//NlqlmyDVvn7NuQ+5Cerosfx2WqV3ba9pPRESEgrvdcs057IktPZ/tRbXarTVs0nZJUt9+fXX66A6DE12f8vZ4ykJoUGvNevLv71nfvoqIqpjfs3nj9qlmwLW9B5WGOjc00+T7fzA6xlVFRESo6yPX915plOs55wio0063PvJpvvZPn73xmvZXEuccuDpbe30Xxp5fWyg/yuPrJjIyUkFBQcXar90VMIKDg+Xo6KhNmzZZtZ84cUJjx46VZD2BZ1ZWlh566CHNmjVLOTk5ZRm1wnNwdNINoR11Q2hHtewzTgd/+UKr54xQ9MHNCmrQ1eh4xWI5eVI5H38ix0cfkeXESWW//4FMcz+Sydvb6GgAAFRoTs6uqhzAPCQV0fRFo7RmZ27xysHkIB+vQDWv010P9HlDft7VDU4HoDTYXQHD2dlZI0eO1Pz58zVgwACFhYUpMjJS8+bNk7+/v6Kjo60KGG+//bZatGihLl26aOPGjcU+XkBAgCIjI0vuARQi86KjjizLXd62bbvMbsZdcj9/u7/OXSy5/VWp3kCSlJp4utjbhoaGXvfPodeRCP2VkV7s7SxZWcp68x2ZWjSXQ5/esmRkKOePXcr+4EM5vVr82xOFhoZqdRk+p4xkS89nexGTaNbCXbnLy39YrkAv+x4+UN4eT1lIPWfWiTW5y8uXL5erb8X8nh1d4a+MRKNT2JeSeK80Skmfc1wPe/4+2ouSfH03qXWTJgz/n3Is2Tp17og+XPyYJn8+WB88/mvJHEA8J2Ab7O19sSivm8vnrSwKuytgSNKMGTNkNpu1dOlSrV+/Xh06dNDixYs1adIkHT58OG9yz8OHD2vOnDnatWvXNR/Lycmp2Je1XI+0JOnI38uBgYFy8SyzQ+dj3n3t2347patCOwyTf63WcvWqqoTYw/r1m/Gq5FZZQQ1vLn4Ws/m6fw5OJ49J11DAyPn0c+nsWTlOnSRJMjk7y+nFZ5U19mnlrFknh57FGw7iVAKPxV7Y0vPZXmSfu7Rczd9fQb7GZSkJ5e3xlIULjtKJv5erVfOXd6ChcQwTaZYyjA5hZ0rivdIo13POUdLs+ftoL0ry9e3k6Cwfr9wPQX7e1RXW7mHNWvqEUtIS5e7iVSLH4DkBW3C1101qerKizx6WJGVmZyg+KVaHo3fLtZKHYXfKKq3XjV0WMDw8PDR37lzNnTvXqn3fvn1q0qSJHBxyb67yyy+/KC4uLq+gkZmZqZSUFPn5+en7779Xly5dyjx7RRHS9DYd2rJQv3/3qjJSE+XqVU3V63VRz4fny9XTz+h4RZazb79yvvlOjq+9IlOVynntpjp15DDiHmV/NEemZk1kqlbNuJAAAADQ2QuntDn8Wzk4OMrhX7c8Bsq7iKgdenbOpT8SL/t1lpb9OktNa3fVu49uNC5YKbDLAkZBEhISFBUVpbCwsLy2u+66Sz169Mj7+rffftOoUaO0e/duVa1a1YiYFUab/i+qTf8XjY5x3RwaN5LDquUFrnMcNkSOw/LfDQcAAJSNWx9ZcMV1T35hKbsgMMyeoxvV72UPWSw5Ss9MlSTd2WWcXJ3dJUm/hC/W52tet9rm5Ok/Nab/B+rQqL+emNlBs57coSoe1ZSWcVGPvN9ME0d+r1qBTcr8sQDXqlmdblrzdsX4nVduChjh4eGSrCfwdHNzk5ubW97XVatWlclk4hIwAADsTGz8cb3x5d1ydDQrOztLT94+W7VvaGrVJ+bcUb37zQPKzMpQ58aDNLjbs5KkvuPdVC84985Rgzo/qc5NBl3xOOP/20dpGSlKz7ioO7uO083Nh1ofI/6Y3l50r0wmB5mdKmnC8K/l4VpZ7/zvfp06d0RpGSnq0XK4br/pqSseY8mWmdq052vl5OToBt86evauT+ToaH1K9uHix/VX1E7lWLJ1762T1KZ+77x1q7bP14ffj9GPb6QW6XsHlGf1g9vp+aGfKiMrTZv2/E+7/lqr+3pPyVvfuckgq9f8ln1L9MnK8erZ+l65OLvpzi7PaO6yZ/Ti3V/o858mqnOjQRQvABtWrgsYl+vWrZuSk5PLKBEAACgpVb2D9P6YX+Tg4KBdh9frq/XT9PLwRVZ95q14Qff3nqYGIe01bk43dW56hwJ9aqla5RpFvoT29XuXyOzkrJS0RI35oFW+Asby3+botnYPqWerEVq04S2t2fmZBnV+Qk/ePkdmJ2dlZ2fp/ncaqE+7h+Xi7FbgMcLaPayBnR6XJL311Uj98ddaqwLFibgDOnn6gGaM/U3xibGa8ElY3vqMzDT9Ev6dqlWpUdRvHVCuVTK75o3xrxXQWDHnjmjmkrF6ZvC8fH3PJETpw8WPadoDK/NenwM6jdVjH7TW9z9/oF/2fa85z+wp0/wAisfB6AAlZcyYMbJYLGrfvr3RUQAAQAlzdHTKm+PqYlqiat/QLF+fyLgDalizg0wmk9rVD1P40c2SpHOJp/TM7K6a+sVQnU+++p2wzE7OkqS0jBTV9G+Ub33NgMZKSU2QJKWkJsjbvarVdhlZaQqoUkvOTi6FHsNiscgii264bII1X69AOTu5KDs7S8lpCfJyvzR31OJfZqhv+9EyyXTVxwFUVCN6TtTqHfN1KHKHVXtOTo7e/Gq4ht78otXVW44Ojnq0//uavewpPRT2dt7QEwC2qdwUMAAAQPl2OHq3nviwg2YueVwt6ua/A1SOJSdv2dOtipIuxkuSPnvpqN57dJM6NOqvuT+MK/Q4z8zuqkfea6p2DfrmW9esTjct/32OHnq3iXZErFanxgPz1k39YqjufbOuGtXsmFdsuZJF69/UfdPrKelivHy9brBa5+7irQCfWho1PVTPzu6moTfnzimVdPG8wo9tVvuG+XMByBVU9UZ1aNBP81e9bNW+cN0Uubl4aWDnsfm22XZghXy8AnUsNrysYgK4RhQwAACAXahbvblmjP1Nk0Yt08wlj+dbbzJduiohOTVBnm4+kiTvv69g6Nr0Lh2JLvzW6u89uknzn4/Q1xveVErqBat1H//4gu6/7Q3NGxeuwV2f039XvJS37uXhi/T5+GPafnClTsT9edVjDO3+ouY/f0g3+NXVTzsWWK3bGbFG55Ni9ekLh/Xxc3/qo6VPKjs7S4vWv6G7uj1faH6gohvc7TntjPhJe45slCTtO7ZFq7b9V8/dNT9f32Mx4dqyf4lmPbFdq7b9VzHnjpZxWgDFQQEDAADYvIys9LxldxdvVTLnn1+ihn9DHTy5TRaLRdsOrlCTWjcpNSNF2TnZkqS9xzbnDde4mJak5L+HgvwjOydb2dlZkqRKzm5ydnKR2Ww9FMQiS15BpLJHNSVePGeVz9nJJXdbs6sk6fT5k1d8LCaTSe4u3nl9/30MTzcfOTg4yK2SpzKz05Wdk6WosxH6at00vTSvt85ciNKbX40owncOKL+eH7pA0x9Zm6+9Uc2OWvO2Rc3qdFNyaoLeWjRCzw1ZIC93X6t+FotF//lutB7t/778vKvr3l6TNHNJ/is0ANiOcjOJJwAAKL/2H9+iz3+aKAcHR1ksFo3u954kafvBVUpKjVf3Fnfrgdve0HvfPKis7Ex1bDRAgb61FRG1U+9/+5BcnT3k6GjWU3fMlSRt3LNI6ZmpGtT5ibxjpKQmaOJnt8skk7KyMzS0+0tydqqk+MRYfbf5PT3Ud7ruuWWCPvh+tBxMjsrOydLTd/6fJGnCf8OUnZOlzKx0dWk6WIE+tZSVnanXPh2o2U/9YfVY5q98WRFRO2Sx5CjAp5buuWWCJOmjpU9peM9X1fLGHtqw6ys9/dFNyshM08BOT8jZ7KLXRy3J28f90+vrxWGfl+a3HCgXfvhttuITYzR72dNW7be2vleulTxUxdNf7RqE5bWt2v6Jfg7/Xjc1ud2IuAAKQQEDAADYvBZ1u6tF3e752v99947qfnXz3W0kNKhVvgKCJB2L3ZdXOPiHl7uv3nt0U76+Pl4BeqjvdElSzYBGen/Mz/n6FPRX4IMnt6lXm/vztT/S7518bZI0ZsB/8pafH7qgwD7/+OT5g1ddDyDXsO4vaVj3l664vk+7h6y+Luh3AADbQQEDAABUOI8N+KDUj9G4Vic1rtWp1I8DAEBFwRwYAAAAAADA5lHAAAAAAAAANo8hJLgiXw+jE1xSEllqu+afsd4ItpIDAGyZa2WjE9gfe/6elbdzDgAoafb2O7608lLAwBU91M3oBCVrcYtWRkcAABRR80FGJ0BZKm/nHABQ0nhfzMUQEgAAAAAAYPMoYAAAAAAAAJtHAQOA4f7v//5P3bp1y/sXGBiol19++Yrt/7ZlyxZNnTrVqi0iIkJms1m///57vmO5ubnl7W/x4sVX3S4+Pl7Dhw8v4UcLAAAA4FowBwYAwz388MN6+OGHJUlHjhzRwIED9eyzz6pKlSoFtv/bW2+9pfnz51u1TZ48WV27di3wWDVq1NDGjRsLXHf5dj4+PvL29ta+ffvUuHHja314AAAAAEoAV2AAsBmZmZkaPny4Zs+erSpVqhTanpiYqAsXLsjX1zevbevWrQoICFBQUFCBxzh16pS6du2qoUOH6vTp04Vud9ttt+nbb78tqYcIAAAA4BpRwABgM1588UWFhYWpc+fORWo/dOiQatWqZdU2depUvfjii1c8xtGjR7Vp0yb1799f48aNK3S7OnXqKDw8/FoeDgAAAIASxBASADZhxYoV2rNnj3766acitRfkxx9/VOvWra2uyLicn5+fJOmuu+7StGnTirwdAAAAAGNRwABguJiYGD333HNau3atHBwcCm3/R2hoqI4ePZr39e7du7Vx40b9+uuvCg8P16FDh/T9998rMDBQkpSSkiIXFxc5Ojpq8+bNqlu3bqHbHTlyhPkvAAAAABtAAQOA4aZMmaLExEQNGzYsr6179+6Ki4srsP3VV1+VJHl7e8vb21vnzp2Tr6+vXn755by7lIwaNUqjR4/OK16MHDlSTz75pB566CF5eHjIbDZr7ty5knTV7VauXKnRo0eX/jcBAAAAwFVRwABguFmzZmnWrFlXXHc1L7zwgubMmZPv9qoLFiyw+vqzzz6TJP3xxx9X3d+/t4uPj9eFCxfUpEmTq24DAAAAoPRRwABg1zp37pxvcs+S4uPjoy+++KJU9g0AAACgeLgLCQAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzmMQTAADYnKz5m2U5l2R0DLti8vWU031dSnSfuxdLqQklukv8zbWy1HyQ0SkAwL5QwAAAADbHci5Jiks0OoZdsZTCPlMTpJRzpbBjAACuAUNIAAAAAACAzaOAAQAAAAAAbB4FDAAAAAAAYPMoYAAAAAAAAJtHAQMAAOAyPRZN1iOr/y9f+/ELZ+T8zt3aEnXQgFQAAFRsFDAAAAAAAIDNo4ABAAAAAABsHgUMAAAAAABg88p1ASM+Pl7PPvus6tatKxcXF1WtWlU333yzfv75Z6OjAQCAcqD7oklq/elLajb/OT225r/KzskxOhIAAOWWk9EBSsuJEyfUrVs3JScn64EHHlBoaKguXLigvXv3Kjo62uh4AACgHFgy6Fl5VXKTxWLRkGX/0bcRv2tI/Y5GxwIAoFwqtwWM4cOHKysrS3v37lVgYKDRcQqVkyOdPSJFh19qi/1TCm4hOToblwu4Vomx0okdl74+sV0KaSO5eBqXCWUnJ0f685S06dCltj0nJX8vycVsXC6gqLwquelC+sV87QnpKZIkFyfnvH6SlJWTrYzsLJlkKruQBtp6YIU+WTlekacPyMcrUAM7PaE7uz5jdCwAQDlXLgsYmzdv1i+//KIZM2YoMDBQmZmZyszMlJubm9HRCpR8VtqzWEq9YN1++Gfp+FapcV/Jr7Yx2YDiysqQ9i2Xzh61bo/8Q4rcJdXuINXqIJkqxjl+hXQ6UZq3UTqTZN2+/k9pS4Q0opPUOMiQaECR1fO5Qd9H/K7snBw5Olwacbsj5ogcTQ6qU9k/r63n11O0+/Rx9a7VXHeEtjMibpk6FLlDry0YoMFdn9X4e77SwZNb9cH3o1XJ2U39Oow2Oh4AoBwrl3NgrFixQpJUo0YN9evXT66urnJ3d1doaKi++OILg9NZS70g7fw6f/HiH1kZ0p4lUvzJMo0FXJOc7Nxi3OXFizwW6eiv0rHfyzQWylDCRWnmmvzFi3+kZ0n/3SwdiinbXEBxjW7eQ3EpiXpw1Rz9EXtURxLitOjAr5q45Rvd27irKru45/VdM2SCTo7+SKlZGdpwcr+BqcvGd5vfU73gNnqgzxsK8W+gXm1GaWCnsfp6w5tGRwMAlHPlsoBx6FDuNcsPPfSQ4uPj9emnn+qTTz6Rs7OzRowYofnz5xuc8JLjW6XM1Kv3seRIf22ULJYyiQRcszOHpfORhfc79pv091XYKGfW7ZcS067ex2KRFu/kdxpsW4h3VW26e6LOp6Vo0OJ31GrBi3pr61I906avPuxxX77+rmZn9a/bWj8c3lHA3sqX/ce3qHW93lZtrev1Vtz5EzqTEGVQKgBARVAuh5AkJeX+6c/T01MbNmyQs3PuONWBAweqdu3aGj9+vO699145OBRev8nKylJsbGyp5MzOMOnU/kBJpr//XVnSaenw3ji5+maWShagJJzc6iepkgp7PltypAO/XJBfoyv8mb4CO51olpR7afrpuDg5ptrPaz4j26TfjxTtd1rsBWnr/tMKqpxRJtnsSeq5fz0HTscpKdt+ngMlyTczy/CTlGbVQrTk9ueuuP5C+kVlZGepqpuXsnKyteLoH+oa3LAME1rLysxSXFTJFhAyM/0lWU9cE58UIx/PAKu2f76OT4pR1cqMESuKzMxMRUXFGR3DEAU9r2xZRf5ZAaUpICBATk7Fe7c3+tygVLi6ukqShg0blle8kKQqVaqof//++uyzz3To0CE1aNCg0H3FxsYqODi4VHI2qNFOM8YW/Vr6Z8dM0rJfPyqVLEBJ+GFqslycC5/cwmKxaMlX6/X6p7eXQSr7Uq12aw2btF2S1LdfX50+aj9/za1as4XunvJHkfuPef5N7Vr5fikmsk+hQa0168m/nwN9+yoiyn6eAyVp96jpauhn2x+EE9JSNGTZf5SRnaVsS456hDTRQ81uMSxPRESEmgcPLNF9zhu3TzUDGpXoPpErIiJCXR9pbHQMQ5Tk8yo2/rje+PJuOTqalZ2dpSdvn63aNzTNWx9z7qje/eYBZWZlqHPjQRrc7VlJUkTUTv13xUvKzslUo5qddF/vKVc8RkX+WQGlKTIyUkFBxXuvL5cFjH++CQEBAfnW/XNHkvPnz5dppoI4ODgWr7+peP2Bslac56gjz+dyp7i/00zF7A/YmhDvqvp9xFSjY5Q5H89AxSdZX516Pjkubx1Qlqp6B+n9Mb/IwcFBuw6v11frp+nl4Yvy1s9b8YLu7z1NDULaa9ycburc9A75eVXX/JUva+K938u1koeB6QEUV7ksYLRt21Zz5sxRVAGXUf7TVq1atSLtKyAgQJGRRRjUfw2y0hx0eKlFshTtdgxvvv+KPgx8vlSyACXh2CoHpSdYVNjwAZPJpLA7btZ9k0vntWXPYhLNWrgrd3n5D8sV6GU/wwdSMx00+zeLcor4O+29KS+ozpwnSzmV/Uk9Z9aJNbnLy5cvr7BDB30/3ynF57+NKa4sNDS0xM9Zjq7wV0aidVujmp2049Bqjej5al7bjoOr5F8lhOEjxVAaPy97UdDz6lo5Ol76OHMxLVG1b2hmtT4y7oAa1uwgSWpXP0zhRzfLv0pNuTi7a+rCoUrPTNV9vabk9SlIRf5ZAaWpoAsOClMuCxgDBw7Uk08+qS+++EITJkyQh0duZTUmJkZLlixRaGio6tatW6R9OTk5FfuyluJIrCud/qvwfi7eUmjrqtx6ErattXRwbdG61u/kKbcqnqWbxw5ln7u0XM3fX0G+xmW5Fi1OSTuPF97P203q3NRPjuVyKunrc8FROvH3crVq/vKuoH/QzjTvMTqC3XEyl/w5S6RZunymmju6PK0nZ3bUJytfVo9WI3Tw5FYt2fKhRvdnSFhxmM3mUj3HtGUFPa+ux+Ho3Zrx/aM6cyFSr4383mpdjiUnb9nTrYqSLsbLydFZR2P3avaTfyg5LUEv/7eP5o0Lv+L+K/LPCrA15fLUsUqVKnrnnXcUHR2t9u3b67333tObb76p9u3bKyMjQx9++KHREfPUbC8V5Ur6Op1E8QI2L6Ch5Fql8H6BjSS3IvSD/bmloWQuwu+025qK4gVgp+oFt9Hro5Zo64HlGv1eM326+lXd13uq+nUYbXQ0VFB1qzfXjLG/adKoZZq55HGrdaZ/nUAnpybI081Hnm4+ahTSSW4unqpWOVguzu5KSSuhS0IAlKpyeQWGJD388MPy8/PT9OnT9corr8jBwUEdOnTQl19+qU6dOhkdL4+Xv9R8oLRnqZSTVXCf0JulQOMmNQeKzMlZanmntOtb6eIVppmpFio16Fm2uVB2bqgiPdRN+niTlHGF32n9mkvt65RlKgAlrV2DMLVrEGZ0DEAZWelydqokSXJ38VYls5vV+hr+DXXw5DbVC26jbQdXaNzg/8rTzUdfrHld2dlZSstI0cW0RLm7eBkRH0AxldsChiTdfvvtuv1227/LgW8tqdODUnS4FPunlHFRcnSWqtWVgppL7nZ2CTkqNldvqd1IKe6QFL1HSjkvOThI3jdIQS0knxpcTVTehQZIr/SXfj8ibT8mJaVKlcxS4+pSp1ApsLLRCQEA5cX+41v0+U8T5eDgKIvFotH93tP2g6uUlBqv7i3u1gO3vaH3vnlQWdmZ6thogAJ9a0uS+rYfrXFzuik7O1MP933b4EcBoKjKdQHDnlTykGp3yP0H2DtHs3RD49x/qJg8XaWejXP/ASXlk70btGDfRjmYTPqwx/1qUrWG1fqLmel6ev2nOn7hjLJzcrT09uf057kovbTpK0lSUmaqLBZp28hp+uHwTo3f/JWiks7p/JPzCz32lF+/19oTe+XiaNbHt41WkOelvy5kZGepzzdv5H3926kIRY2ZrUqOZt2/crbOpSarsou75vV6WJVd3Avcf1zKBQ1f/qGycrJlkUXv3jxSrQJqW/XZGXtUT65bIGdHJ/m7eeuzsMdkduRUDhVbi7rd1aJu9yuur+5XV+8+ujFfe8/WI9Wz9chSTAagNPCuBwAAbF58arLm7lmjX+6epKMXTmvsmk/005AJVn0m//q9hjbopJtrNMpraxNYV2uHviJJmrFzpVKzcqcO7Fg9VNtHTlPrz14q9Nj7z0bpt1OHtHHYRK09Hq7XfvlG/73t0nwPzo5OecfYffq4Xt78laq4eGjGzpVqG1hXz7Tpq+8jtund7cs1+aYhBR7Dzeysz/s+rgD3yjp4Llpj187Xmsse37vbl+vNrnerc1B9Pb7mv1p1bI/61W1VhO8eAADlA1OoAQAAm7c99oi6BjWU2dFJ9Xxu0NnUJKu7C0jSpsj9Wn54p3osmqxpvy3Ot49FB7ZoSP2OkiRfV0+5ODkX6dhbog6qT+2WkqRbQhrrj7hjV+y76M8tGlI/d66tv+Jj1Mo/9yqKNgF1tCnyzytu5+nsqgD3ypIks6OTHAsYa9fIL0gJ6SmSpAvpqfJz5U5OAICKhQIGAACwefFpyVbDLzydXXUh/aJVn71nTurWWs3005CXtev0cW06ealgEBEfI2dHJ9X0rnpdxzaZTMrOySmwX44lR8sO79Cg0DaSpMZVg7X6eO7tYFce3aX4tORCj5VjydGzGz7XM2365lvXr25rPb3uUzX95DldSE9RuxuKdkt4AADKCwoYAADA5lWp5G5VsEjKSJV3Jeu7Dfi5eqpnzSZyMDmoZ0gThZ89mbfuqwNbNLT+td2FrIqLuy6k5V75YLFY5OhQ8OnT5sgDalatpjydXSVJ9zW5WSkZaer59RSdTDqrG9wLv3/0U+s+VY+QJrq1VrN86x5f8199O3Cc9t7/tjoF1dfMP1Zf0+MBAMBeUcAAAAA2r21gXf0cdUBZOdk6fD5Wfq6ecjBZn8Z0DqqvXXHHJUk7446qTmX/vHXfHvpdd9ZrV+hxopPi811h0TmogVYfy72SYmPkn2rpX6vAbb86sEXDGl4qkjg7OumDHvdpzZAJqls5QLeH5h4/PjVZyRlp+bZ/fcu38nB20WMte10x3z/DRqq5eelcalKhjwcAgPKESTwBAIDN83H10P1Nblb3RZPkYDLpg1vukyStPrZH8WnJGtagk6beNFSjf5qntKxMNfQLUu9azSVJ22IOq7Z3Nfm5eeXtb1vMYb3689eKSoxX7/9N1VOtw9S7dnON+HGmvh84zmq4SiO/ILUKqK1uX01UJUez5vV+RJL02b5NCvby0801Gik9K1MbT+7Xhz3uz9su/MxJPb3uUzk5OKhJ1Rp6o+vdkqT3d/yotoF1rSbgPHguWm/+vkSdqtdTj0WT5e/urYX9ntDu08e18eR+PdU6TFNuGqqhy/6jSo5mOTo46NOwx0rt+w0AgC0yWSwWi9EhAAC5TpyT3l+Vu/x0bynE9+r9Uf5ciJG2L8xdbnOP5B1obB6jZL7zoxSXWLbHzM7SI6vn6ZM+j5bqcR5YOUezb31QziV9C1R/L5mfDSvRXf42X0o5V6K7xN/cfaUO9xmdwhj29ryqyD8rwNZwBQYAAIBy7/5R2sULSVa3YAUAAEXHHBgAAAAAAMDmUcAAAAAAAAA2jyEkAADA5ph8PcUkXcVj8vU0OgIAAKWKAgYAALA5Tvd1MToCAACwMQwhAQAAAAAANo8CBgAAAGzS83N7aPqiUUbHAADYCAoYAAAAAADA5lHAAAAAQKlZumWWHni7ofq8WEmDJ1bT65/eIUkaPq2mFq6dYtX33W8e1LjZ3SRJ0xeN0q7D67Rm56fq+ZxJPZ8zac+RjYUeb/i0mlqw6hV98N2jGvhKZQ2eWE1LtsxURla6Zi4Zq0GvVtHQydW1ZMtMq+3OJcZo6hdDNfCVygp7yVXjZnfTocgdkqScnBzdPbWGvlw3zWqbjKx0DXq1ilZs/TivbckvH+r+6fXV5yUX3fvWjVq4bqqys7OK+20DABSASTwBAABQKj5d/Zq+3fyuHujzplqH3qrU9GRtO7SySNs+NuADxcYflY9XoMb0/0CS5OnmU6Rtl2z5UMN7vKpZT+7Qxt2LNGvJWG07uEIt6/bQzCe2a/Peb/TR0ifUom53hfg3lMVi0cQFA5WRla4p9y+Xu4u3Fq6bohfn9dSCF/6St7ufbmk5XGv/+Fx33zI+7zi/7V+qjMw0dW06WJL02U8TtXr7fD3a/z+qU725TsYd0Affj1ZmZppG9Z5czO8eAOByXIEBAACAEpeakaL/bZyukT0namCnxxVUNVQ3BrXUPbe8XKTt3V295eToLGcnV/l4BcjHK0BmJ+cibdusTjfd2fUZVferq2Hdx8utkqccTY55bUO6vSB3F2/tOrxekrTr8HodjNym8fd8qca1OqtWYBM9P/QzOTu5aNmvH0mSerYaqcjTB3Uocnvecdbs/EwdGw+Uu6u30jIu6n8bp+upO+aqc5NBCvSppXYN+ui+XlO0ZMuHxfzuAQAKwhUYAAAAKHEnYvcrIytNrUJvLfNj1w5slrfs4OAgb/eqqhXY1Kqtskc1JSSfzs0at19ebr4K8W+Y18fZqZLq12inE3H7JUk1qtVX/eC2Wrvzc9ULbqPzyae149BqTbpvWd4+0jNTNemzOySTKW8/OTnZyshKU0LyGVX2qFqqjxsAyjsKGAAAAChzJpODLBaLVVt2dmaJ7NvJ0XzZsUz522SSxZJTrP32aDVSX6x5XY/0e1cbdn0pb3e/vAJNzt/7mjDiGwVVDc23bVGHvwAArowhJAAAAChxIf4N5ezkop0RPxW4vrJHNZ1LPGXVdjh6l9XXTk7OyrFkl1rGf4T4N1LixXM6EfdnXltGVroOntyqmv6N89pubjFMKWkXtP3QKq3Z+Zm6t7hHjg6OkqSa/o3k7OSimPijqu5XN9+/f/oBAK4dV2AAAACgxLlW8tCdXcfpszUT5Wx2VavQnkrPTNW2gys0rPtLanljD/3w60fq1HiQ/KuEaPnvcxSXcMLqSoWAKrW058gGnTp7RO6u3nJ38c53JUVJaFG3u+oHt9W0hXdr7KBZcnf11sK1k5WRlaZ+HR/N6+fl5qO2DcL06epXdeTUbj0/5FOrxzus+3jNXzleJpnU8sYeys7J0rHYcB2O3qWHwt4q8dwAUNFQwAAAAECpGNVrsrzdq2rJlhma88PT8nCtoia1u0iShnR7QXHnT2jqwiFycjCrX8cx6tJ0sE6dPZy3/eCu43Q8NlyPvN9MaRkpemf0BjWr063Ec5pMJk0ctURzlj2tCZ+EKTMrXfVqtNWbD62Rt7ufVd9bW92r1z4dqDo3NFetwCZW64b3fEU+XoFaumWm5i4fp0pmVwX5herW1qNKPDMAVEQmy+WDDwEAhjlxTnp/Ve7y072lEF9j86DsXYiRti/MXW5zj+QdaGweVGy/zZdSzhmdonxy95U63Gd0CmPY2/OqIv+sAFvDHBgAAAAAAMDmMYQEAAAAduHLddP01fppV1z/w9TkMkwDAChrFDAAAABgF/p2GK2uze4yOgYAwCAUMAAAAGAXvNx85PWvu5QAACoW5sAAAAAAAAA2jwIGAAAAAACweRQwAAAAAACAzaOAAQAAAAAAbB4FDAAAAAAAYPMoYAAAAAAAAJtHAQMAAAAAANg8ChgAAAAAAMDmUcAAAAAAAAA2jwIGAAAAAACweXZdwNizZ48GDBggb29veXl5aeDAgYqJiZGnp6eGDh1qdDwAAAAAAFBCnIwOcK3WrVunvn37KiQkRBMmTJCrq6sWLFig2267TcnJyWrevLnREQEAAMqlvUc369tN7+rIqd06nXBSo3pN1j09JhgdC3aO5xWAwthlAePMmTMaMmSIWrZsqbVr18rV1VWSNGLECNWqVUuSKGAAAACUktT0ZIX4N1T3Fndr9rKnjI6DcoLnFYDC2OUQkrfeekvnz5/X/Pnz84oXkuTt7a2WLVtKooABAABQWto16KMH+ryhbs2HyOxUyeg4KCd4XgEojF0WMBYtWqSbbrpJoaGhBa739/dXQECAJGnUqFFydnaWh4dH3r9Vq1aVZVwAAAAAAHCd7G4ISWxsrKKjozVkyJB863JychQeHq4WLVpYtT/88MOaOXPmNR0vKytLsbGx17QtABTX6USzJP/c5bg4OaZmGhsIZS713L+eA6fjlJTNcwDGycz0l2Q2Oka5lJmZqaioOKNjGMLenlcV+WcFlKaAgAA5ORWvJGF3BYyUlBRJkslkyrdu6dKlOn36dIkOH4mNjVVwcHCJ7Q8ArqZa7dYaNmm7JKlvv746fXSHwYlQ1kKDWmvWk38/B/r2VUQUzwEYZ964faoZ0MjoGOVSRESEuj7S2OgYhrC351VF/lkBpSkyMlJBQUHF2sbuhpAEBwfL0dFRmzZtsmo/ceKExo4dKyn//BcLFy6Uj4+PGjRooKlTpyorK6us4gIAAAAAgBJgd1dgODs7a+TIkZo/f74GDBigsLAwRUZGat68efL391d0dLRVAeOJJ57Q9OnT5efnpz/++EPDhg1TWlqaJk+eXKTjBQQEKDIyspQeDQBYi0k0a+Gu3OXlPyxXoBfDByqa1HNmnViTu7x8+XK5+vIcgHGOrvBXRqLRKcqn0NDQCnuOaW/Pq4r8swJK0z/zVhaH3RUwJGnGjBkym81aunSp1q9frw4dOmjx4sWaNGmSDh8+bDW55z93JZGk1q1b6/XXX9drr71W5AKGk5NTsS9rAYBrlX3u0nI1f38F+RqXBca44Cid+Hu5WjV/eQcaGgcVXKRZyiigPTU9WdFnD0uSMrMzFJ8Uq8PRu+VayUPV/eqWbUg7ZTabK+w5pr09ryryzwqwNXZZwPDw8NDcuXM1d+5cq/Z9+/apSZMmcnC48sgYBwcHWSyW0o4IAABQbkVE7dCzc27O+3rZr7O07NdZalq7q959dKNxwWDXeF4BKIxdFjAKkpCQoKioKIWFhVm1f/311+rdu7e8vLwUHh6u119/XYMHDzYoJQAAgP1rVqeb1rzNH4RQsnheASiM3U3ieSXh4eGS8k/g+dFHH6lmzZry9PTUHXfcoWHDhmnSpEkGJAQAAAAAANeq3FyBcaUCxuV3KwEAAAAAAPan3FyBMWbMGFksFrVv397oKAAAAAAAoISVmwIGAAAAAAAovyhgAAAAAAAAm0cBAwAAAAAA2DwKGAAAAAAAwOZRwAAAAAAAADaPAgYAAAAAALB5FDAAAAAAAIDNo4ABAAAAAABsnpPRAQAAAGCbXCsbnaD8qsjfW3t77PaWFyjPKGAAAACgQM0HGZ0A5RHPKwDXiiEkAADYmePHj8vHx0fdunVTmzZttHr16nx9jh49qscee0yStGzZMjVo0EAeHh5X3W9ERITMZrN+//13q/bXXntN9evXz/v6rrvuUkpKSgk8EgAAgKKjgAEAgB1q27atNm7cqMWLF2vcuHH51r/99tsaPXq0JKlTp07atWuXgoKCrrrPyZMnq2vXrlZtcXFxioiIsGobPHiw5s+ff52PAAAAoHgoYAAAYMeCgoIKvBri999/V5MmTSRJvr6+cnFxuep+tm7dqoCAgHxFjsmTJ+ull16yauvVq5e+//7760wOAABQPBQwAACwY+Hh4fLz87NqO3PmjLy9vYu1n6lTp+rFF1+0avvrr7+UnJyspk2bWrV7eXkpNjb22gIDAABcIybxBADADm3btk3dunWTs7Oz5syZc137+vHHH9W6dWv5+vpatU+cOFGTJk26rn0DAACUFAoYAADYobZt22rVqlUFrvPz81NCQkKR97V7925t3LhRv/76q8LDw3Xo0CF9//33VhOBRkVF6dlnn9U777yjxMRE+fv7l8TDAAAAKDKGkAAAUM6YTCa1b99e4eHhknLnt+jRo4ciIyPVo0cPrVy5UpL01FNPKT4+Xi+//LLWr1+vVatWqWfPnnr//fcVGBio3377TatWrdKqVasUFBSkd955R5K0evVq3X777YY9PgAAUDGZLBaLxegQAIBcJ85J7//9R/Wne0shvlfvj/LnQoy0fWHucpt7JO/Aa9vP0aNH9e6772rWrFklF+5vgwcP1oIFC+Tu7l7i+wYAALgShpAAAFAO1a5du1SKF5L0zTfflMp+AQAAroYhJAAAAAAAwOZRwAAAAAAAADaPAgYAAAAAALB5FDAAAAAAAIDNo4ABAAAAAABsHgUMAAAAAABg87iNKq5o3kbpXLLRKXL5ekgPdTM6BQDAnvG+Zrt2L5ZSE4xOkcu1stR8kNEpAAAFoYCBKzqXLMVeMDoFAAAlg/c125WaIKWcMzoFAMDWMYQEAAAAAADYPAoYAAAAAADA5lHAAAAAAAAANo8CBgAAAAAAsHkUMAAAAAAAgM2jgAEAAAAAAGweBQwAAAAAAGDzKGAAAAAAAACbRwEDAAAAAADYPLsuYOzZs0cDBgyQt7e3vLy8NHDgQMXExMjT01NDhw41Oh6u4pOnahodAQAAlHPDp9U0OgIAoAQ5GR3gWq1bt059+/ZVSEiIJkyYIFdXVy1YsEC33XabkpOT1bx5c6MjAkCxJFyUfvvr0tfr9ku3NpaCfIzLhLKVdFo6vu3S19F7pUoekouncZkgZWWkavvSaTr0+yIlx0fJydlV3tXqqEHnEWre6wmj4wEAUGHYZQHjzJkzGjJkiFq2bKm1a9fK1dVVkjRixAjVqlVLkihg2KhNXzytqD83KOX8KS0c3/z/27v/mCjvA47jnzs41OpxKh53KgjaDrX+qlgzRC01tjZKxcZ1cevUbFlD1cToNJqu2TWLa8jIki6aLC21G4txid3qD9zs0EWNxtVmTus8ugrFAR6nV6vD2oAbOp79cQG5FOEO5e65u/cruQSe+3J8zNe75+HzfZ47jRg9UUvWvxfrWEBMGYZ02Csdrgl+3emCL3ibliWtLJQG2WKXEQPrf+1SzZ+lLz4L3X7FK12pkcYXSBMKJYslNvmS3bHKtWr+53EVrdquUeNmqP32LX3R9LG+unE51tFwH28d/JHO1x/XjVtX9MqbTyg7c6J+spLjDQCId3FZYJSXl6ulpUWVlZVd5YUkORwO5efn6+jRoxQYURbu6lTRyl9KCl5C8r2y8zFKC5jL4Rqp2nv/+73N0m9OSqULpJS4vvAPPenokC4clG403meAITWcDpYXEwqjmQydLp09oMIX39CjT77Qtc2ZMyN2gZLYs1t6b/FcI3K0+7VGrS0JHm+sLMtVxabzUUgGAIiGuCww9uzZo/nz5ysvL6/H+10ul9xud9f3hw4dksfjUW1trex2uzZv3qwtW7ZEK25SYHUK6J8vb0tHeikvOtUGpE/80vTsgc+E6Lp+qZfyopuG09LY6cFLShBdQ4ePVuOFak0sfEmDh3FNVyy957na9fUnTR9q265v6a2N5zTSPlqSZLWmxCoaACAK4q7ACAQC8vv9WrFixdfu6+jokNfr1cyZM7u2HTlyRKWlpdq1a5eKiorU1tamy5fD/6P67t27CgQCDyV7vLlzxyUpvHPWB3p16s6dO2pu/vyhPR5gFqeb7OowHGGMNHT0wn810nJ9wDMhui5/NErSIEm9rywbhvTpqS81aupXUcmViCLZr3X3zMvvqvpXL+mdtU6NzJqi0Y8VKHfGEk2YtUyWfl7Xw34tVLhzMzL93gJV+iPBMskx1Bmy/cGzMDcAEA1ut1upqZFVEnFXYLS2tkpSjwcMVVVVunbtWsjlIx6PRx6PRwsXLpQkpaena+rUqWH/vkAgoOzs5FzyXPnzGmVkTQlr7ECvTtXV1Sl7efjzBsSLpZsOavzM58P4I8iiz662K/v55Hw9SmQHfnZTQwcP7nOcYRj64+9P6vXFJVFIlZgi2a91NyZvrr7/5iUFLv1NgfrT8l88qUM7XlTujMVauulgv0oM9muhdm6uUa478rkZCHV1dSp6hbkBgIHm8/mUlZUV0c/E3dXU2dnZSklJ0YkTJ0K2NzU1af369ZLuvYFna2urzpw5o0AgoEmTJsnlcqmkpEQNDQ3Rjp3wnnn5Xd3wefXOWqd2/3i6jv66VJf+fkBG93ckBPA1wdOdw3ueWDg1OiFZLeHOq6EUa9ytOyQMa0qqxuQVKn/JZi3dVKVFpb9Vw8d/kv/iyVhHAwAgacTdkVBaWppWr16tyspKLVu2TMXFxfL5fNq5c6dcLpf8fn9XgdHS0iLDMLR3715VV1crMzNTGzdu1PLly3Xu3LmwVkzcbrd8Pt8A/6vMqfKMSzfawhsb6erUyLGPR5QlLy8vaecBie14vUNn/eF0yYayMmw8DxJQ4+E0/afFUF+XkFgsVj1XMk+rf8r/gf6KZL/WlxFjJ0uSbt+61q+fZ78W6l8fuNR+6+E/7jhXZMcbEnMDANHS/X0rwxV3BYYk7dixQzabTVVVVTp27JjmzJmj/fv3a9u2baqvr+96c0+73S5J2rBhg3JzcyVJZWVlcjqd8vl8GjduXJ+/KzU1NeLTWhKF7Xxk4ztXpzpXqC6e2q3Db6+S/+JJZU0uChn7wpYPIstisyXtPCCxLbJLZ/3hjLTo6SlpPA8SkGW29OmR8MZOmmvX0Az7wAZKYJHu1zq9/0aR8uZ8V67xT2pIulM3A/X68A+vadAjw5X1+IL+ZWG/FsJnk9oH4HHLfhjZ8YbE3ACAmcVlgTFs2DBVVFSooqIiZHtNTY2mTZsmqzW4mulwOJSTk9PvN9jCg3nQ1SkgGbgc0qxc6Wxj7+Ocdik/NwqBEHXuSVLTGamtpY9xk6WhGdHJhFA50xer9q+/00d7X1f77Vsakp6psROf0rOllRpiHxXreAAAJI24LDB6cvPmTTU3N6u4uDhk+5o1a7R9+3YtWrRITqdTHo9Hs2bNCuvsC4RvIFangGTxnQKp/a7kbe75/sx0ac0CaVDCvGKju5Q0Kf/b0rn3pbZ/9zzG+Zg0+bno5sI9s0te1eySV2MdAwCApJcwh8Ner1eSQj6BRJK2bt2qlpYW5efnq6OjQ/PmzdO+fftikDCxsToF9J8tRfrBU1LtVelUndR4XerokJzp0txvSDNzpLSEebVGTwanS99cJX1eKzX/I1hkWKySY4yU9YSUkStxMiEAAEh2CXNIfL8Cw2q1qry8XOXl5TFIlTxYnQIejNUiTR4TvCE5pdikMVODNwB9m/Ho0/rLL/i0MwBIJnH3Mar3s27dOhmGoYKCglhHAQAAAAAAD1nCFBgAAAAAACBxUWAAAAAAAADTo8AAAAAAAACmR4EBAAAAAABMjwIDAAAAAACYHgUGAAAAAAAwPQoMAAAAAABgehQYAAAAAADA9CgwAAAAAACA6aXGOgDMK2NYrBPcY6YsAID4ZKZ9iZmymMGQ4bFOcI+ZsgAAQlkMwzBiHQIAAAAAAKA3XEICAAAAAABMjwIDAAAAAACYHgUGAAAAAAAwPQoMAAAAAABgehQYAAAAAADA9CgwAAAAAACA6VFgAAAAAAAA06PAAAAAAAAApkeBAQAAAAAATI8CAwAAAAAAmB4FBgAAAAAAMD0KDAAAAAAAYHoUGAAAAAAAwPQoMAAAAAAAgOlRYAAAAAAAANOjwAAAAAAAAKZHgQEAAAAAAEyPAgMAAAAAAJgeBQYAAAAAADA9CgwAAAAAAGB6FBgAAAAAAMD0KDAAAAAAAIDp/R8Lx/Y1gMqLmgAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -119,14 +119,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 1201.0166532117305\n" + "Sampling overhead: 4096.0\n" ] } ], @@ -141,17 +141,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{0: PauliList(['IIII', 'IIII', 'IIIZ']),\n", - " 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" + "{0: PauliList(['IIII', 'IZII', 'IIIZ']),\n", + " 1: PauliList(['ZIIII', 'IIIII', 'IIIII'])}" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -162,17 +162,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 6, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -183,17 +183,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -211,14 +211,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "576 total subexperiments to run on backend.\n" + "1024 total subexperiments to run on backend.\n" ] } ], @@ -246,7 +246,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.9.6" } }, "nbformat": 4, From 8d6ee74fbdf564f603ea48e5dce6718018cc3146 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 23 Jan 2024 12:05:01 -0500 Subject: [PATCH 027/128] Add cut finder tests --- .../cutting/cut_finding/circuit_interface.py | 14 +- .../cutting/cut_finding/cutting_actions.py | 187 -------------- .../cut_finding/disjoint_subcircuits_state.py | 14 - .../cut_finding/search_space_generator.py | 29 --- .../tutorials/LO_circuit_cut_finder.ipynb | 113 +++++++- test/cutting/cut_finding/__init__.py | 1 + .../cut_finding/test_best_first_search.py | 75 ++++++ test/cutting/cut_finding/test_cco_utils.py | 116 +++++++++ .../cut_finding/test_circuit_interfaces.py | 120 +++++++++ .../cut_finding/test_cut_finder_roundtrip.py | 128 ++++++++++ .../cut_finding/test_cutting_actions.py | 115 +++++++++ .../test_disjoint_subcircuits_state.py | 241 ++++++++++++++++++ .../cut_finding/test_optimization_settings.py | 37 +++ .../test_quantum_device_constraints.py | 19 ++ 14 files changed, 963 insertions(+), 246 deletions(-) create mode 100644 test/cutting/cut_finding/__init__.py create mode 100644 test/cutting/cut_finding/test_best_first_search.py create mode 100644 test/cutting/cut_finding/test_cco_utils.py create mode 100644 test/cutting/cut_finding/test_circuit_interfaces.py create mode 100644 test/cutting/cut_finding/test_cut_finder_roundtrip.py create mode 100644 test/cutting/cut_finding/test_cutting_actions.py create mode 100644 test/cutting/cut_finding/test_disjoint_subcircuits_state.py create mode 100644 test/cutting/cut_finding/test_optimization_settings.py create mode 100644 test/cutting/cut_finding/test_quantum_device_constraints.py diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 4b0cc646f..d09b5a706 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -15,17 +15,18 @@ import copy import string +import numpy as np from typing import NamedTuple from abc import ABC, abstractmethod -import numpy as np + class CircuitElement(NamedTuple): """Named tuple for specifying a circuit element.""" name: str - params: list + params: list qubits: tuple gamma: float | int @@ -183,15 +184,15 @@ def __init__(self, input_circuit, init_qubit_names=[]): assert gate == "barrier" self.circuit.append([gate, None]) self.new_circuit.append(gate) - else: - gate_spec = CircuitElement( + else: + gate_spec = CircuitElement( name=gate.name, params=gate.params, qubits=tuple(self.qubit_names.getID(x) for x in gate.qubits), gamma=gate.gamma, ) - self.circuit.append([gate_spec, None]) - self.new_circuit.append(gate_spec) + self.circuit.append([gate_spec, None]) + self.new_circuit.append(gate_spec) self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) self.num_qubits = self.qubit_names.getArraySizeNeeded() @@ -261,6 +262,7 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): gate_pos = self.new_gate_ID_map[gate_ID] new_gate_spec = self.new_circuit[gate_pos] + print (new_gate_spec, input_ID) assert src_wire_ID == new_gate_spec[input_ID], ( f"Input wire ID {src_wire_ID} does not match " diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 84b9e90bc..2e252d400 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -111,37 +111,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def multiqubitNextState(self, state, gate_spec, max_width): - """Return the new state that results from applying - ActionApplyGate to state given a multiqubit (3 or more qubits) - gate specification: gate_spec. - """ - - gate = gate_spec[1] - roots = list(set([state.findQubitRoot(q) for q in gate.qubits])) - new_width = sum([state.width[r] for r in roots]) - - # If applying the gate would cause the number of qubits to exceed - # the qubit limit, then do not apply the gate - if new_width > max_width: - return list() - - new_state = state.copy() - - r0 = roots[0] - for r in roots[1:]: - new_state.mergeRoots(r, r0) - r0 = new_state.findWireRoot(r0) - - # If the gate cannot be applied because it would violate the - # merge constraints, then do not apply the gate - if not new_state.verifyMergeConstraints(): - return list() - - new_state.addAction(self, gate_spec) - - return [new_state] - ### Adds ActionApplyGate to the object disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionApplyGate()) @@ -518,159 +487,3 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): ### Adds ActionCutBothWires to the object disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionCutBothWires()) - - -class ActionMultiWireCut(DisjointSearchAction): - - """Action class that implements search over wire cuts - for gates (protected subcircuits) with more that two inputs""" - - def getName(self): - """Return the look-up name of ActionMultiWireCut.""" - - return "MultiWireCut" - - def getGroupNames(self): - """Return the group name of ActionMultiWireCut.""" - - return ["WireCut", "MultiqubitGates"] - - def nextStatePrimitive(self, state, gate_spec, max_width): - """Return the new state that results from applying - ActionMultiWireCut to state given the gate_spec. - """ - - gate = gate_spec[1] - - # If the gate is applied to two or fewer qubits, return the empty list - if len(gate.qubits) <= 2: - return list() - - input_pairs = [ - (i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits) - ] - subcircuits = list(set([pair[1] for pair in input_pairs])) - - return self.nextStateRecurse( - state, gate_spec, max_width, input_pairs, subcircuits - ) - - def nextStateRecurse( - self, state, gate_spec, max_width, input_pairs, subcircuits, cuts=[], merges=[] - ): - """Recursive implementation of nextState()""" - - # If the limit on the total number of wire cuts would - # be exceeded, then return the empty list - if not state.canAddWires(len(cuts)): - return list() - - # Base case of the recursion - if len(subcircuits) <= 0: - # If there are no wire cuts, then return the empty list - if len(cuts) <= 0: - return list() - - # Case: all wires are cut - elif len(merges) <= 0: - new_state = state.copy() - - gate = gate_spec[1] - r0 = None - - cut_triples = self.addCutsToNewState(new_state, gate, cuts, r0) - - new_state.addAction(self, gate_spec, *cut_triples) - - return [new_state] - - # Case: at least one wire is not cut - else: - new_width = len(cuts) + sum([state.width[r] for r in merges]) - - # If applying the gate would cause the number of qubits to - # exceed the qubit limit even with the wire cuts, then - # return the empty list - if new_width > max_width: - return list() - - new_state = state.copy() - - r0 = merges[0] - for r in merges[1:]: - new_state.mergeRoots(r0, r) - - # If the gate cannot be applied because it would violate the - # merge constraints, then do not apply the gate - if not new_state.verifyMergeConstraints(): - return list() - - gate = gate_spec[1] - r0 = new_state.findWireRoot(r0) - - cut_triples = self.addCutsToNewState(new_state, gate, cuts, r0) - - new_state.addAction(self, gate_spec, *cut_triples) - - return [new_state] - - # Recursive step - else: - root = subcircuits[0] - - # Case A: all input wires from subcircuit root are cut - new_cuts = [pair for pair in input_pairs if (pair[1] == root)] - - cut_case = self.nextStateRecurse( - state, - gate_spec, - max_width, - input_pairs, - subcircuits[1:], - cuts + new_cuts, - merges, - ) - - # Case B: all input wires from subcircuit root are left uncut - uncut_case = self.nextStateRecurse( - state, - gate_spec, - max_width, - input_pairs, - subcircuits[1:], - cuts, - merges + [root], - ) - - return cut_case + uncut_case - - def addCutsToNewState(self, new_state, gate, cuts, downstream_root): - """Updates the new_state to incorporate a list of wire cuts""" - - cut_triples = list() - - for i, root in cuts: - qubit = gate.qubits[i] - wire = new_state.getWire(qubit) - rnew = new_state.newWire(qubit) - cut_triples.append((i, wire, rnew)) - if downstream_root is None: - downstream_root = rnew - else: - new_state.mergeRoots(rnew, downstream_root) - new_state.assertDoNotMergeRoots(root, downstream_root) - new_state.bell_pairs.append((root, downstream_root)) - new_state.gamma_UB *= 4 - - return cut_triples - - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): - """Insert an LO wire cut into the input circuit for the specified - gate and cut arguments. - """ - - insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) - - -### Adds ActionMultiWireCut to the object disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionMultiWireCut()) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 5366eb6a2..47f114491 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -162,20 +162,6 @@ def copy(self): def print(self, simple=False): """Print the various properties of a DisjointSubcircuitState.""" - # cut_actions = PrintActionListWithNames(self.actions) - # cut_actions_sublist = [] - # Cut = namedtuple("Cut", ["Action", "Gate"]) - - # for i in range(len(cut_actions)): - # if cut_actions[i][0] == "CutTwoQubitGate": - # cut_actions_sublist.append( - # Cut( - # Action=cut_actions[i][0], - # Gate=[cut_actions[i][1][0], cut_actions[i][1][1]], - # ) - # ) - # elif (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): - cut_actions = PrintActionListWithNames(self.actions) cut_actions_sublist = [] diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 535a6744a..a4cf39db8 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -67,14 +67,6 @@ def defineAction(self, action_object): self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) - def defineActionList(self, action_list): - """Inserts the specified action object into the look-up - dictionaries using the name of the action and its group - names""" - - for action in action_list: - self.defineAction(action) - def getAction(self, action_name): """Return the action object associated with the specified name. None is returned if there is no associated action object. @@ -93,27 +85,6 @@ def getGroup(self, group_name): return self.group_dict[group_name] return None - def getGroupActionNames(self, group_name): - """Return a list of the names of action objects associated with - the group_name. None is returned if there are no associated action - objects. - """ - - if group_name in self.group_dict: - return [a.getName() for a in self.group_dict[group_name]] - return None - - def getActionNameList(self): - """Return a list of action names that have been defined.""" - - return list(self.action_dict.keys()) - - def getGroupNameList(self): - """Return a list of group names that have been defined.""" - - return list(self.group_dict.keys()) - - def getActionSubset(action_list, action_groups): """Return the subset of actions in action_list whose group affiliations intersect with action_groups. diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 10a54a662..b7115b2dd 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -29,9 +29,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAD2CAYAAABobBdEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA4X0lEQVR4nO3de3wU9dn//9duTgRIwjnhrCABkShElINAEYsUQRQVod71VFsPKLcIxa+t3kqtP6v267cVRUpRQa1K+2hF1AqC4eBdRQUMEAQV5JQA4RQSkpCQhOzvjymBQEJ2M7uZmQ/v5+ORh8lkdva63M81uZjDZ3yBQCCAiIiIiEg9+Z0OQERERES8TQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYku00wGYZt0CKMl3OgqIbwa9x9rbhltygfDkYxLTPhu35KNxZja3jDNQ3Yh51FCGWUk+FB9yOorwMCkX05j22ZiWj7iTaePMtHzE23TKW0RERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtuinHIc/Nv4Ola18HwO/z0yKxLb27DuOua35Pq6T2DkcXOtPyMYlJn41JuYi7mTTWTMpF3EtHKB2Udv5g/vY/e3nr0V38+pa32bonk9+9Oc7psOrNtHxMYtJnY1Iu4m4mjTWTchF3UkPpoOioWFokptAqqT0XdxnCqH53s2nnKopLjzgdWr2Ylo9JTPpsTMpF3M2ksWZSLuJOaihd4mDBHj7N+gd+fxR+f5TT4dhmWj4mMemzMSkXcTeTxppJuYh76BpKB63ftoJrH21KIFDJsfISAG4aMpX42CYAPPnGTVyaejWj+t8NwNbdmTz99i38eXImsTGNHIu7NnXl8++sBby59LfVXrNr/yYmjnmBawfe1+DxnktMGmsaZ9JQVDeqGwmepxvK9evX8/jjj7NixQoCgQDDhg1j1qxZpKamMmrUKObPn+90iGfVo2M/Hp7wOmUVpaxc/3cyt3zCnT95qur3E697gYdmDmJQ2g0kxLfghXfv44HrX3LdjuqEuvIZlDaWQWknn8/12cb3eG3Rbxje93Ynwg1JIAC5BVBYCnHR0KEFRHno+L5JY83kcWYa1Y17qG4k0jzbUGZkZDB69Gg6d+7MY489Rnx8PPPmzWPkyJEUFRXRu3dvp0OsU1xMPO1bXQDA+Sm92HvoB156bxJTxs0BoFVSe24cMoW/fDiNHp360aFVKundrnIy5LOqK59THcjP4cUF9/P0XYtoFNu4oUMNWiAAq7fDis2wJ//k8sR4GNQNhvWEaA+cMTJprJk4zkwTCMDaHbB8E+zOP7k8MR4GdoOrekKM6qZBqW4k0jz0b8WTDhw4wPjx40lPTyczM5Np06bxwAMPkJGRwa5duwA80VCe7tbh0/l4zVy+y15TtWzMwPvZue8b/rb8Ge659nkHowtdTfkAVFZW8sw7P2PClY/Qpd3FDkVXt0AA3vsa3l5VvZkEOFICH22APy+DsgpHwrPFpLHm9XFmmkAA3s+Ev35evZkEq24Wb4BZGaobp6luJNw82VA+++yzHD58mLlz5xIfH1+1PCkpifT0dMCbDWWH1t0YcOG1zF38aNUyv9/P6P73cnmPa2jWtLWD0YWupnwA3sp4isaNErl+0CSHIgvO2h2w8tuzr7N1P3yQ2SDhhJVJY83r48w0mTth+eazr7PtALy3tmHiCSfVjUjtPNlQzp8/n8GDB5Oamlrj75OTk0lJSQGgoqKCBx98kBYtWtCsWTPuuusuSktLGzLckIwbOo213y9h/Q8rqpb5fH58Pk9+VGfks3H7Zyz+6lWm3TzX2cDqEAhYp7mD8cUPUFIW2XgiwaSx5tVxZqIVdfwj7ISvtkHxscjGEgmqG5Gaee4aytzcXHbv3s348ePP+F1lZSVZWVn06dOnatnTTz/N8uXLycrKIjY2ljFjxvDwww8zY8aMoN6voqKC3NzcoOMrL08GYupc7+EJ82pcftF5A1n6h0DQ71d7HOXk5OyzuY3gcoHg8ikqyefZ+bcybfw8Epu0DDEW+/mEIu9oNDmHU4Jat/w4fLohj4tSjkY4qlPeM8yfjb1YGm6smTbOTJNfEsWuQ22DWrei0qqbtLaqm/pvQ3Uj4ZeSkkJ0dOjtoecayuLiYgB8Pt8Zv1u4cCH79++vdrr7lVde4bnnnqN9e+vxUtOnT2fcuHH88Y9/JCqq7qvCc3Nz6dixY9DxzZm6kfNSLgp6/Uj5/vvv+dE9vWxtI9y5fLBqFnlH9jLr/YeqLb+67+3cOOShWl5lCUc+oWiXegXjHv930Ov/+vH/j8xF/y+CEVXnlnEG7htrXhpnpknp2o/xv/0i6PUf/91zrPng2QhGVJ3qpnaqGzkhOzubDh06hPw6zzWUHTt2JCoqipUrV1ZbvnPnTiZNsq75ONFQ5ufnk52dXa3BTE9Pp7CwkB07dtC1a9eGCtuWEZfdwYjL7nA6DNt+OuzX/HTYr50OIyhlJaE9PaK8tDBCkTQsE8aal8aZaUKtm7IS1Y1bqG7ELl8gELB/7L6B/fznP2fu3LmMGTOGUaNGkZ2dzZw5c0hOTmbDhg1s3ryZHj16kJ2dTadOndi7d2/VNZXl5eXExsaSmZkZ1I07oZ7y3vZRMmVHgjulEkmxieV0ucbeKQi35ALhyScUgQC88lUKBaVRwJlHw0/lI8A9/ffSNK6yYYLDvM/GLfk09DgzTSAAr61O5nBJNMHUzS/75ZLY6HjDBId7xhmobsS9zplT3gAzZswgJiaGhQsXsmzZMgYMGMCCBQt48skn2bp1a9XNOgkJCQAUFBRUNZT5+fnVfleX6OjokA79ZseAG+7PiImJqdch61O5JRcITz6hGloEC7+ue71LOvno0bVd5AM6hWmfjVvycWKcmWZoMSwI4g7uXh189LwguOstw8Ut4wxUN2Ie792WBjRt2pTZs2eTm5tLYWEhS5YsYcCAAWzcuJG0tDT8fiutZs2a0bFjR9atW1f12szMTBISEjjvvPOcCV48Y0h36FlHn9iyKdx4WcPEI+IFg1KhVx29RYsmMO7yholHRBqGJxvKmuTn55OTk3PGaexf/OIX/P73v2fPnj0cOHCA6dOnc8cddwR1Q46c26L88PMh1tNwGp12Vsnvgz6dYfIISHDfU9ZEHBPlhzsHW0/DqalueneCh0ZYT80REXN48pR3TbKysoAzJzT/zW9+w8GDB7nooouorKzkpptu4tlnG+6uQvG26CgY0wdGpMHqbfCP1dbyh34CHVs4G5uIW0X54do+cPVpdTN5BHQKbUYaEfEIY45Q1tZQRkdHM2PGDA4fPkxBQQGvvvpqtafrOO2jL1/hwZcGMnnmILbvzapxnamzhvKnf97bwJHVj2n5nBAXXf00nhePSpr02ZiUi8lOrxsvHpU0aayZlIu4jzEN5cSJEwkEAvTv39/pUIJ25GgeH66axfP3rWTquFd5eeGDZ6zzxaYPaRwX3A1ETjMtH5OY9NmYlIu4m0ljzaRcxJ2MaSi96LtdX3Fx16FER8XQsU13CooPUll5cuqZyspK3v98JmMG3u9glMEzLR+TmPTZmJSLuJtJY82kXMSd1FA6qLAkj4T45lU/x8clUFxaUPXzkrWvMyjtBmJjvHF+1bR8TGLSZ2NSLuJuJo01k3IRd1JD6aCm8c0pKsmv+rnkWCFNGiUBUFZeyrKv32JE3zsdii50puVjEpM+G5NyEXczaayZlIu4kzF3eXtRj079eGPJExw/XkHu4R0kNWlVNYfm3rztFJXm89hroyksySOvMJela95geN/bHI66dqblYxKTPhuTchF3M2msmZSLuJMaSgclNm7ByMt/wZRZQ/D5/EwaO5PV3y6msCSPYX1u4eUH1wCw/ocVLF833/XFbVo+JjHpszEpF3E3k8aaSbmIO3nyWd5utmouFB9yOgpo0hIG2Dx74ZZcIDz52JV/FKYvsL6fPhaaNXYuFtM+G7fk44ZxZhrVTc1UN2IaXUMpIiIiIraooRQRERERW3QNZZjFN3M6Aks44nBLLuCuWNzATf8/TBprbolDIsNNn6/qRkyjhjLMeo91OoLwMSkX05j22ZiWj7iTaePMtHzE23TKW0RERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbEl2ukATLNuAZTkOx0FxDeD3mPtbcMtuUB48hH3cstYU92Il7hlrKluBNRQhl1JPhQfcjqK8DApF3E3k8aaSbmIu5k01kzK5VylU94iIiIiYosaShERERGxRQ2liIiIiNiiayhFzqKoFLbsg+xDkHP45PJ/rYMLkqFrG2iV4Fh4Iq5UVApb98GuPMjJO7n8w3Un66a16kbEKGooRWqQfQhWfAvrdsHxyjN/v3q79QWQmgJDusNF7cHna9g4RdwkOw9WbobMWupmzXbrC6BbMgzuDmkdVDciJlBD6ZDn5t/B0rWvA+D3+WmR2JbeXYdx1zW/p1VSe4ejC50p+ZRVwKINsGIzBIJ8zfe51levDjDuckiKj2iI5zRTxtkJpuRTftyqm+WbIRBk4WzZZ331bAfj+0FS48jGeC4zZZydYFo+ptA1lA5KO38wf/ufvbz16C5+fcvbbN2Tye/eHOd0WPXm9XyOlMCfPv7PH8V6vH5jDjz3L9ilqS8iyuvj7HRez6ewBF74GJZtCr6ZPNWmPfDsv2DHwfDHJid5fZydzrR8TKCG0kHRUbG0SEyhVVJ7Lu4yhFH97mbTzlUUlx5xOrR68XI+RaXw0iewJ7/2dfw+6+hjUrz1fU2Kj8HLGdapP4kML4+zmng5n+JjMDOj+vXFpwumbo6WwawM/WMskrw8zmpiWj4mUEPpEgcL9vBp1j/w+6Pw+6OcDsc2L+UTCMDbq2B/HfuhhEbw2xusr4RGta9XWg6vfWr9VyLLS+MsGF7KJxCAd76A3IKzrxds3RyrsOqmpCy8ccqZvDTOgmFaPl6laygdtH7bCq59tCmBQCXHyksAuGnIVOJjmwDw5Bs3cWnq1YzqfzcAW3dn8vTbt/DnyZnExpxlz+yQuvL5d9YC3lz622qv2bV/ExPHvMC1A+9r8HhP+GqbddotnA4Xw/uZcPPl4d2uqG7AHXWzdod1mUc45R+FhV/DhP7h3a6obsAddWMyTzeU69ev5/HHH2fFihUEAgGGDRvGrFmzSE1NZdSoUcyfP9/pEM+qR8d+PDzhdcoqSlm5/u9kbvmEO3/yVNXvJ173Ag/NHMSgtBtIiG/BC+/exwPXv+TK4oa68xmUNpZBaScfkPrZxvd4bdFvGN73difCBaDiuDWVSSR8vgWG9oA2iZHZfn0dLrZi23kIKgPQJgEGdIOOLZyOLDiqG+fr5nglfJAZmW1/8QMMvRBSkiKz/frKP2rVzY6DVt20ToABF0Cnlk5HFhzVjfN1YzrPNpQZGRmMHj2azp0789hjjxEfH8+8efMYOXIkRUVF9O7d2+kQ6xQXE0/7VhcAcH5KL/Ye+oGX3pvElHFzAGiV1J4bh0zhLx9Oo0enfnRolUp6t6ucDPms6srnVAfyc3hxwf08fdciGsU6d3vnhmwoLI3c9j/bAmMvjdz2QxEIwEfr4ZNvqt90tHUffL7Vukv91oEQF+NYiEFR3ThfNxtzoKAkctv/bAvc2Ddy2w9FIACLs2DJxuo3HW3dB6u2WtOF3XoFNFLdNCgv1o3pPHkN5YEDBxg/fjzp6elkZmYybdo0HnjgATIyMti1axeAJxrK0906fDofr5nLd9lrqpaNGXg/O/d9w9+WP8M91z7vYHShqykfgMrKSp5552dMuPIRurS72KHoLCfmxIvk9utz52skLNoAS7+p/Q72jTnw2v9CZQ3zB7qZ6qbhrW6Auql0Sd18vBE+zqq9jr/ZDa+urHneTTdT3Ui4ebKhfPbZZzl8+DBz584lPv7kpH9JSUmkp6cD3mwoO7TuxoALr2Xu4kerlvn9fkb3v5fLe1xDs6atHYwudDXlA/BWxlM0bpTI9YMmORSZJRCwTvtGUvExOFQU2fcIRv5Rq5msy3d7rT+QXqK6aXi7IjzFT0kZHCiM7HsE40gJLMmqe70t+yArzNeTRprqRsLNk6e858+fz+DBg0lNTa3x98nJyaSkpADw97//nRkzZrBu3TpatWrFjh07QnqviooKcnNzg16/vDwZqP+5j3FDpzF55hWs/2EFl3QdCoDP58fnC633Ly8vJydnX73jsLZhLxc4M5+N2z9j8VevMmvy1yHGYj+f0x0pjaL4WNtqy/y+2u9ETYyv+ftTFZaeeWRl/dZDdG8dwfODQfhsRyKBQDAXcwbIyDpGc1/DTgqouqnOzXVTdMzPkdJ21ZZFom42bDnEhcnO1s0XOxOoDARzMadVN638qpv6Mr1uvCQlJYXo6NDbQ18g4JYTcsHJzc2lbdu2TJkyheefr35IvrKykrZt29KnTx8WL14MwNKlSzl06BD79u3jj3/8Y8gNZU5ODh07dgx6/TlTN3JeykUhvUddPl49j+9z1jBp7EtBv2ZH7jf88vlett433LkUleRz35/SmTruVXpfcGVIrw1HPqdrc/6l/PR31U+PJMVb05vU1xPvnnlt2fJ597Phk5frv9EwGPOrDznvkpFB/aEoLT7M7Hsa9g4d1U3t3FY3rTpdwn89va7askjUzco3J7Pu4xfqv9EwGD15AV0uvQ5fEM+GLCstYtYvGvYB5aqb2rmtbrwkOzubDh06hPw6zx2hLC4uBqixwBcuXMj+/furne4ePnw4AO+9915DhCdn8cGqWeQd2cus9x+qtvzqvrdz45CHanlV5ATzRyI87+P8lSW+EOZm0zxu7nLO1o1fdSP157a6ORd47ghlWVkZjRs3pk+fPqxevbpq+c6dO7niiivYvXs377zzDhMmTKj2uvfee4/JkydH/JT3to+SKTvi/O1+sYnldLnG3iF7t+QC4cnndIePRvPq6pRqy+o6dTd1pPX984us66tOV9Opu2t65NEz+WgYIq6/5VuTWLs7mKMnAVISyvlZ+v6Ix3Qqt4w11U3d8kuieOWr0C4VqU/djOieR1qKs3Wz4ock1uQEVzdtmpZz26Wqm/pySy4Qmbrxkvqe8vbcEcrY2Fhuu+025s6dy3XXXceoUaPIzs5mzpw5JCcns3v37rDekBMdHR3Sod/sGHDDgx5iYmLqdcj6VG7JBcKTz+naBSAu03pCxwmVgeCmQzlSEvy0KWldW9C2mbOTPA5PgLVB3Wzj48qLYsP+/7oubhlrqpu6tQ9Ao8zqT4KKSN10aUGHFs7WzdWJsCaom218DO2purHDLblAZOrmXOD8OYV6mDFjBnfffTdffvklU6dO5csvv2TBggW0a9eOxo0b13qzjsip/D7oEOG/V7FR7pjYPCUJLj2v7vWSE6FP54iHIx7m80V+Mu+YKGjbLLLvEYw2iXBZl7rXa50Al54f+XhE3MxzRygBmjZtyuzZs5k9e3a15Rs3biQtLQ2/C669EW/o0xl+iOBZqks6Q5RLhuOE/lBWUfv0JslJcN8wiPXkXkEaUp/O8H3wVwKF7OKO7qmb8ZdDWTmsz675920S4d4rIU51I+c4Y0ogPz+fnJwcRo0aVW358ePHKS8vp7y8nEAgQGlpKT6fj7i4OIciFTfpe771CLlTT3uH06BukdlufcREwZ1DrEZg+Sb47j8NQccWMLg79O6kZlKCk36e9cztU097h9MgF51kio6C2wfDllxYvhm+3Wst79ACBqdazbXqRsSjp7xrkpVlzT57+vWTb775JvHx8dx8883s2rWL+Ph4unfv7kCENfvoy1d48KWBTJ45iO17a55Bd+qsofzpn/c2cGT147V8GsXAlT0js+2e7dz3nF+/D3q0hZ8OOLnsrh/B5V289UfRa+OsLl7LJy4aropQ3XRvC+e1isy268vvs+Ka0P/ksl/8CPp1Vd04ybR8vM74hvKOO+4gEAhU+wr1Tu9IOXI0jw9XzeL5+1YyddyrvLzwwTPW+WLThzSOa9i5zerLq/kMvwjaNw/vNhvFwM39rOvNJLy8Os5q49V8hvW0jm6HU1w0TFDdRIRXx1ltTMvHBMY0lBMnTiQQCNC/f/+6V3aJ73Z9xcVdhxIdFUPHNt0pKD5I5SkPUq6srOT9z2cyZuD9DkYZPK/mE+WH266AJnVcBVFYak3A/MS71ve18fvgvwZAs8bhjVMsXh1ntfFqPifqpmmY6sbng1sGQPMm4Y1TLF4dZ7UxLR8TGNNQelFhSR4J8ScPjcXHJVBcWlD185K1rzMo7QZiY2qZ4M1lvJzPiRtSzvbH8cTUKAUlZ86Zd4LfB7deAWnBP1xJQuTlcVYTL+fTOhEmXlX7HJQQfN381wC4pFNk4hRvj7OamJaPCdRQOqhpfHOKSvKrfi45VkiTRtZzY8vKS1n29VuM6HunQ9GFzuv5dGhhTcDco23d69YkORH++2pNuxNpXh9np/N6Pu2aW3VzYbu6161J6wSYNNy6QU4ix+vj7HSm5WMCD11ObJ4enfrxxpInOH68gtzDO0hq0qpqyqO9edspKs3nsddGU1iSR15hLkvXvMHwvrc5HHXtTMineRO450pYsx2WbYa9+XW/JikerkiFKy+07qSWyDJhnJ3KhHyaNYa7h8LaHVbd7Dlc92sS4+GKblbdeOnGFq8yYZydyrR8TKAydlBi4xaMvPwXTJk1BJ/Pz6SxM1n97WIKS/IY1ucWXn5wDQDrf1jB8nXzXV8MpuTj81mTGfc9H7YfsKYJyc6DfQVQdhyi/dCyqXVEs2sbuKi9e+bMOxeYMs5OMCUfn8+qmUvPgx0HYfMeyMmD3P/UTZTPqpuOLVU3TjBlnJ1gWj4m8NyzvN1u1VwoPuR0FNCkJQywebTfLblAePKRk/KPwvQF1vfTxzp/A5FbxprqRs5GdVMz1Y2ArqEUEREREZvUUIqIiIiILWooRURERMQW3ZQTZvHNnI7AEo443JILuCsWCT+3fL6qG/ESt3y+qhsBNZRh13us0xGEj0m5iLuZNNZMykXczaSxZlIu5yqd8hYRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsiXY6ANOsWwAl+U5HAfHNoPdYe9twSy4QnnxEGoJpdeOWfLQPMJtbxhmobupLDWWYleRD8SGnowgPk3IRaSim1Y1p+Yg7mTbOTMsnGDrlLSIiIiK2qKEUEREREVvUUIqcYwIBOFx88ucDR+B4pXPxiHjB6XWzX3UjUo2uoRQ5B1Qchw3Z8NU22HUIjpad/N3MDIiJgvbNoXdnuPx8aBznXKwiblFxHLJyrLrZebB63bz8n7pp1xx6d4LLu0AT1Y2cw9RQOuS5+XewdO3rAPh9floktqV312Hcdc3vaZXU3uHoQmdaPqYIBKw/hh+ug8LS2tcrPw47Dlpf/1oHP+oBP0mD6KiGivTcZFLdmJRLIABrtsMHmXCkjrrZedD6+mg9DO4OIy+2Gk2JHJPGmkm56JS3g9LOH8zf/mcvbz26i1/f8jZb92TyuzfHOR1WvZmWj9cVlcKcFfDOF2dvJk9Xfhw++Qb+7yLYczhi4cl/mFQ3JuRSfAxe/RTeWnX2ZvJ05cdh2Sb4w0eQkxe5+MRiwlg7wZRc1FA6KDoqlhaJKbRKas/FXYYwqt/dbNq5iuLSI06HVi+m5eNlhSXw4lLYtKf+28gtgBlLraOWEjkm1Y3XcykqhZeWwsac+m9j/xGr9rYfCF9cciavj7VTmZKLGkqXOFiwh0+z/oHfH4Xf7/3zJabl4yXlx+HPy2HfWfZFfh8kxVtffl/t65WWw1+Ww8HC8McpZzKpbryWS8VxmL0c9hbUvk6wdXOswtrWfm/1A57ltbF2Nl7ORddQOmj9thVc+2hTAoFKjpWXAHDTkKnExzYB4Mk3buLS1KsZ1f9uALbuzuTpt2/hz5MziY1p5Fjctakrn39nLeDNpb+t9ppd+zcxccwLXDvwvgaP11SLN8DuOk5VJzSC395gff/Eu1BQUvu6R8us0+b3//jsf0SlfkzaD3h5H/BxFmTXcao6lLopLbfqZtKPwa9DN2GnunFH3ZzK0w3l+vXrefzxx1mxYgWBQIBhw4Yxa9YsUlNTGTVqFPPnz3c6xLPq0bEfD094nbKKUlau/zuZWz7hzp88VfX7ide9wEMzBzEo7QYS4lvwwrv38cD1L7muGE6oK59BaWMZlHbyGVCfbXyP1xb9huF9b3ciXCPtPgzLNod/uz/shy+2wsBu4d+2XYGAdTS2sBQaRVt33UZ56A+4SfsBr+4D9uZDxqbwb3f7Afh8KwxKDf+2w2HfEThSAnHR1iwPqhtneLVuTufZhjIjI4PRo0fTuXNnHnvsMeLj45k3bx4jR46kqKiI3r17Ox1ineJi4mnf6gIAzk/pxd5DP/DSe5OYMm4OAK2S2nPjkCn85cNp9OjUjw6tUknvdpWTIZ9VXfmc6kB+Di8uuJ+n71pEo9jGDR2qsVZ+azVYkbB8Mwy4AHwuOUoZCMDaHbBiM+ScckQ2KR6uSIVhF3rjLnWT9gNe3Qes/BYqI1Q3KzZb/xBz09H9E3Vz6hHZxHi4ohsM6+mNu9RVN87Xzek89O+Rkw4cOMD48eNJT08nMzOTadOm8cADD5CRkcGuXbsAPNFQnu7W4dP5eM1cvsteU7VszMD72bnvG/62/BnuufZ5B6MLXU35AFRWVvLMOz9jwpWP0KXdxQ5FZ57iY5C5M3LbP1AIW/ZFbvuhCASsKV3++nn1ZhKs05AfrbeuIy2rcCY+O0zaD3hhH3C0zGqwIuVgEXy3N3LbD9WH6+DNz848vX+kBBZtgFnLVDdO80Ld1MSTDeWzzz7L4cOHmTt3LvHx8VXLk5KSSE9PB7zZUHZo3Y0BF17L3MWPVi3z+/2M7n8vl/e4hmZNWzsYXehqygfgrYynaNwokesHTXIoMjP9sN+6ISeSvrVx13g4Ze6s+9T+1n3w/tcNE084mbQf8MI+YHtD1I1LGsr1u6wpwc5m235YsLZh4gkn1Y3zPNlQzp8/n8GDB5OaWvOFKcnJyaSkpHDs2DF++ctf0qVLFxISEkhNTeXFF19s4GhDM27oNNZ+v4T1P6yoWubz+fH5PPlRnZHPxu2fsfirV5l281xnAzNQ9qEGeA+XzK+34tvg1vtiW/Wnm3iFSfsBt+8DGmJMN0RtBiPYulm9zTrj4TWqG2d57hrK3Nxcdu/ezfjx48/4XWVlJVlZWfTp0weAiooKUlJSWLJkCV26dGHDhg2MGDGC5ORkbr755qDer6Kigtzc3KDjKy9PBmLqXO/hCfNqXH7ReQNZ+gf7F/OUl5eTk2Pv/GSwuUBw+RSV5PPs/FuZNn4eiU1ahhiL/XxMt2NfC+DkNTV+n3VXak0S42v+/nSFpdWvLdtz+Dg5Oc4ebjlcEsWuQ22DWrfiOHy6IY9eKUcjHNVJ4a4be7E03H7Aq/uA7bmRr5u9+c7XTUFpFNsPBFk3lbByQx4Xt1Xd1H8b3q2blJQUoqNDbw8911AWFxcD4KvhzoCFCxeyf//+qtPdTZo04Xe/+13V73v37s2YMWP497//HXRDmZubS8eOHYOOb87UjZyXclHQ60fK999/z4/u6WVrG+HO5YNVs8g7spdZ7z9UbfnVfW/nxiEP1fIqSzjyMd2YX33I+b1HVf186hQnZzN1ZO2/O31qlEOHj4RUD5GQckF/xk9fFfT6j01/hrX/+kMEI6rOLfsAcN9+wI37gNEPvUfXS6+r+jkSdVNQWOJ43SR36cuEJ1cHvf70p/4vq9//fQQjqk51U7uGrpvs7Gw6dOgQcpyeayg7duxIVFQUK1eurLZ8586dTJpkXVdQ2/WT5eXl/O///i+/+tWvIh1mWI247A5GXHaH02HY9tNhv+anw37tdBjGqqwob4D3cP78cXlpaLOsl5WYMbu0CfsBN+4DKo+fG3VzLMQ6KCsx42kGqpuG4wsEIjXJSOT8/Oc/Z+7cuYwZM4ZRo0aRnZ3NnDlzSE5OZsOGDWzevJkePXqc8bp77rmHr7/+ms8++4zY2Nig3ivUU97bPkqm7Ehwh+0jKTaxnC7X2Dtk75ZcIDz5mG75D0mszUmo+rmuU3cnjrA8v8i6w7Mmp5+6a5d4jFv6OPtMuUAAXvkqhYLSKODsc7H4CHB3/1wS4iJ818UpTKsbt+QTqX3Aym1JrM6ObN0kJ5Rxa/r+MEVcP4EAvLY6mcMl0dRVNxDgl/1ySWqkuqkvt+RTn1zOmVPeADNmzCAmJoaFCxeybNkyBgwYwIIFC3jyySfZunVrjTfrTJkyhVWrVrFs2bKgm0mA6OjokA79ZseA8/8WhZiYmHodsj6VW3KB8ORjup7lsPaUZxBXBs7+JI8TjpQEtx5A15Q4V3wOVxbBe0HcwZ3W0ceFXYO7bixcTKsbt+QTqX1Az+OwOvvkzxGpm+RYV9TNsKPwzzV1r3dRex8XXaC6scMt+TTk305PNpRNmzZl9uzZzJ49u9ryjRs3kpaWhv+051xNnjyZjIwMli1bRqtWrRoyVJEG06WNddwhkqccuiZHcOMhGNwdvs+FTWeZxqhFE7jpsoaLSbypS2trsv5InqtzS90M7Abf5cLGnNrXadYYbr684WISc3jvXvpa5Ofnk5OTc8b1k//93//NJ598wrJly2jd2jvzUImEqnkT6Nk+cttPaAS9Irj9UET54edDrKfhxJ32z2K/D3p3gskjzn4nrghAUuPIjusmcXCJs/fjVInyw52D4aqe0Oi0s7E+nxXnQz+x/p+IhMqTRyhrkpWVBVS/IWfnzp28+OKLxMXFcf7551ctHzx4MIsWLWroEEUibkh3+GZ3ZLY9sJu7HmUYHQVj0mFEGny1Hf75nxtYJ4+ATqHNrCHnuCHdIessR+3sGHiBu+omyg/X9oGr06z5Jv/xn7p5SHUjNhlzhLKmhrJz584EAgFKS0spKiqq+nJTM/nRl6/w4EsDmTxzENv3ZtW4ztRZQ/nTP+9t4Mjqx7R8vKZ7W+jTOfzbbZ1gHdVwo7gYSDvlEiEvHpU0qW68mEu3FLj0vPBvt1VT+LFLZzuLi4ZeqhvXMCEXYxrKiRMnEggE6N+/v9OhBO3I0Tw+XDWL5+9bydRxr/LywgfPWOeLTR/SOC6hhle7j2n5eNWNfSGxlrtUTygstebKe+Jd6/uz8fvglgEQa8z5DHcxqW68nMsNfSGpjqYq1Lr5af8zL8mQ8PDyWDudKbkY01B60Xe7vuLirkOJjoqhY5vuFBQfpLKysur3lZWVvP/5TMYMvN/BKINnWj5e1bQR3DsMGp9lMoMTd7IWlFSf3uR0Ph/8bCCcr8uPI8akuvFyLk3irLppElf7OkHXDVYz6ZabcUzk5bF2OlNyUUPpoMKSPBLim1f9HB+XQHFpQdXPS9a+zqC0G4iNqeNwk0uYlo+XtWsOk4ZDKxv/oG0UY13An35e2MKSGphUN17PpW0zq25a26yb2wfDZV3CFpbUwOtj7VSm5KKG0kFN45tTVJJf9XPJsUKaNEoCoKy8lGVfv8WIvnc6FF3oTMvH69o2g4evgR/1qHsa49P1bAePjIaLXXJ3qslMqhsTcklJgmnXwJUXWkfoQ9GjLfyfUdYsAxJZJoy1E0zJRVd3OKhHp368seQJjh+vIPfwDpKatKqaQ3Nv3naKSvN57LXRFJbkkVeYy9I1bzC8720OR1070/IxQWw0jL3Uuov18y3WXZ1Harn2Ky4aLukEg1J1t2dDMqluTMklNhquS4fBqbBqK3y5rfan4sRGW9PtnKibUJtQqR9TxhqYk4saSgclNm7ByMt/wZRZQ/D5/EwaO5PV3y6msCSPYX1u4eUHrUcarP9hBcvXzXflADqVafmYpGVTa6qQ0b0h/yhk51k3FQQCEB8L7ZtDmwTw65xFgzOpbkzKBaBFUxjVG665xLpuMvvQyccqqm6cZdJYMyUXTz7L281WzYXiQ05HAU1awgCbR8jdkguEJx8xV/5RmL7A+n76WOtpH04xrW7cko/2AeGnuqmZ6qZ+9O8qEREREbFFDaWIiIiI2KJrKMMsvpnTEVjCEYdbcgF3xSJyNm4aqybtB9wSh0SGmz5f1U39qKEMs95jnY4gfEzKRaShmFY3puUj7mTaODMtn2DolLeIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiixpKEREREbFFDaWIiIiI2KKGUkRERERsUUMpIiIiIraooRQRERERW9RQioiIiIgtaihFRERExBY1lCIiIiJiS7TTAZhm3QIoyXc6CohvBr3H2tuGW3KB8OQj0hBMqxu35KN9gNncMs5AdVNfaijDrCQfig85HUV4mJSLSEMxrW5My0fcybRxZlo+wdApbxERERGxRQ2liIiIiNiihlJEREREbNE1lCLiScXHYMs+yD4EOYdPLv9oPXRtY321SnAuPhE3Kj4GW/dBdp71dcK/1sMFbaBLG2itupF6UEMpIp6SkwcrvoV1O6Gi8szff7XN+gLongKDu8NF7cHna9g4Rdxk92GrbjJ31Fw3q7dZXwCpKTA4FXp1UN1I8NRQOuS5+XewdO3rAPh9floktqV312Hcdc3vaZXU3uHoQmdaPuI+5cdh0QZYvhkCgeBe812u9dWrA9x8OSTGRzbGUJlUNyblYpKK4/BxFmRsgsog6+b7XOvrovZW3SQ1jmyMoTJprJmUi66hdFDa+YP52//s5a1Hd/HrW95m655MfvfmOKfDqjfT8hH3KCyFFz6GZZuCbyZPtTEHnv0X7HLhNB4m1Y1JuZigqBReWAJLvwm+mTzVN7ututlxMPyx2WXSWDMlFzWUDoqOiqVFYgqtktpzcZchjOp3N5t2rqK49IjTodWLafmIOxQfg5mfVL9O8nR+HyTFW1/+Wk7RFR+DlzOqXzfmBibVjUm5eN3RIMZ7MHVztAxmZbjvH2MmjTVTclFD6RIHC/bwadY/8Puj8PujnA7HNtPyEWcEAvD2KsgtOPt6CY3gtzdYXwmNal+vtBxe+9T6rxuZVDcm5eI1gQDM/xL25J99vWDr5liFVTclZWENM2xMGmtezkXXUDpo/bYVXPtoUwKBSo6VlwBw05CpxMc2AeDJN27i0tSrGdX/bgC27s7k6bdv4c+TM4mNOUv1O6SufP6dtYA3l/622mt27d/ExDEvcO3A+xo8XnG/tTus027hdLgY3s+0rg1zA5P2A9oHuEPmTtiQHd5t5h+FhV/DhP7h3W59qW7cVzeebijXr1/P448/zooVKwgEAgwbNoxZs2aRmprKqFGjmD9/vtMhnlWPjv14eMLrlFWUsnL938nc8gl3/uSpqt9PvO4FHpo5iEFpN5AQ34IX3r2PB65/yXXFcEJd+QxKG8ugtJMPFf1s43u8tug3DO97uxPhissdr4QPMiOz7c+3wNAe0CYxMtsPhUn7Ae0DnFdZaf2DKRK++AGGXggpSZHZfihUN+6rG882lBkZGYwePZrOnTvz2GOPER8fz7x58xg5ciRFRUX07t3b6RDrFBcTT/tWFwBwfkov9h76gZfem8SUcXMAaJXUnhuHTOEvH06jR6d+dGiVSnq3q5wM+azqyudUB/JzeHHB/Tx91yIaxbrsFkJxhY05UFASue1/tgXGXhq57QfLpP2A9gHO27THOpoYKZ99DzdeFrntB0t147668eQ1lAcOHGD8+PGkp6eTmZnJtGnTeOCBB8jIyGDXrl0AnmgoT3fr8Ol8vGYu32WvqVo2ZuD97Nz3DX9b/gz3XPu8g9GFrqZ8ACorK3nmnZ8x4cpH6NLuYoeiE7c7MZdkpKzeVr87XyPNpP2A9gENL+J1s906Cuo2qhvnebKhfPbZZzl8+DBz584lPv7kxHJJSUmkp6cD3mwoO7TuxoALr2Xu4kerlvn9fkb3v5fLe1xDs6atHYwudDXlA/BWxlM0bpTI9YMmORSZuF0gADsjfFfp0TI4VBTZ96gPk/YD2gc0vJ0RnuKntBz2F0b2PepDdeM8T57ynj9/PoMHDyY1NbXG3ycnJ5OSkgLAxIkT+eCDDygoKCAhIYFx48bx3HPPERsbG9R7VVRUkJubG3Rs5eXJQEzQ659u3NBpTJ55Bet/WMElXYcC4PP58flC6/3Ly8vJydlX7zisbdjLBc7MZ+P2z1j81avMmvx1iLHYz0e8o/CYn6LSdtWW+X2134l66oTltU1eXlh65hHJ9VsO0aNNeM+rR6JuwLv7Ae0DGk5xmZ+CksjXzYateVQkh/e8uuqmOifrJiUlhejo0NtDXyBQn2mCnZObm0vbtm2ZMmUKzz9f/RB2ZWUlbdu2pU+fPixevBiATZs20blzZ5o0acLBgwcZN24cP/rRj5g+fXpQ75eTk0PHjh2Djm/O1I2cl3JR0OsH4+PV8/g+Zw2Txr4U9Gt25H7DL5/vZet9w51LUUk+9/0pnanjXqX3BVeG9Npw5CPe0fq8PtzyVPUdZ1K8Nb1JfT3x7pnXZK54fRLrlwZfV8GIxD4AzNgPaB8QWS079OJnz2RVWxaJuvn0rSlkLvpj/TdaA9VN7Rq6brKzs+nQoUNIrwEPHqEsLi4GwFfDA0YXLlzI/v37q53u7tmzZ9X3gUAAv9/Pli1bIh6nnOmDVbPIO7KXWe8/VG351X1v58YhD9XyKjkX+WiYBwj7/J686seztA+IrJr+LkbmfVQ3DckrdeO5I5RlZWU0btyYPn36sHr16qrlO3fu5IorrmD37t288847TJgwoep3zzzzDE899RTFxcW0bNmSRYsWcdllwd2mFuop720fJVN2xN5h+3CITSynyzX2Dtm7JRcITz7iHfklUbzyVdtqy+o6dTd1pPX984vgSA1nsWs6dfeT7nn0SgnvqTvT6sYt+WgfULcjpVH85cvI182I1DzS2qpuzsYt+dQnl/qe8vbcEcrY2Fhuu+025s6dy3XXXceoUaPIzs5mzpw5JCcns3v37jNuyHnkkUd45JFH2Lx5M2+99RZt27ateeM1iI6ODunQb3YMuOFhAjExMfU6ZH0qt+QC4clHvKNdAOK+tp7QcUJlILhphI6UBD/dUFrXFrRv3qJ+QdbCtLpxSz7aB9QtEIDGmdYNZydEom56dWlBh5aqm7NxSz4NWTeePG49Y8YM7r77br788kumTp3Kl19+yYIFC2jXrh2NGzeu9WadCy+8kEsuuYRbb721gSMWkVD4fdCxZWTfIybKHRM0i4SLzwcdw9vnnSHKD22bRfY9xJs8d4QSoGnTpsyePZvZs2dXW75x40bS0tLwn+W6qPLycr7//vtIhygiNvXpBFsjeIbzko7WH0cRk/TpDN8Ff5VWyC7uCNHeesS0NBBjdqf5+fnk5ORUO91dUFDAvHnzyM/PJxAIsGHDBp566ilGjBjhXKAiEpRLz4e4CP6T94qaT2SIeFr6edAogpfuDeoWuW2LtxnTUGZlWVMlnNpQ+nw+/vrXv9KlSxcSEhK4/vrrueaaa3jxxRcdivJMH335Cg++NJDJMwexfW9WjetMnTWUP/3z3gaOrH5My0ec0ygGrupZ93r10aMtnNcqMtuuD5PqxqRcvCg2Gn4c/tl3AEhNgS5tIrPt+jBprJmQiydPedekpoYyMTGRTz75xKGI6nbkaB4frprFjElfsPfQNma8ex9/uHdZtXW+2PQhjeMSHIowNKblI8676iLYkA05h8O3zUYxML6fdb2ZG5hUNybl4mVXXmjVza4wPm0qLlp1Eymm5GLMEcqJEycSCATo37+/06EE7btdX3Fx16FER8XQsU13CooPUnnKQ1IrKyt5//OZjBl4v4NRBs+0fMR5UX649QpoEnf29QpLrQmYn3jX+r42Ph/8tD80bxLeOO0wqW5MysXLovxw60BoGq66ASb0h5ZNwxqmLSaNNVNyMaah9KLCkjwS4ptX/Rwfl0BxaUHVz0vWvs6gtBuIjallEjGXMS0fcYfkJLhv2Nn/OJ6YGqWg5Mw5807w++BnA+CSTpGJs75MqhuTcvG61okw8ara56CE4OvmpwOsm33cxKSxZkouaigd1DS+OUUl+VU/lxwrpEkjax6TsvJSln39FiP63ulQdKEzLR9xjw4trAmYu6fU7/WtE2DScOtGH7cxqW5MysUE7ZpbddMj+KmXq2mVAPf/GC7vEt64wsGksWZKLsZcQ+lFPTr1440lT3D8eAW5h3eQ1KRV1ZRHe/O2U1Saz2OvjaawJI+8wlyWrnmD4X1vczjq2pmWj7hL8yZw7zBYvR2Wb4K9BXW/JrERDOwGw3paNyu4kUl1Y1IupmjWGO65EtbugGWbYE9+3a9J+E/dXKW6aRCm5OK5Ry+63aq5UBzChdD/+uIvLFkzD5/Pz6SxM8k7spfCkjyG9bmlap31P6xg+br5TL7xz0Fvt0lLGGDzHzSh5gLuzkfMEQjAtgPw7R7IzoN9BVB2HKL90KKpNblz1zbQq0PDzzVpWt2YtE871wUCsP0AbD6tbqL80LIJdGj5n7pp3/BzTapu3JtLsNRQhll9iiISnGooI0V/TMQrTKsbt+SjfYDZ3DLOQHVTX7qGUkRERERsUUMpIiIiIraooRQRERERW1x6/5Z3xTdzOgJLOOJwSy7grlhEzsZNY9Wk/YBb4pDIcNPnq7qpH92UIyIiIiK26JS3iIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMQWNZQiIiIiYosaShERERGxRQ2liIiIiNiihlJEREREbFFDKSIiIiK2qKEUEREREVvUUIqIiIiILWooRURERMSW/x/BpNnG91G9nQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from qiskit.circuit.library import EfficientSU2\n", "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", @@ -55,9 +67,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=(2, 3), gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=(2, 3), gamma=3.0)]}]\n", + "Subcircuits: AAAB \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=(1, 2), gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=(1, 2), gamma=3.0)]}]\n", + "Subcircuits: AABB \n", + "\n" + ] + } + ], "source": [ "settings = OptimizationSettings(rand_seed = 12345)\n", "\n", @@ -110,9 +150,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from qiskit import QuantumCircuit\n", "qc_0 = QuantumCircuit(7)\n", @@ -137,9 +189,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", + "\n", + "\n", + "\n", + "---------- 6 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 3.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=(3, 6), gamma=3.0)]}]\n", + "Subcircuits: AAAAAAB \n", + "\n", + "\n", + "\n", + "---------- 5 Qubits per QPU, 2 QPUs ----------\n", + "CircuitElement(name='cx', params=[], qubits=(3, 5), gamma=3.0) 1\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "Input wire ID 3 does not match new_circuit wire ID []", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 27\u001b[0m\n\u001b[1;32m 21\u001b[0m interface \u001b[38;5;241m=\u001b[39m SimpleGateList(circuit_ckt_wirecut)\n\u001b[1;32m 23\u001b[0m op \u001b[38;5;241m=\u001b[39m LOCutsOptimizer(interface, \n\u001b[1;32m 24\u001b[0m settings, \n\u001b[1;32m 25\u001b[0m constraint_obj)\n\u001b[0;32m---> 27\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m Gamma =\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m (out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;28;01melse\u001b[39;00m out\u001b[38;5;241m.\u001b[39mupperBoundGamma(),\n\u001b[1;32m 30\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, Min_gamma_reached =\u001b[39m\u001b[38;5;124m'\u001b[39m, op\u001b[38;5;241m.\u001b[39mminimumReached())\n\u001b[1;32m 31\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py:154\u001b[0m, in \u001b[0;36mLOCutsOptimizer.optimize\u001b[0;34m(self, circuit_interface, optimization_settings, device_constraints)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m min_cost \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbest_result \u001b[38;5;241m=\u001b[39m min_cost[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m--> 154\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbest_result\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 156\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbest_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py:447\u001b[0m, in \u001b[0;36mDisjointSubcircuitsState.exportCuts\u001b[0;34m(self, circuit_interface)\u001b[0m\n\u001b[1;32m 444\u001b[0m wire_map \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_wires)\n\u001b[1;32m 446\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m action, gate_spec, cut_args \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mactions:\n\u001b[0;32m--> 447\u001b[0m \u001b[43maction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgate_spec\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcut_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 449\u001b[0m root_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgetSubCircuitIndices()\n\u001b[1;32m 450\u001b[0m wires_to_roots \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgetWireRootMapping()\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cutting_actions.py:367\u001b[0m, in \u001b[0;36mActionCutLeftWire.exportCuts\u001b[0;34m(self, circuit_interface, wire_map, gate_spec, cut_args)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexportCuts\u001b[39m(\u001b[38;5;28mself\u001b[39m, circuit_interface, wire_map, gate_spec, cut_args):\n\u001b[1;32m 363\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Insert an LO wire cut into the input circuit for the specified\u001b[39;00m\n\u001b[1;32m 364\u001b[0m \u001b[38;5;124;03m gate and cut arguments.\u001b[39;00m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 367\u001b[0m \u001b[43minsertAllLOWireCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgate_spec\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcut_args\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cutting_actions.py:382\u001b[0m, in \u001b[0;36minsertAllLOWireCuts\u001b[0;34m(circuit_interface, wire_map, gate_spec, cut_args)\u001b[0m\n\u001b[1;32m 380\u001b[0m gate_ID \u001b[38;5;241m=\u001b[39m gate_spec[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 381\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m input_ID, wire_ID, new_wire_ID \u001b[38;5;129;01min\u001b[39;00m cut_args:\n\u001b[0;32m--> 382\u001b[0m \u001b[43mcircuit_interface\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minsertWireCut\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 383\u001b[0m \u001b[43m \u001b[49m\u001b[43mgate_ID\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minput_ID\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m[\u001b[49m\u001b[43mwire_ID\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnew_wire_ID\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLO\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 384\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/circuit_interface.py:266\u001b[0m, in \u001b[0;36mSimpleGateList.insertWireCut\u001b[0;34m(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type)\u001b[0m\n\u001b[1;32m 263\u001b[0m new_gate_spec \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnew_circuit[gate_pos]\n\u001b[1;32m 264\u001b[0m \u001b[38;5;28mprint\u001b[39m (new_gate_spec, input_ID)\n\u001b[0;32m--> 266\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m src_wire_ID \u001b[38;5;241m==\u001b[39m new_gate_spec[input_ID], (\n\u001b[1;32m 267\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput wire ID \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msrc_wire_ID\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m does not match \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnew_circuit wire ID \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnew_gate_spec[input_ID]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 269\u001b[0m )\n\u001b[1;32m 271\u001b[0m \u001b[38;5;66;03m# If the new wire does not yet exist, then define it\u001b[39;00m\n\u001b[1;32m 272\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqubit_names\u001b[38;5;241m.\u001b[39mgetName(dest_wire_ID) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mAssertionError\u001b[0m: Input wire ID 3 does not match new_circuit wire ID []" + ] + } + ], "source": [ "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", @@ -159,7 +252,7 @@ " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", " \n", " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", - " num_QPUs = num_QPUs)\n", + " num_QPUs = num_QPUs)\n", "\n", " interface = SimpleGateList(circuit_ckt_wirecut)\n", " \n", diff --git a/test/cutting/cut_finding/__init__.py b/test/cutting/cut_finding/__init__.py new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/test/cutting/cut_finding/__init__.py @@ -0,0 +1 @@ + diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py new file mode 100644 index 000000000..ea215cb18 --- /dev/null +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -0,0 +1,75 @@ +import numpy as np +from pytest import fixture, raises +from numpy import inf +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization +from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + PrintActionListWithNames, +) + + +@fixture +def testCircuit(): + circuit = [ + ("cx", 0, 1), + ("cx", 0, 2), + ("cx", 1, 2), + ("cx", 0, 3), + ("cx", 1, 3), + ("cx", 2, 3), + ("cx", 4, 5), + ("cx", 4, 6), + ("cx", 5, 6), + ("cx", 4, 7), + ("cx", 5, 7), + ("cx", 6, 7), + ("cx", 3, 4), + ("cx", 3, 5), + ("cx", 3, 6), + ("cx", 0, 1), + ("cx", 0, 2), + ("cx", 1, 2), + ("cx", 0, 3), + ("cx", 1, 3), + ("cx", 2, 3), + ("cx", 4, 5), + ("cx", 4, 6), + ("cx", 5, 6), + ("cx", 4, 7), + ("cx", 5, 7), + ("cx", 6, 7), + ] + interface = SimpleGateList(circuit) + return interface + + +def test_BestFirstSearch(testCircuit): + settings = OptimizationSettings(rand_seed=12345) + + settings.setEngineSelection("CutOptimization", "BestFirst") + + constraint_obj = DeviceConstraints(qubits_per_QPU=4, num_QPUs=2) + + op = CutOptimization(testCircuit, settings, constraint_obj) + + out, _ = op.optimizationPass() + + assert op.search_engine.getStats() is not None + assert op.getUpperBoundCost() == (27, inf) + assert op.minimumReached() == False + assert out is not None + assert (out.lowerBoundGamma(), out.gamma_UB, out.getMaxWidth()) == (15, 27, 4) + assert PrintActionListWithNames(out.actions) == [ + ["CutTwoQubitGate", [12, ["cx", 3, 4], None], ((1, 3), (2, 4))], + ["CutTwoQubitGate", [13, ["cx", 3, 5], None], ((1, 3), (2, 5))], + ["CutTwoQubitGate", [14, ["cx", 3, 6], None], ((1, 3), (2, 6))], + ] + + out, _ = op.optimizationPass() + + assert op.search_engine.getStats() is not None + assert op.getUpperBoundCost() == (27, inf) + assert op.minimumReached() == True + assert out is None diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py new file mode 100644 index 000000000..cf702df0c --- /dev/null +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -0,0 +1,116 @@ +import pytest +from pytest import fixture +from qiskit.circuit.library import EfficientSU2 +from qiskit import QuantumCircuit, QuantumRegister +from qiskit.circuit import Qubit, Instruction, CircuitInstruction +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit, CCOtoQCCircuit + +# test circuit 1. +tc_1 = QuantumCircuit(2) +tc_1.h(1) +tc_1.barrier(1) +tc_1.s(0) +tc_1.barrier() +tc_1.cx(1, 0) + +# test circuit 2 +tc_2 = EfficientSU2(2, entanglement="linear", reps=2).decompose() +tc_2.assign_parameters([0.4] * len(tc_2.parameters), inplace=True) + + +# test circuit 3 +@fixture +def InternalTestCircuit(): + circuit = [ + ("cx", 0, 1), + ("cx", 2, 3), + ("cx", 1, 2), + ("cx", 0, 1), + ("cx", 2, 3), + ("h", 0), + (("rx", 0.4), 0), + ] + interface = SimpleGateList(circuit) + interface.insertGateCut(2, "LO") + interface.defineSubcircuits([[0, 1], [2, 3]]) + return interface + + +@pytest.mark.parametrize( + "test_circuit, known_output", + [ + (tc_1, [("h", 1), ("barrier", 1), ("s", 0), "barrier", ("cx", 1, 0)]), + ( + tc_2, + [ + (("ry", 0.4), 0), + (("rz", 0.4), 0), + (("ry", 0.4), 1), + (("rz", 0.4), 1), + ("cx", 0, 1), + (("ry", 0.4), 0), + (("rz", 0.4), 0), + (("ry", 0.4), 1), + (("rz", 0.4), 1), + ("cx", 0, 1), + (("ry", 0.4), 0), + (("rz", 0.4), 0), + (("ry", 0.4), 1), + (("rz", 0.4), 1), + ], + ), + ], +) +def test_QCtoCCOCircuit(test_circuit, known_output): + test_circuit_internal = QCtoCCOCircuit(test_circuit) + assert test_circuit_internal == known_output + + +# TODO: Expand test below to cover the wire cutting case. +def test_CCOtoQCCircuit(InternalTestCircuit): + qc_cut = CCOtoQCCircuit(InternalTestCircuit) + assert qc_cut.data == [ + CircuitInstruction( + operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), + qubits=( + Qubit(QuantumRegister(4, "q"), 0), + Qubit(QuantumRegister(4, "q"), 1), + ), + clbits=(), + ), + CircuitInstruction( + operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), + qubits=( + Qubit(QuantumRegister(4, "q"), 2), + Qubit(QuantumRegister(4, "q"), 3), + ), + clbits=(), + ), + CircuitInstruction( + operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), + qubits=( + Qubit(QuantumRegister(4, "q"), 0), + Qubit(QuantumRegister(4, "q"), 1), + ), + clbits=(), + ), + CircuitInstruction( + operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), + qubits=( + Qubit(QuantumRegister(4, "q"), 2), + Qubit(QuantumRegister(4, "q"), 3), + ), + clbits=(), + ), + CircuitInstruction( + operation=Instruction(name="h", num_qubits=1, num_clbits=0, params=[]), + qubits=(Qubit(QuantumRegister(4, "q"), 0),), + clbits=(), + ), + CircuitInstruction( + operation=Instruction(name="rx", num_qubits=1, num_clbits=0, params=[0.4]), + qubits=(Qubit(QuantumRegister(4, "q"), 0),), + clbits=(), + ), + ] diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py new file mode 100644 index 000000000..73afc1e65 --- /dev/null +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -0,0 +1,120 @@ +import numpy as np +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList + + +class TestCircuitInterface: + def test_CircuitConversion(self): + """Test conversion of circuits to the internal representation + used by the circuit-cutting optimizer. + """ + + trial_circuit = [ + ("h", "q1"), + ("barrier", "q1"), + ("s", "q0"), + "barrier", + ("cx", "q1", "q0"), + ] + circuit_converted = SimpleGateList(trial_circuit) + + assert circuit_converted.getNumQubits() == 2 + assert circuit_converted.getNumWires() == 2 + assert circuit_converted.qubit_names.item_dict == {"q1": 0, "q0": 1} + assert circuit_converted.getMultiQubitGates() == [[4, ["cx", 0, 1], None]] + assert circuit_converted.circuit == [ + [["h", 0], None], + [["barrier", 0], None], + [["s", 1], None], + ["barrier", None], + [["cx", 0, 1], None], + ] + + def test_GateCutInterface(self): + """Test the internal representation of LO gate cuts.""" + + trial_circuit = [ + ("cx", 0, 1), + ("cx", 2, 3), + ("cx", 1, 2), + ("cx", 0, 1), + ("cx", 2, 3), + ] + circuit_converted = SimpleGateList(trial_circuit) + circuit_converted.insertGateCut(2, "LO") + circuit_converted.defineSubcircuits([[0, 1], [2, 3]]) + + assert list(circuit_converted.new_gate_ID_map) == [0, 1, 2, 3, 4] + assert circuit_converted.cut_type == [None, None, "LO", None, None] + assert ( + circuit_converted.exportSubcircuitsAsString(name_mapping="default") + == "AABB" + ) + assert circuit_converted.exportCutCircuit(name_mapping="default") == [ + ["cx", 0, 1], + ["cx", 2, 3], + ["cx", 1, 2], + ["cx", 0, 1], + ["cx", 2, 3], + ] + + # the following two methods are the same in the absence of wire cuts. + assert ( + list(circuit_converted.exportOutputWires(name_mapping="default")) + == list(circuit_converted.exportOutputWires(name_mapping=None)) + == [0, 1, 2, 3] + ) + + def test_WireCutInterface(self): + """Test the internal representation of LO wire cuts.""" + + trial_circuit = [ + ("cx", 0, 1), + ("cx", 2, 3), + ("cx", 1, 2), + ("cx", 0, 1), + ("cx", 2, 3), + ] + circuit_converted = SimpleGateList(trial_circuit) + circuit_converted.insertWireCut( + 2, 1, 1, 4, "LO" + ) # cut first input wire of trial_circuit[2] and map it to wire id 4. + assert list(circuit_converted.output_wires) == [0, 4, 2, 3] + + assert circuit_converted.cut_type[2] == "LO" + + # the missing gate 2 corresponds to a move operation + assert list(circuit_converted.new_gate_ID_map) == [0, 1, 3, 4, 5] + + assert circuit_converted.exportCutCircuit(name_mapping=None) == [ + ["cx", 0, 1], + ["cx", 2, 3], + ["move", 1, ("cut", 1)], + ["cx", ("cut", 1), 2], + ["cx", 0, ("cut", 1)], + ["cx", 2, 3], + ] + + # relabel wires after wire cuts according to 'None' name_mapping. + assert circuit_converted.exportOutputWires(name_mapping=None) == { + 0: 0, + 1: ("cut", 1), + 2: 2, + 3: 3, + } + + assert circuit_converted.exportCutCircuit(name_mapping="default") == [ + ["cx", 0, 1], + ["cx", 3, 4], + ["move", 1, 2], + ["cx", 2, 3], + ["cx", 0, 2], + ["cx", 3, 4], + ] + + # relabel wires after wire cuts according to 'default' name_mapping. + assert circuit_converted.exportOutputWires(name_mapping="default") == { + 0: 0, + 1: 2, + 2: 3, + 3: 4, + } diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py new file mode 100644 index 000000000..9298a738b --- /dev/null +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -0,0 +1,128 @@ +import numpy as np +from numpy import array +from pytest import fixture, raises +from qiskit import QuantumCircuit +from qiskit.circuit.library import EfficientSU2 +from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + PrintActionListWithNames, +) +from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer + + +@fixture +def gate_cut_test_setup(): + qc = EfficientSU2(4, entanglement="linear", reps=2).decompose() + qc.assign_parameters([0.4] * len(qc.parameters), inplace=True) + circuit_internal = QCtoCCOCircuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(rand_seed=12345) + settings.setEngineSelection("CutOptimization", "BestFirst") + return interface, settings + + +@fixture +def wire_cut_test_setup(): + qc = QuantumCircuit(7) + for i in range(7): + qc.rx(np.pi / 4, i) + qc.cx(0, 3) + qc.cx(1, 3) + qc.cx(2, 3) + qc.cx(3, 4) + qc.cx(3, 5) + qc.cx(3, 6) + circuit_internal = QCtoCCOCircuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(rand_seed=12345) + settings.setEngineSelection("CutOptimization", "BestFirst") + return interface, settings + + +def test_no_cuts(gate_cut_test_setup): + # QPU with 4 qubits requires no cutting. + qubits_per_QPU = 4 + num_QPUs = 2 + + interface, settings = gate_cut_test_setup + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize(interface, settings, constraint_obj) + + # assert optimization_pass.best_result == None #no cutting. + + print(optimization_pass.best_result) + + assert PrintActionListWithNames(output.actions) == [] + + assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" + + +def test_GateCuts(gate_cut_test_setup): + # QPU with 2 qubits requires cutting. + qubits_per_QPU = 2 + num_QPUs = 2 + + interface, settings = gate_cut_test_setup + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + best_result = optimization_pass.getResults() + + assert output.upperBoundGamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. + + assert optimization_pass.minimumReached() == True # matches optimal solution. + + assert ( + interface.exportSubcircuitsAsString(name_mapping="default") == "AABB" + ) # circuit separated into 2 subcircuits. + + assert ( + optimization_pass.getStats()["CutOptimization"] == array([15, 46, 15, 6]) + ).all() # matches known stats. + + +def test_WireCuts(wire_cut_test_setup): + qubits_per_QPU = 4 + num_QPUs = 2 + + interface, settings = wire_cut_test_setup + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + best_result = optimization_pass.getResults() + + assert output.upperBoundGamma() == best_result.gamma_UB == 4 # One LO wire cut. + + assert optimization_pass.minimumReached() == True # matches optimal solution + + +def test_selectSearchEngine(gate_cut_test_setup): + qubits_per_QPU = 4 + num_QPUs = 2 + + interface, settings = gate_cut_test_setup + + # check if unsupported search engine is flagged. + settings.setEngineSelection("CutOptimization", "BeamSearch") + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + with raises(ValueError): + _ = optimization_pass.optimize() diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py new file mode 100644 index 000000000..c1563f8c7 --- /dev/null +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -0,0 +1,115 @@ +from pytest import fixture +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.cutting_actions import ( + ActionApplyGate, + ActionCutTwoQubitGate, + ActionCutLeftWire, + ActionCutRightWire, +) +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + DisjointSubcircuitsState, + PrintActionListWithNames, +) +from circuit_knitting.cutting.cut_finding.search_space_generator import ActionNames + + +@fixture +def testCircuit(): + circuit = [ + ("h", "q1"), + ("s", "q0"), + ("cx", "q1", "q0"), + ] + + interface = SimpleGateList(circuit) + + # initialize DisjointSubcircuitsState object. + state = DisjointSubcircuitsState(interface.getNumQubits(), 2) + + two_qubit_gate = interface.getMultiQubitGates()[0] + + return interface, state, two_qubit_gate + + +def test_ActionApplyGate(testCircuit): + """Test the application of a gate without any cutting actions.""" + + _, state, two_qubit_gate = testCircuit + apply_gate = ActionApplyGate() + assert apply_gate.getName() == None + assert apply_gate.getGroupNames() == [None, "TwoQubitGates", "MultiqubitGates"] + + updated_state = apply_gate.nextStatePrimitive(state, two_qubit_gate, 2) + actions_list = [] + for state in updated_state: + actions_list.extend(state.actions) + assert actions_list == [] # no actions when the gate is simply applied. + + +def test_CutTwoQubitGate(testCircuit): + """Test the action of cutting a two qubit gate.""" + + interface, state, two_qubit_gate = testCircuit + cut_gate = ActionCutTwoQubitGate() + assert cut_gate.getName() == "CutTwoQubitGate" + assert cut_gate.getGroupNames() == ["GateCut", "TwoQubitGates"] + + updated_state = cut_gate.nextStatePrimitive(state, two_qubit_gate, 2) + actions_list = [] + for state in updated_state: + actions_list.extend(PrintActionListWithNames(state.actions)) + assert actions_list == [ + ["CutTwoQubitGate", [2, ["cx", 0, 1], None], ((1, 0), (2, 1))] + ] + + assert cut_gate.getCostParams(two_qubit_gate) == ( + 1, + 1, + 3, + ) # check if reproduces the parameters for a CNOT. + + cut_gate.exportCuts( + interface, None, two_qubit_gate, None + ) # insert cut in circuit interface. + assert interface.cut_type[2] == "LO" + + +def test_CutLeftWire(testCircuit): + """Test the action of cutting the first (left) input wire to a two qubit gate.""" + _, state, two_qubit_gate = testCircuit + cut_left_wire = ActionCutLeftWire() + assert cut_left_wire.getName() == "CutLeftWire" + assert cut_left_wire.getGroupNames() == ["WireCut", "TwoQubitGates"] + + updated_state = cut_left_wire.nextStatePrimitive(state, two_qubit_gate, 3) + actions_list = [] + for state in updated_state: + actions_list.extend(PrintActionListWithNames(state.actions)) + assert actions_list[0][0] == "CutLeftWire" + assert actions_list[0][1][1] == ["cx", 0, 1] + assert actions_list[0][2][0][0] == 1 # the first input ('left') wire is cut. + + +def test_CutRightWire(testCircuit): + """Test the action of cutting the second (right) input wire to a two qubit gate.""" + _, state, two_qubit_gate = testCircuit + cut_right_wire = ActionCutRightWire() + assert cut_right_wire.getName() == "CutRightWire" + assert cut_right_wire.getGroupNames() == ["WireCut", "TwoQubitGates"] + + updated_state = cut_right_wire.nextStatePrimitive(state, two_qubit_gate, 3) + actions_list = [] + for state in updated_state: + actions_list.extend(PrintActionListWithNames(state.actions)) + assert actions_list[0][0] == "CutRightWire" + assert actions_list[0][1][1] == ["cx", 0, 1] + assert actions_list[0][2][0][0] == 2 # the second input ('right') wire is cut + + +def test_DefinedActions(): + # Check that unsupported cutting actions return None + # when the action or corresponding group is requested. + + assert ActionNames().getAction("LOCCGateCut") == None + + assert ActionNames().getGroup("LOCCCUTS") == None diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py new file mode 100644 index 000000000..63b73e4ab --- /dev/null +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -0,0 +1,241 @@ +import io, sys +from pytest import mark, raises, fixture +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + DisjointSubcircuitsState, +) +from circuit_knitting.cutting.cut_finding.cut_optimization import ( + disjoint_subcircuit_actions, +) + +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + PrintActionListWithNames, +) + +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import calcRootBellPairsGamma + + +@mark.parametrize("num_qubits, max_wire_cuts", [(2.1, 1.2), (None, -1), (-1, None)]) +def test_StateInitialization(num_qubits, max_wire_cuts): + """Test device constraints for being valid data types.""" + + with raises(ValueError): + _ = DisjointSubcircuitsState(num_qubits, max_wire_cuts) + + +@fixture +def testCircuit(): + circuit = [ + ("h", "q1"), + ("barrier", "q1"), + ("s", "q0"), + "barrier", + ("cx", "q1", "q0"), + ] + + interface = SimpleGateList(circuit) + + # initialize DisjointSubcircuitsState object. + state = DisjointSubcircuitsState(interface.getNumQubits(), 2) + + two_qubit_gate = interface.getMultiQubitGates()[0] + + return state, two_qubit_gate + + +def test_StateUncut(testCircuit): + state, _ = testCircuit + + assert list(state.wiremap) == [0, 1] + + assert state.num_wires == 2 + + assert state.getNumQubits() == 2 + + assert list(state.uptree) == [0, 1, 2, 3] + + assert list(state.width) == [1, 1, 1, 1] + + assert list(state.no_merge) == [] + + assert state.getSearchLevel() == 0 + + # print_output = test_prints(state.print(simple=True)) + + # assert print_output == [] + + +def test_ApplyGate(testCircuit): + state, two_qubit_gate = testCircuit + + next_state = disjoint_subcircuit_actions.getAction(None).nextState( + state, two_qubit_gate, 10 + )[0] + + assert list(next_state.wiremap) == [0, 1] + + assert next_state.num_wires == 2 + + assert next_state.findQubitRoot(1) == 0 + + assert next_state.getWireRootMapping() == [0, 0] + + assert list(next_state.uptree) == [0, 0, 2, 3] + + assert list(next_state.width) == [2, 1, 1, 1] + + assert list(next_state.no_merge) == [] + + assert next_state.getSearchLevel() == 1 + + +def test_CutGate(testCircuit): + state, two_qubit_gate = testCircuit + + next_state = disjoint_subcircuit_actions.getAction("CutTwoQubitGate").nextState( + state, two_qubit_gate, 10 + )[0] + + assert list(next_state.wiremap) == [0, 1] + + assert next_state.checkDoNotMergeRoots(0, 1) == True + + assert next_state.num_wires == 2 + + assert state.getNumQubits() == 2 + + assert next_state.getWireRootMapping() == [0, 1] + + assert list(next_state.uptree) == [0, 1, 2, 3] + + assert list(next_state.width) == [1, 1, 1, 1] + + assert list(next_state.no_merge) == [(0, 1)] + + assert next_state.getSearchLevel() == 1 + + assert next_state.lowerBoundGamma() == 3 # one CNOT cut. + + assert ( + next_state.upperBoundGamma() == 3 + ) # equal to lowerBoundGamma for single gate cuts. + + +def test_CutLeftWire(testCircuit): + state, two_qubit_gate = testCircuit + + next_state = disjoint_subcircuit_actions.getAction("CutLeftWire").nextState( + state, two_qubit_gate, 10 + )[0] + + assert list(next_state.wiremap) == [ + 2, + 1, + ] # qubit 0 is mapped onto wire ID 2 after cut. + + assert next_state.num_wires == 3 + + assert state.getNumQubits() == 2 + + assert next_state.canExpandSubcircuit(1, 1, 2) == False + + assert next_state.canExpandSubcircuit(1, 1, 3) == True + + assert next_state.canAddWires(2) == False + + assert next_state.getWireRootMapping() == [0, 1, 1] + + assert next_state.checkDoNotMergeRoots(0, 1) == True + + assert list(next_state.uptree) == [0, 1, 1, 3] + + assert list(next_state.width) == [1, 2, 1, 1] + + assert list(next_state.no_merge) == [(0, 1)] + + assert next_state.getMaxWidth() == 2 + + assert next_state.findQubitRoot(0) == 1 + + assert next_state.getSearchLevel() == 1 + + assert next_state.lowerBoundGamma() == 3 + + assert next_state.upperBoundGamma() == 4 + + +def test_CutRightWire(testCircuit): + state, two_qubit_gate = testCircuit + + next_state = disjoint_subcircuit_actions.getAction("CutRightWire").nextState( + state, two_qubit_gate, 10 + )[0] + + assert list(next_state.wiremap) == [ + 0, + 2, + ] # qubit 1 is mapped onto wire ID 2 after cut. + + assert next_state.num_wires == 3 + + assert state.getNumQubits() == 2 + + assert next_state.canAddWires(1) == True + + assert next_state.getWireRootMapping() == [0, 1, 0] + + assert next_state.checkDoNotMergeRoots(0, 1) == True + + assert list(next_state.uptree) == [0, 1, 0, 3] + + assert list(next_state.width) == [2, 1, 1, 1] + + assert list(next_state.no_merge) == [(0, 1)] + + assert next_state.findQubitRoot(1) == 0 + + assert next_state.getSearchLevel() == 1 + + +def test_CutBothWires(testCircuit): + state, two_qubit_gate = testCircuit + + next_state = disjoint_subcircuit_actions.getAction("CutBothWires").nextState( + state, two_qubit_gate, 10 + )[0] + + assert list(next_state.wiremap) == [2, 3] + + assert next_state.canAddWires(1) == False + + assert next_state.num_wires == 4 + + assert state.getNumQubits() == 2 + + assert next_state.getWireRootMapping() == [0, 1, 2, 2] + + assert ( + next_state.checkDoNotMergeRoots(0, 2) + == next_state.checkDoNotMergeRoots(1, 2) + == True + ) + + assert list(next_state.uptree) == [0, 1, 2, 2] + + assert list(next_state.width) == [1, 1, 2, 1] + + assert list(next_state.no_merge) == [(0, 2), (1, 3)] + + assert next_state.findQubitRoot(0) == 2 # maps to third wire initialized after cut. + + assert ( + next_state.findQubitRoot(1) == 2 + ) # maps to third wire because of the entangling gate. + + assert next_state.getSearchLevel() == 1 + + assert next_state.lowerBoundGamma() == 9 # 3^n scaling. + + assert next_state.upperBoundGamma() == 16 # 4^n scaling. + + assert next_state.verifyMergeConstraints() == True diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py new file mode 100644 index 000000000..caaeafaad --- /dev/null +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -0,0 +1,37 @@ +import pytest +from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings + + +@pytest.mark.parametrize( + "max_gamma, max_backjumps ", + [(2.1, 1), (2, 1.2), (0, 1), (-1, 0)], +) +def test_OptimizationParameters(max_gamma, max_backjumps): + """Test optimization parameters for being valid data types.""" + + with pytest.raises(ValueError): + _ = OptimizationSettings(max_gamma=max_gamma, max_backjumps=max_backjumps) + + +def test_GateCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): + """Test default gate cut types.""" + op = OptimizationSettings() + op.setGateCutTypes() + assert op.gate_cut_LO == True + assert op.gate_cut_LOCC_with_ancillas == False + + +def test_WireCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): + """Test default wire cut types.""" + op = OptimizationSettings() + op.setWireCutTypes() + assert op.wire_cut_LO + assert op.wire_cut_LOCC_with_ancillas == False + assert op.wire_cut_LOCC_no_ancillas == False + + +def test_AllCutSearchGroups(): + """Test for the existence of all Cut search groups.""" + assert OptimizationSettings( + LO=True, LOCC_ancillas=True, LOCC_no_ancillas=True + ).getCutSearchGroups() == [None, "GateCut", "WireCut"] diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py new file mode 100644 index 000000000..cd5dbe6c3 --- /dev/null +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -0,0 +1,19 @@ +import pytest +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints + + +@pytest.mark.parametrize( + "qubits_per_QPU, num_QPUs", [(2.1, 1.2), (1.2, 0), (-1, 1), (1, 0)] +) +def test_DeviceConstraints(qubits_per_QPU, num_QPUs): + """Test device constraints for being valid data types.""" + + with pytest.raises(ValueError): + _ = DeviceConstraints(qubits_per_QPU, num_QPUs) + + +@pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(2, 4), (1, 3)]) +def test_getQPUWidth(qubits_per_QPU, num_QPUs): + """Test that getQPUWidth returns number of qubits per qpu.""" + + assert DeviceConstraints(qubits_per_QPU, num_QPUs).getQPUWidth() == qubits_per_QPU From 1c87d3de0f9a584d00fcfbea9ca33f9708423ef1 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 14:34:52 -0600 Subject: [PATCH 028/128] rebase conflict --- circuit_knitting/cutting/__init__.py | 3 +++ .../cutting/cut_finding/__init__.py | 1 + .../cutting/cut_finding/cut_finding.py | 19 +++++++++++++ .../tutorials/LO_circuit_cut_finder.ipynb | 27 +++++++++---------- 4 files changed, 36 insertions(+), 14 deletions(-) create mode 100644 circuit_knitting/cutting/cut_finding/cut_finding.py diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index 268123d27..55cbed2d4 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -21,6 +21,7 @@ :toctree: ../stubs/ :nosignatures: + find_cuts cut_wires expand_observables partition_circuit_qubits @@ -80,6 +81,7 @@ cutqc.reconstruct_full_distribution """ +from .cut_finding import find_cuts from .cutting_decomposition import ( partition_circuit_qubits, partition_problem, @@ -93,6 +95,7 @@ from .wire_cutting_transforms import cut_wires, expand_observables __all__ = [ + "find_cuts", "partition_circuit_qubits", "partition_problem", "cut_gates", diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index e69de29bb..88a79e9b2 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -0,0 +1 @@ +from .cut_finding import find_cuts diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py new file mode 100644 index 000000000..e9427bd34 --- /dev/null +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -0,0 +1,19 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2023. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Automatically find cut locations in a quantum circuit.""" + +from __future__ import annotations + +from qiskit import QuantumCircuit + +def find_cuts(circuit: QuantumCircuit): + pass diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index f8ca26be2..0cf6dbe54 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -29,17 +29,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -53,9 +53,7 @@ "\n", "circuit_ckt=QCtoCCOCircuit(qc)\n", "\n", - "qc.draw(\"mpl\", scale=0.8)\n", - "\n", - "\n" + "qc.draw(\"mpl\", scale=0.8)" ] }, { @@ -67,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -78,21 +76,21 @@ "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", + "Actions: []\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + "Actions: [['CutTwoQubitGate', [17, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [25, ['cx', 2, 3], None], ((1, 2), (2, 3))]]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + "Actions: [['CutTwoQubitGate', [9, ['cx', 1, 2], None], ((1, 1), (2, 2))], ['CutTwoQubitGate', [20, ['cx', 1, 2], None], ((1, 1), (2, 2))]]\n", "Subcircuits: AABB \n", "\n" ] @@ -115,7 +113,8 @@ " \n", " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", " num_QPUs = num_QPUs)\n", - " \n", + "\n", + " find_cuts(qc, opt_settings, constraints)\n", " interface = SimpleGateList(circuit_ckt)\n", "\n", " op = LOCutsOptimizer(interface, \n", @@ -283,7 +282,7 @@ ], "metadata": { "kernelspec": { - "display_name": "cco", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -297,9 +296,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.8.16" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 5957759ef978d10b085e27cd5ed6d186e85422d6 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 11:04:31 -0600 Subject: [PATCH 029/128] Add license blurbs --- .../cutting/cut_finding/best_first_search.py | 14 +++++++++++++- .../cutting/cut_finding/circuit_interface.py | 15 +++++++++++++-- .../cutting/cut_finding/cut_finding.py | 2 +- .../cutting/cut_finding/cut_optimization.py | 14 +++++++++++++- .../cutting/cut_finding/cutting_actions.py | 16 ++++++++++++++-- .../cut_finding/disjoint_subcircuits_state.py | 14 +++++++++++++- .../cutting/cut_finding/lo_cuts_optimizer.py | 12 ++++++++++++ .../cutting/cut_finding/optimization_settings.py | 13 ++++++++++++- .../cut_finding/quantum_device_constraints.py | 13 ++++++++++++- .../cut_finding/search_space_generator.py | 13 ++++++++++++- circuit_knitting/cutting/cut_finding/utils.py | 14 +++++++++++++- 11 files changed, 128 insertions(+), 12 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index b261400d8..d3a3ab7e5 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -1,4 +1,16 @@ -"""File containing the classes required to implement Dijkstra's (best-first) search algorithm.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes required to implement Dijkstra's (best-first) search algorithm.""" + import heapq import numpy as np from itertools import count diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 2507aba40..8c7800026 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -1,5 +1,16 @@ -"""File containing the classes required to represent quantum circuits in a format - native to the circuit cutting optimizer.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Quantum circuit representation compatible with cut-finding optimizers.""" + import copy import string import numpy as np diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index e9427bd34..16fdc9b00 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -1,6 +1,6 @@ # This code is a Qiskit project. -# (C) Copyright IBM 2023. +# (C) Copyright IBM 2024. # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 33c995b13..475853733 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -1,4 +1,16 @@ -""" File containing the classes required to search for optimal cut locations.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes required to search for optimal cut locations.""" + import numpy as np from .utils import selectSearchEngine, greedyBestFirstSearch from .cutting_actions import disjoint_subcircuit_actions diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 70236c0fd..4daa48336 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -1,9 +1,21 @@ -""" File containing classes needed to implement the actions involved in circuit cutting.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes needed to implement the actions involved in circuit cutting.""" + import numpy as np from abc import ABC, abstractmethod from .search_space_generator import ActionNames -### This is an object that holds action names for constructing disjoint subcircuits +# Object that holds action names for constructing disjoint subcircuits disjoint_subcircuit_actions = ActionNames() diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 165960ef3..9a991ec1d 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -1,4 +1,16 @@ -"""File containing the class needed for representing search-space states when cutting circuits.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class needed for representing search-space states when cutting circuits.""" + import copy import numpy as np from collections import Counter, namedtuple diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 16b50cb02..8be8a3521 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -1,4 +1,16 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + """File containing the wrapper class for optimizing LO gate and wire cuts.""" + from .cut_optimization import CutOptimization from .cut_optimization import disjoint_subcircuit_actions from .cut_optimization import CutOptimizationNextStateFunc diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 3a6d3c89a..656e32af8 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -1,4 +1,15 @@ -"""File containing class for specifying parameters that control the optimization.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class for specifying parameters that control the optimization.""" class OptimizationSettings: diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index bf7f2383e..237aa4e0f 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -1,4 +1,15 @@ -"""File containing the class used for specifying characteristics of the target QPU.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Class used for specifying characteristics of the target QPU.""" class DeviceConstraints: diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index cd1508a88..535a6744a 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -1,4 +1,15 @@ -"""File containing the classes needed to generate and explore a search space.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes needed to generate and explore a search space.""" class ActionNames: diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 11d3ec34a..2e41d1449 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -1,4 +1,16 @@ -"""File containing helper functions that are used in the code.""" +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Helper functions that are used in the code.""" + from qiskit import QuantumCircuit from qiskit.circuit import Instruction from .best_first_search import BestFirstSearch From b257039d06104193399504329a0247c1abb231fe Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 11:07:16 -0600 Subject: [PATCH 030/128] black errors --- circuit_knitting/cutting/cut_finding/cut_finding.py | 10 +++++++++- .../cutting/cut_finding/disjoint_subcircuits_state.py | 6 +++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 16fdc9b00..b1f01f779 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -15,5 +15,13 @@ from qiskit import QuantumCircuit -def find_cuts(circuit: QuantumCircuit): +from .optimization_settings import OptimizationSettings +from .quantum_device_constraints import DeviceConstraints + + +def find_cuts( + circuit: QuantumCircuit, + optimization: OptimizationSettings | dict[str, str | int], + constraints: DeviceConstraints | dict[str, int], +): pass diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 9a991ec1d..5d24c6158 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -176,13 +176,14 @@ def print(self, simple=False): # ) # elif (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): - cut_actions = PrintActionListWithNames(self.actions) cut_actions_sublist = [] # Output formatting for LO gate and wire cuts. for i in range(len(cut_actions)): - if (cut_actions[i][0] == "CutLeftWire") or (cut_actions[i][0] == ("CutRightWire")): + if (cut_actions[i][0] == "CutLeftWire") or ( + cut_actions[i][0] == ("CutRightWire") + ): cut_actions_sublist.append( { "Cut action": cut_actions[i][0], @@ -473,7 +474,6 @@ def exportCuts(self, circuit_interface): scc_order = np.zeros((len(scc_subcircuits), len(scc_subcircuits)), dtype=bool) - def calcRootBellPairsGamma(root_bell_pairs): """Calculate the minimum-achievable LOCC gamma for circuit cuts that utilize virtual Bell pairs. The input can be a list From 41861e5cbca11920501bc4beb41689c58039f121 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 13:15:35 -0500 Subject: [PATCH 031/128] clean up notebook with updated print method --- .../cutting/cut_finding/circuit_interface.py | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 8c7800026..efbb74c9a 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -80,8 +80,10 @@ def getMultiQubitGates(self): @abstractmethod def insertGateCut(self, gate_ID, cut_type): """Derived classes must override this function and mark the specified - gate as being cut. The cut type can be "LO", "LOCCWithAncillas", - or "LOCCNoAncillas".""" + gate as being cut. The cut type can only be "LO" in this release. + In the future, support for "LOCCWithAncillas" and "LOCCNoAncillas". + will be added. + """ assert False, "Derived classes must override insertGateCut()" @@ -94,7 +96,9 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): is also provided as input to allow the wire choice to be verified. The ID of the new wire/qubit is also provided, which can then be used internally in derived classes to create new wires/qubits as needed. - The cut type can be "LO", "LOCCWithAncillas", or "LOCCNoAncillas".""" + The cut type can only be "LO" in this release. In the future, support + for "LOCCWithAncillas" and "LOCCNoAncillas" will be added. + """ assert False, "Derived classes must override insertWireCut()" @@ -105,7 +109,8 @@ def insertParallelWireCut(self, list_of_wire_cuts): list_of_wire_cuts must be a list of wire-cut quadruples of the form: [..., (, , , ), ...] - The assumed cut type is "LOCCNoAncillas".""" + The assumed cut type is "LOCCNoAncillas". + """ assert False, "Derived classes must override insertParallelWireCut()" @@ -113,7 +118,8 @@ def insertParallelWireCut(self, list_of_wire_cuts): def defineSubcircuits(self, list_of_list_of_wires): """Derived classes must override this function. The input is a list of subcircuits where each subcircuit is specified as a - list of wire IDs.""" + list of wire IDs. + """ assert False, "Derived classes must override defineSubcircuits()" @@ -208,12 +214,12 @@ def __init__(self, input_circuit, init_qubit_names=[]): ) def getNumQubits(self): - """Return the number of qubits in the input circuit""" + """Return the number of qubits in the input circuit.""" return self.num_qubits def getNumWires(self): - """Return the number of wires/qubits in the cut circuit""" + """Return the number of wires/qubits in the cut circuit.""" return self.qubit_names.getNumItems() @@ -355,13 +361,13 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - print('wire_map:', wire_map) + # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase print('getNumWires:', out) for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - print('subcircuits:', self.subcircuits) + # print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): From 99c5259b13b296cd2b742a658c17854a1d10d206 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 13:33:20 -0500 Subject: [PATCH 032/128] clean up printed output in tutorial --- docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 0cf6dbe54..2b68bd11a 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -83,7 +83,6 @@ "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "Actions: [['CutTwoQubitGate', [17, ['cx', 2, 3], None], ((1, 2), (2, 3))], ['CutTwoQubitGate', [25, ['cx', 2, 3], None], ((1, 2), (2, 3))]]\n", "Subcircuits: AAAB \n", "\n", "\n", From 4460c538ba3582f321a898f045e739289396d554 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 19:33:27 -0500 Subject: [PATCH 033/128] edit string output function --- circuit_knitting/cutting/cut_finding/circuit_interface.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index efbb74c9a..111e52df8 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -361,13 +361,11 @@ def exportSubcircuitsAsString(self, name_mapping="default"): wire_map = self.makeWireMapping(name_mapping) out = list(range(self.getNumWires())) - # print('wire_map:', wire_map) alphabet = string.ascii_uppercase + string.ascii_lowercase print('getNumWires:', out) for k, subcircuit in enumerate(self.subcircuits): for wire in subcircuit: out[wire_map[wire]] = alphabet[k] - # print('subcircuits:', self.subcircuits) return "".join(out) def makeWireMapping(self, name_mapping): From 3e88ed9cad2e27be679f6053211ad8c123773990 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 12:34:36 -0600 Subject: [PATCH 034/128] Add find_cuts tutorial --- .../tutorials/04_automatic_cut_finding.ipynb | 247 ++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb new file mode 100644 index 000000000..24558a509 --- /dev/null +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -0,0 +1,247 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatically find cuts using CKT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit.library import EfficientSU2\n", + "\n", + "circ = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", + "circ.assign_parameters([0.4] * len(circ.parameters), inplace=True)\n", + "\n", + "circ.draw(\"mpl\", scale=0.8, style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", + "Subcircuits: AAAB \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", + "Subcircuits: AABB \n", + "\n" + ] + } + ], + "source": [ + "from circuit_knitting.cutting import find_cuts\n", + "\n", + "# Specify settings for the cut-finding optimizer\n", + "optimization_settings = {\"rand_seed\": 12345}\n", + "\n", + "# Specify the size and number of the QPUs available\n", + "qubits_per_qpu = 4\n", + "num_qpus = 2\n", + "device_constraints = {\"qubits_per_QPU\": qubits_per_qpu, \"num_QPUs\": num_qpus}\n", + "\n", + "for num in range(num_qpus, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", + " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", + " find_cuts(circ, optimization_settings, device_constraints)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cut finding for 7 qubit circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "from qiskit import QuantumCircuit\n", + "\n", + "circ2 = QuantumCircuit(7)\n", + "for i in range(7):\n", + " circ2.rx(np.pi / 4, i)\n", + "circ2.cx(0, 3)\n", + "circ2.cx(1, 3)\n", + "circ2.cx(2, 3)\n", + "circ2.cx(3, 4)\n", + "circ2.cx(3, 5)\n", + "circ2.cx(3, 6)\n", + "\n", + "circ2.draw(\"mpl\", scale=0.8, style=\"iqp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform cut finding" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", + "\n", + "\n", + "\n", + "---------- 6 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 3.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: AAAAAAB \n", + "\n", + "\n", + "\n", + "---------- 5 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABABB \n", + "\n", + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABBBB \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 16.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", + "Subcircuits: AABABCBCC \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 243.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", + "Subcircuits: ABCDDEF \n", + "\n" + ] + } + ], + "source": [ + "# Specify settings for the cut-finding optimizer\n", + "optimization_settings = {\"rand_seed\": 12345}\n", + "\n", + "# Specify the size and number of the QPUs available\n", + "qubits_per_qpu = 7\n", + "num_qpus = 2\n", + "\n", + "for num in range(num_qpus, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", + " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", + " find_cuts(circ2, optimization_settings, device_constraints)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From e5a762a632e462ddc9f19d90ee1fcf135cda8247 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 12:36:26 -0600 Subject: [PATCH 035/128] Use dataclasses for settings objects --- .../cutting/cut_finding/cut_finding.py | 39 +++++++++++++- .../cut_finding/optimization_settings.py | 53 +++++++++---------- .../cut_finding/quantum_device_constraints.py | 25 +++++---- 3 files changed, 79 insertions(+), 38 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index b1f01f779..223963d6a 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -17,6 +17,9 @@ from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints +from .circuit_interface import SimpleGateList +from .lo_cuts_optimizer import LOCutsOptimizer +from .utils import QCtoCCOCircuit def find_cuts( @@ -24,4 +27,38 @@ def find_cuts( optimization: OptimizationSettings | dict[str, str | int], constraints: DeviceConstraints | dict[str, int], ): - pass + circuit_cco = QCtoCCOCircuit(circuit) + interface = SimpleGateList(circuit_cco) + + if isinstance(optimization, dict): + opt_settings = OptimizationSettings.from_dict(optimization) + else: + opt_settings = optimization + + # Hard-code the optimization type to best-first + opt_settings.setEngineSelection("CutOptimization", "BestFirst") + + if isinstance(constraints, dict): + constraint_settings = DeviceConstraints.from_dict(constraints) + else: + constraint_settings = constraints + + optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) + out = optimizer.optimize() + + print( + " Gamma =", + None if (out is None) else out.upperBoundGamma(), + ", Min_gamma_reached =", + optimizer.minimumReached(), + ) + if out is not None: + out.print(simple=True) + else: + print(out) + + print( + "Subcircuits:", + interface.exportSubcircuitsAsString(name_mapping="default"), + "\n", + ) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 656e32af8..731ffd727 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -11,9 +11,13 @@ """Class for specifying parameters that control the optimization.""" +from __future__ import annotations + +from dataclasses import dataclass -class OptimizationSettings: +@dataclass +class OptimizationSettings: """Class for specifying parameters that control the optimization. Member Variables: @@ -70,37 +74,24 @@ class OptimizationSettings: ValueError: beam_width must be a positive definite integer. """ - def __init__( - self, - max_gamma=1024, - max_backjumps=10000, - greedy_multiplier=None, - beam_width=30, - rand_seed=None, - LO=True, - LOCC_ancillas=False, - LOCC_no_ancillas=False, - engine_selections={"PhaseOneStageOneNoQubitReuse": "Greedy"}, - ): - if not (isinstance(max_gamma, int) and max_gamma > 0): + max_gamma: int = 1024 + max_backjumps: int = 10_000 + greedy_multiplier: float | int | None = None + beam_width: int = 30 + rand_seed: int | None = None + LO: bool = True + LOCC_ancillas: bool = False + LOCC_no_ancillas: bool = False + engine_selections: dict[str, str] | None = None + + def __post_init__(self): + if self.max_gamma < 1: raise ValueError("max_gamma must be a positive definite integer.") - - if not (isinstance(max_backjumps, int) and max_backjumps >= 0): + if self.max_backjumps < 0: raise ValueError("max_backjumps must be a positive semi-definite integer.") - - if not (isinstance(beam_width, int) and beam_width > 0): + if self.beam_width < 1: raise ValueError("beam_width must be a positive definite integer.") - self.max_gamma = max_gamma - self.max_backjumps = max_backjumps - self.greedy_multiplier = greedy_multiplier - self.beam_width = beam_width - self.rand_seed = rand_seed - self.engine_selections = engine_selections.copy() - self.LO = LO - self.LOCC_ancillas = LOCC_ancillas - self.LOCC_no_ancillas = LOCC_no_ancillas - self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas @@ -108,6 +99,8 @@ def __init__( self.wire_cut_LO = self.LO self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas + if self.engine_selections is None: + self.engine_selections = {"PhaseOneStageOneNoQubitReuse": "Greedy"} def getMaxGamma(self): """Return the max gamma.""" @@ -188,3 +181,7 @@ def getCutSearchGroups(self): out.append("WireCut") return out + + @classmethod + def from_dict(cls, options: dict[str, int]): + return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 237aa4e0f..dca339d34 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -11,9 +11,13 @@ """Class used for specifying characteristics of the target QPU.""" +from __future__ import annotations + +from dataclasses import dataclass -class DeviceConstraints: +@dataclass +class DeviceConstraints: """Class for specifying the characteristics of the target quantum processor that the optimizer must respect in order for the resulting subcircuits to be executable on the target processor. @@ -31,16 +35,19 @@ class DeviceConstraints: ValueError: num_QPUs must be a positive integer. """ - def __init__(self, qubits_per_QPU, num_QPUs): - if not (isinstance(qubits_per_QPU, int) and qubits_per_QPU > 0): - raise ValueError("qubits_per_QPU must be a positive definite integer.") + qubits_per_QPU: int + num_QPUs: int - if not (isinstance(num_QPUs, int) and num_QPUs > 0): - raise ValueError("num_QPUs must be a positive definite integer.") - - self.qubits_per_QPU = qubits_per_QPU - self.num_QPUs = num_QPUs + def __post_init__(self): + if self.qubits_per_QPU < 1 or self.num_QPUs < 1: + raise ValueError( + "qubits_per_QPU and num_QPUs must be positive definite integers." + ) def getQPUWidth(self): """Return the number of qubits supported on each individual QPU.""" return self.qubits_per_QPU + + @classmethod + def from_dict(cls, options: dict[str, int]): + return cls(**options) From 3686726c17c8a2be53fc7f05f9cef933f2ab458b Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Tue, 9 Jan 2024 17:49:00 -0600 Subject: [PATCH 036/128] Update tutorial to integrate with CKT --- .../cutting/cut_finding/cut_finding.py | 69 +++-- .../tutorials/04_automatic_cut_finding.ipynb | 243 +++++++++--------- 2 files changed, 176 insertions(+), 136 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 223963d6a..4f1849d46 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -14,19 +14,38 @@ from __future__ import annotations from qiskit import QuantumCircuit +from qiskit.circuit import CircuitInstruction from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints from .circuit_interface import SimpleGateList from .lo_cuts_optimizer import LOCutsOptimizer from .utils import QCtoCCOCircuit +from ..instructions import CutWire +from ..cutting_decomposition import cut_gates def find_cuts( circuit: QuantumCircuit, optimization: OptimizationSettings | dict[str, str | int], constraints: DeviceConstraints | dict[str, int], -): +) -> QuantumCircuit: + """ + Find cut locations in a circuit, given optimization settings and QPU constraints. + + Args: + circuit: The circuit to cut + optimization: Settings for controlling optimizer behavior. Currently, + only a best-first optimizer is supported. For a list of supported + optimization settings, see :class:`.OptimizationSettings`. + constraints: QPU constraints used to generate the cut location search space. + For information on how to specify QPU constraints, see :class:`.DeviceConstraints`. + + Returns: + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + """ circuit_cco = QCtoCCOCircuit(circuit) interface = SimpleGateList(circuit_cco) @@ -43,22 +62,36 @@ def find_cuts( else: constraint_settings = constraints + # Hard-code the optimizer to an LO-only optimizer optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) - out = optimizer.optimize() - - print( - " Gamma =", - None if (out is None) else out.upperBoundGamma(), - ", Min_gamma_reached =", - optimizer.minimumReached(), - ) - if out is not None: - out.print(simple=True) - else: - print(out) - print( - "Subcircuits:", - interface.exportSubcircuitsAsString(name_mapping="default"), - "\n", - ) + # Find cut locations + opt_out = optimizer.optimize() + + wire_cut_actions = [] + gate_ids = [] + for action in opt_out.actions: + if action[0].getName() == "CutTwoQubitGate": + gate_ids.append(action[1][0]) + else: + wire_cut_actions.append(action) + + # First, replace all gates to cut with BaseQPDGate instances. + # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. + # This may not hold in the future as we stop treating gate cuts individually + circ_out = cut_gates(circuit, gate_ids)[0] + + # Insert all the wire cuts + counter = 0 + for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): + if action[0].getName() == "CutTwoQubitGate": + continue + inst_id = action[1][0] + qubit_id = action[2][0][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), + ) + counter += 1 + + return circ_out diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 24558a509..f8b56fc2e 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Visualize the circuit" + "#### Create a circuit and observables" ] }, { @@ -21,9 +21,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 1, @@ -32,19 +32,20 @@ } ], "source": [ - "from qiskit.circuit.library import EfficientSU2\n", - "\n", - "circ = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", - "circ.assign_parameters([0.4] * len(circ.parameters), inplace=True)\n", + "import numpy as np\n", + "from qiskit.circuit.random import random_circuit\n", + "from qiskit.quantum_info import PauliList\n", "\n", - "circ.draw(\"mpl\", scale=0.8, style=\"iqp\")" + "circuit = random_circuit(7, 5, max_operands=2)\n", + "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", + "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\", fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Perform cut finding" + "#### Find cut locations, given two QPUs with 4 qubits each" ] }, { @@ -53,173 +54,179 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, ['cx', 2, 3]]}]\n", - "Subcircuits: AAAB \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 1, 2]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, ['cx', 1, 2]]}]\n", - "Subcircuits: AABB \n", - "\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "from circuit_knitting.cutting import find_cuts\n", "\n", "# Specify settings for the cut-finding optimizer\n", - "optimization_settings = {\"rand_seed\": 12345}\n", + "optimization_settings = {\"rand_seed\": 111}\n", "\n", "# Specify the size and number of the QPUs available\n", - "qubits_per_qpu = 4\n", - "num_qpus = 2\n", - "device_constraints = {\"qubits_per_QPU\": qubits_per_qpu, \"num_QPUs\": num_qpus}\n", + "device_constraints = {\"qubits_per_QPU\": 4, \"num_QPUs\": 2}\n", "\n", - "for num in range(num_qpus, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", - " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", - " find_cuts(circ, optimization_settings, device_constraints)" + "cut_circuit = find_cuts(circuit, optimization_settings, device_constraints)\n", + "cut_circuit.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Cut finding for 7 qubit circuit" + "#### Add ancillas for wire cuts and expand the observables to account for ancilla qubits" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from circuit_knitting.cutting import cut_wires, expand_observables\n", + "\n", + "qc_w_ancilla = cut_wires(cut_circuit)\n", + "observables_expanded = expand_observables(observables, circuit, qc_w_ancilla)\n", + "qc_w_ancilla.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Visualize the circuit" + "#### Partition the circuit and observables into subcircuits and subobservables. Calculate the sampling overhead incurred from cutting these gates and wires." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling overhead: 1201.0166532117305\n" + ] + } + ], + "source": [ + "from circuit_knitting.cutting import partition_problem\n", + "\n", + "partitioned_problem = partition_problem(circuit=qc_w_ancilla, observables=observables_expanded)\n", + "subcircuits = partitioned_problem.subcircuits\n", + "subobservables = partitioned_problem.subobservables\n", + "print(f\"Sampling overhead: {np.prod([basis.overhead for basis in partitioned_problem.bases])}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "{0: PauliList(['IIII', 'IIII', 'IIIZ']),\n", + " 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import numpy as np\n", - "from qiskit import QuantumCircuit\n", - "\n", - "circ2 = QuantumCircuit(7)\n", - "for i in range(7):\n", - " circ2.rx(np.pi / 4, i)\n", - "circ2.cx(0, 3)\n", - "circ2.cx(1, 3)\n", - "circ2.cx(2, 3)\n", - "circ2.cx(3, 4)\n", - "circ2.cx(3, 5)\n", - "circ2.cx(3, 6)\n", - "\n", - "circ2.draw(\"mpl\", scale=0.8, style=\"iqp\")" + "subobservables" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subcircuits[0].draw(\"mpl\", style=\"iqp\", scale=0.8)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subcircuits[1].draw(\"mpl\", style=\"iqp\", scale=0.8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Perform cut finding" + "#### Generate the experiments to run on the backend." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\n", - "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", - "\n", - "\n", - "\n", - "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAAAAB \n", - "\n", - "\n", - "\n", - "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABABB \n", - "\n", - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AABABCBCC \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: ABCDDEF \n", - "\n" + "576 total subexperiments to run on backend.\n" ] } ], "source": [ - "# Specify settings for the cut-finding optimizer\n", - "optimization_settings = {\"rand_seed\": 12345}\n", - "\n", - "# Specify the size and number of the QPUs available\n", - "qubits_per_qpu = 7\n", - "num_qpus = 2\n", + "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", - "for num in range(num_qpus, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num} QPUs ----------')\n", - " device_constraints = {\"qubits_per_QPU\": qpu_qubits, \"num_QPUs\": num}\n", - " find_cuts(circ2, optimization_settings, device_constraints)" + "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=np.inf)\n", + "print(f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\")" ] } ], From 9e49305f2fbe251e4b639fbf5458a056014fbde3 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 9 Jan 2024 19:36:08 -0500 Subject: [PATCH 037/128] clean up utils doc strings. --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 2e41d1449..349c6d0b7 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -82,7 +82,7 @@ def CCOtoQCCircuit(interface): gate_qubits = len(op) - 1 # number of qubits involved in the operation. if ( cut_types[i] is None - ): # only append gates that are not cut to qc_cut. May replace cut gates with TwoQubitQPDGate's in future. + ): # only append gates that are not cut to qc_cut. if type(op[0]) is tuple: params = [i for i in op[0][1:]] gate_name = op[0][0] From cf7268b52e8b2a518ec09a674d6a49ec264beb50 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:49:11 -0600 Subject: [PATCH 038/128] Simplifications in xform func --- circuit_knitting/cutting/cut_finding/utils.py | 26 ++++++------------- 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 349c6d0b7..3c3f732a3 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -35,27 +35,17 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): """ circuit_list_rep = list() - num_circuit_instructions = len(circuit.data) - - for i in range(num_circuit_instructions): - gate_instruction = circuit.data[i] - instruction_name = gate_instruction.operation.name - qubit_ref = gate_instruction.qubits - params = gate_instruction.operation.params - circuit_element = instruction_name - - if ( - circuit_element == "barrier" and len(qubit_ref) == circuit.num_qubits - ): # barrier across all qubits is not assigned to a specific qubit. - circuit_list_rep.append(circuit_element) + for i, inst in enumerate(circuit.data): + # Barrier on all qubits not assigned to a specific qubit + if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: + circuit_list_rep.append(inst.operation.name) else: - circuit_element = (circuit_element,) + circuit_element = (inst.operation.name,) if params: - circuit_element += tuple(params[i] for i in range(len(params))) + circuit_element += tuple(inst.operation.params) circuit_element = (circuit_element,) - for j in range(len(qubit_ref)): - qubit_index = qubit_ref[j].index - circuit_element += (qubit_index,) + for qubit in inst.qubits: + circuit_element += (qubit.index,) circuit_list_rep.append(circuit_element) return circuit_list_rep From 97f87c18e90f0151d41809d35d724b2ef2210e87 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:50:37 -0600 Subject: [PATCH 039/128] black --- circuit_knitting/cutting/cut_finding/utils.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 3c3f732a3..2e29e4cb8 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -70,9 +70,7 @@ def CCOtoQCCircuit(interface): i ] # the operation, including gate names and qubits acted on. gate_qubits = len(op) - 1 # number of qubits involved in the operation. - if ( - cut_types[i] is None - ): # only append gates that are not cut to qc_cut. + if cut_types[i] is None: # only append gates that are not cut to qc_cut. if type(op[0]) is tuple: params = [i for i in op[0][1:]] gate_name = op[0][0] From 56358979fd4aff036612d6b1f65a104f62e38f59 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:52:33 -0600 Subject: [PATCH 040/128] update xform code to fix small bug --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 2e29e4cb8..9e258fcda 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -41,7 +41,7 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): circuit_list_rep.append(inst.operation.name) else: circuit_element = (inst.operation.name,) - if params: + if inst.operation.params: circuit_element += tuple(inst.operation.params) circuit_element = (circuit_element,) for qubit in inst.qubits: From 8c01c3753918e93046903020f32540bf878cc842 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 10 Jan 2024 09:53:32 -0600 Subject: [PATCH 041/128] minor simplification --- circuit_knitting/cutting/cut_finding/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 9e258fcda..813523e7c 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -35,7 +35,7 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): """ circuit_list_rep = list() - for i, inst in enumerate(circuit.data): + for inst in circuit.data: # Barrier on all qubits not assigned to a specific qubit if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: circuit_list_rep.append(inst.operation.name) From 3a090c1c0fe3a03682bbf0a0a7d7da5a69b3ba7e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 10 Jan 2024 22:35:24 -0500 Subject: [PATCH 042/128] edit doc strings --- circuit_knitting/cutting/cut_finding/cut_optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 475853733..fb99fa381 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -140,7 +140,7 @@ class CutOptimization: CutOptimization focuses on using circuit cutting to create disjoint subcircuits. It then uses upper and lower bounds on the resulting gamma in order to decide where and how to cut while deferring the exact - choices of quasiprobability decompositions to Stage Two. + choices of quasiprobability decompositions. Member Variables: From 20ce84d0a3aef744b37cc01bc7270a7015e4a901 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 11 Jan 2024 11:08:28 -0500 Subject: [PATCH 043/128] edit field name in settings --- circuit_knitting/cutting/cut_finding/optimization_settings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 731ffd727..3cd85ded7 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -100,7 +100,7 @@ def __post_init__(self): self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas if self.engine_selections is None: - self.engine_selections = {"PhaseOneStageOneNoQubitReuse": "Greedy"} + self.engine_selections = {"CutOptimization": "Greedy"} def getMaxGamma(self): """Return the max gamma.""" From 0d9eef8a98da70fd787b131c86eaa088458f1938 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 22 Jan 2024 09:39:25 -0500 Subject: [PATCH 044/128] Remove remnants of other search algorithms. --- .../cutting/cut_finding/__init__.py | 2 +- .../cutting/cut_finding/circuit_interface.py | 21 +- .../cutting/cut_finding/cut_finding.py | 2 +- .../cutting/cut_finding/cut_optimization.py | 12 +- .../cutting/cut_finding/cutting_actions.py | 217 +----------------- .../cut_finding/disjoint_subcircuits_state.py | 2 +- .../cutting/cut_finding/lo_cuts_optimizer.py | 3 +- .../cut_finding/optimization_settings.py | 29 +-- .../tutorials/LO_circuit_cut_finder.ipynb | 51 +--- 9 files changed, 22 insertions(+), 317 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index 88a79e9b2..b9765124b 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -1 +1 @@ -from .cut_finding import find_cuts +from .cut_finding import find_cuts \ No newline at end of file diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 111e52df8..50653bd17 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -102,17 +102,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): assert False, "Derived classes must override insertWireCut()" - @abstractmethod - def insertParallelWireCut(self, list_of_wire_cuts): - """Derived classes must override this function and insert a parallel - LOCC wire cut without ancillas into the circuit. The - list_of_wire_cuts must be a list of wire-cut quadruples of the form: - [..., (, , , ), ...] - - The assumed cut type is "LOCCNoAncillas". - """ - - assert False, "Derived classes must override insertParallelWireCut()" @abstractmethod def defineSubcircuits(self, list_of_list_of_wires): @@ -292,14 +281,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): qubit = self.circuit[gate_ID][0][input_ID] self.output_wires[qubit] = dest_wire_ID - def insertParallelWireCut(self, list_of_wire_cuts): - """Insert a parallel LOCC wire cut without ancillas into the circuit. - The list_of_wire_cuts must be a list of wire-cut quadruples of - the form: - [..., (, , , ), ...] - """ - - assert False, "insertParallelWireCut() not yet implemented" def defineSubcircuits(self, list_of_list_of_wires): """Assign subcircuits where each subcircuit is @@ -465,7 +446,7 @@ def getID(self, item_name): return self.item_dict[item_name] def defineID(self, item_ID, item_name): - """Assign a spefiic ID number to an item name.""" + """Assign a specific ID number to an item name.""" assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" assert ( diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 4f1849d46..13f6005da 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -78,7 +78,7 @@ def find_cuts( # First, replace all gates to cut with BaseQPDGate instances. # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. - # This may not hold in the future as we stop treating gate cuts individually + # This may not hold in the future as we stop treating gate cuts individually. circ_out = cut_gates(circuit, gate_ids)[0] # Insert all the wire cuts diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index fb99fa381..0640ecbd4 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -73,7 +73,7 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1]) <= 3: # change to ==3 + if len(gate_spec[1]) == 3: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") @@ -119,7 +119,6 @@ def greedyCutOptimization( func_args.search_actions = search_actions func_args.max_gamma = optimization_settings.getMaxGamma() func_args.qpu_width = device_constraints.getQPUWidth() - func_args.greedy_multiplier = optimization_settings.getGreedyMultiplier() start_state = DisjointSubcircuitsState( circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) @@ -205,7 +204,6 @@ def __init__( self.func_args.search_actions = self.search_actions self.func_args.max_gamma = self.settings.getMaxGamma() self.func_args.qpu_width = self.constraints.getQPUWidth() - self.func_args.greedy_multiplier = self.settings.getGreedyMultiplier() # Perform an initial greedy best-first search to determine an upper # bound for the optimal gamma @@ -254,11 +252,9 @@ def __init__( def optimizationPass(self): """Produce, at each call, a goal state representing a distinct - set of cutting decisions. The first goal state returned corresponds - to cutting decisions that minimize the lower bound on the resulting gamma. - None is returned once no additional choices of cuts can be made without - exceeding the minimum upper bound across all cutting decisions previously - returned and the optimization settings. + set of cutting decisions. None is returned once no additional choices + of cuts can be made without exceeding the minimum upper bound across + all cutting decisions previously returned and the optimization settings. """ state, cost = self.search_engine.optimizationPass(self.func_args) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 4daa48336..9cda64798 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -59,49 +59,7 @@ def nextState(self, state, gate_spec, max_width): return next_list - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Derived classes must register the action in the specified - AssignmentSettings object, where the action was applied to gate_spec - with the action arguments cut_args""" - - assert False, "Derived classes must override registerCut()" - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Derived classes must initialize the action in the specified - AssignmentSettings object, where the action was applied to gate_spec - with the action arguments cut_args. Intialization is performed after - all actions have been registered.""" - - assert False, "Derived classes must override initializeCut()" - - def nextAssignment( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - """Return a list of next assignment states that result from - applying assignment actions to the input assignment state. - """ - - next_list = self.nextAssignmentPrimitive( - assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ) - - for next_state in next_list: - next_state.setNextLevel(assign_state) - - return next_list - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - """Derived classes must retrieve the appropriate group of QPD - assignment actions from assign_actions, and then collect and - return the combined list of next assignment states that result - from applying those actions to the input assignment state, with - the constraint object, gate_spec, and cut_args provided as inputs - to the nextState() methods of those assignment actions.""" - - assert False, "Derived classes must override initializeCut()" - + class ActionApplyGate(DisjointSearchAction): @@ -125,15 +83,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ if len(gate_spec[1]) > 3: - # The function multiqubitNextState handles - # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - gate = gate_spec[1] # extract the gate from gate specification. - r1 = state.findQubitRoot(gate[1]) # extract the root wire for the first qubit - # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate[2]) # extract the root wire for the second qubit - # acted on by the given 2-qubit gate. + gate = gate_spec[1] + r1 = state.findQubitRoot(gate[1]) + r2 = state.findQubitRoot(gate[2]) # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate @@ -156,7 +110,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): def multiqubitNextState(self, state, gate_spec, max_width): """Return the new state that results from applying - ActionApplyGate to state given a multiqubit gate specification: gate_spec. + ActionApplyGate to state given a multiqubit (3 or more qubits) + gate specification: gate_spec. """ gate = gate_spec[1] @@ -304,34 +259,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): def getCostParams(self, gate_spec): return lookupCostParams(self.gate_dict, gate_spec, (None, None, None)) - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the gate cuts made by a ActionCutTwoQubitGate action - in an AssignmentSettings object. - """ - - assignment_settings.registerGateCut(gate_spec, cut_args[0][0]) - assignment_settings.registerGateCut(gate_spec, cut_args[1][0]) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the gate cuts made by a ActionCutTwoQubitGate action - in an AssignmentSettings object. - """ - - assignment_settings.initGateCut(gate_spec, cut_args[0][0]) - assignment_settings.initGateCut(gate_spec, cut_args[1][0]) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("TwoQubitGateCut") - - new_list = list() - for action in action_list: - new_list.extend( - action.nextState(assign_state, constraint_obj, gate_spec, cut_args) - ) - - return new_list def exportCuts(self, circuit_interface, wire_map, gate_spec, args): """Insert an LO gate cut into the input circuit for the specified gate @@ -413,31 +340,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutLeftWire action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutLeftWire action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified @@ -451,36 +353,6 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) -def registerAllWireCuts(assignment_settings, gate_spec, cut_args): - """Register a list of wire cuts in an AssignmentSettings object.""" - - for cut_triple in cut_args: - assignment_settings.registerWireCut(gate_spec, cut_triple) - - -def assignWireCuts(action_list, assign_state, constraint_obj, gate_spec, tuple_list): - if len(tuple_list) <= 0: - return [ - assign_state, - ] - - wire_cut = tuple_list[0] - new_states = list() - for action in action_list: - new_states.extend( - action.nextState(assign_state, constraint_obj, gate_spec, wire_cut) - ) - - final_states = list() - for state in new_states: - final_states.extend( - assignWireCuts( - action_list, state, constraint_obj, gate_spec, tuple_list[1:] - ) - ) - - return final_states - def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): """Insert LO wire cuts into the input circuit for the specified @@ -549,31 +421,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutRightWire action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutRightWire action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified @@ -643,32 +490,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionCutBothWires action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionCutBothWires action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. @@ -823,32 +644,6 @@ def addCutsToNewState(self, new_state, gate, cuts, downstream_root): return cut_triples - def registerCut(self, assignment_settings, gate_spec, cut_args): - """Register the wire cuts made by a ActionMultiWireCut action - in an AssignmentSettings object. - """ - - registerAllWireCuts(assignment_settings, gate_spec, cut_args) - - def initializeCut(self, assignment_settings, gate_spec, cut_args): - """Initialize the wire cuts made by a ActionMultiWireCut action - in an AssignmentSettings object. - """ - - for gate_input in [pair[0] for pair in cut_args]: - assignment_settings.initWireCut(gate_spec, gate_input) - - assignment_settings.initApplyGate(gate_spec) - - def nextAssignmentPrimitive( - self, assign_state, constraint_obj, gate_spec, cut_args, assign_actions - ): - action_list = assign_actions.getGroup("WireCut") - - return assignWireCuts( - action_list, assign_state, constraint_obj, gate_spec, cut_args - ) - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 5d24c6158..5366eb6a2 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -13,7 +13,7 @@ import copy import numpy as np -from collections import Counter, namedtuple +from collections import Counter class DisjointSubcircuitsState: diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 8be8a3521..cfa3c80ed 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -22,8 +22,7 @@ ### Functions for generating the cut optimization search space cut_optimization_search_funcs = SearchFunctions( - cost_func=CutOptimizationUpperBoundCostFunc, # Change to CutOptimizationCostFunc with LOCC - # or after the new LO QPD's are incorporated into CKT. + cost_func=CutOptimizationUpperBoundCostFunc, # Valid choice only for LO cuts. upperbound_cost_func=CutOptimizationUpperBoundCostFunc, next_state_func=CutOptimizationNextStateFunc, goal_state_func=CutOptimizationGoalStateFunc, diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 3cd85ded7..563feff02 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -55,9 +55,6 @@ class OptimizationSettings: gate_cut_LOCC_with_ancillas (bool) is a flag that indicates that LOCC gate cuts with ancillas should be included in the optimization. - gate_cut_LOCC_no_ancillas (bool) is a flag that indicates that - LOCC gate cuts with no ancillas should be included in the optimization. - wire_cut_LO (bool) is a flag that indicates that LO wire cuts should be included in the optimization. @@ -67,6 +64,9 @@ class OptimizationSettings: wire_cut_LOCC_no_ancillas (bool) is a flag that indicates that LOCC wire cuts with no ancillas should be included in the optimization. + NOTE: The current release only support LO gate and wire cuts. LOCC + flags have been incorporated with an eye towards future releases. + Raises: ValueError: max_gamma must be a positive definite integer. @@ -76,8 +76,6 @@ class OptimizationSettings: max_gamma: int = 1024 max_backjumps: int = 10_000 - greedy_multiplier: float | int | None = None - beam_width: int = 30 rand_seed: int | None = None LO: bool = True LOCC_ancillas: bool = False @@ -89,8 +87,6 @@ def __post_init__(self): raise ValueError("max_gamma must be a positive definite integer.") if self.max_backjumps < 0: raise ValueError("max_backjumps must be a positive semi-definite integer.") - if self.beam_width < 1: - raise ValueError("beam_width must be a positive definite integer.") self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas @@ -100,7 +96,7 @@ def __post_init__(self): self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas if self.engine_selections is None: - self.engine_selections = {"CutOptimization": "Greedy"} + self.engine_selections = {"CutOptimization": "BestFirst"} def getMaxGamma(self): """Return the max gamma.""" @@ -110,14 +106,6 @@ def getMaxBackJumps(self): """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def getGreedyMultiplier(self): - """Return the greedy multiplier.""" - return self.greedy_multiplier - - def getBeamWidth(self): - """Return the beam width.""" - return self.beam_width - def getRandSeed(self): """Return the random seed.""" return self.rand_seed @@ -135,24 +123,20 @@ def clearAllCutTypes(self): self.gate_cut_LO = False self.gate_cut_LOCC_with_ancillas = False - self.gate_cut_LOCC_no_ancillas = False - self.wire_cut_LO = False self.wire_cut_LOCC_with_ancillas = False self.wire_cut_LOCC_no_ancillas = False def setGateCutTypes(self): """Select which gate-cut types to include in the optimization. - The default is to include all gate-cut types. + The default is to include LO gate cuts. """ - self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas - self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas def setWireCutTypes(self): """Select which wire-cut types to include in the optimization. - The default is to include all wire-cut types. + The default is to include LO wire cuts. """ self.wire_cut_LO = self.LO @@ -169,7 +153,6 @@ def getCutSearchGroups(self): if ( self.gate_cut_LO or self.gate_cut_LOCC_with_ancillas - or self.gate_cut_LOCC_no_ancillas ): out.append("GateCut") diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 2b68bd11a..1a6ab7e27 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -189,56 +189,7 @@ "cell_type": "code", "execution_count": 13, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", - "\n", - "\n", - "\n", - "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: AAAAAAB \n", - "\n", - "\n", - "\n", - "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABABB \n", - "\n", - "\n", - "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, ['cx', 3, 4]]}, 'Input wire': 1}]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, ['cx', 2, 3]]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, ['cx', 3, 5]]}, 'Input wire': 1}]\n", - "Subcircuits: AABABCBCC \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, ['cx', 0, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, ['cx', 1, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, ['cx', 2, 3]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, ['cx', 3, 5]]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, ['cx', 3, 6]]}]\n", - "Subcircuits: ABCDDEF \n", - "\n" - ] - } - ], + "outputs": [], "source": [ "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", From a4d6eb224c133c279e684226a602a6437955c0b5 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 17 Jan 2024 10:34:35 -0600 Subject: [PATCH 045/128] Introduce a CircuitElement tuple --- .../cutting/cut_finding/best_first_search.py | 1 - .../cutting/cut_finding/circuit_interface.py | 40 +++++++++++----- .../cutting/cut_finding/cut_optimization.py | 6 +-- .../cutting/cut_finding/cutting_actions.py | 47 ++++++++++--------- circuit_knitting/cutting/cut_finding/utils.py | 26 ++++++---- 5 files changed, 71 insertions(+), 49 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index d3a3ab7e5..89f25f032 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -266,7 +266,6 @@ def optimizationPass(self, *args): self.num_backjumps += 1 prev_depth = depth - if self.goal_state_func(state, *args): self.penultimate_stats = self.getStats() self.updateUpperBoundGoalState(state, *args) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 50653bd17..b9e14c0f7 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -11,11 +11,24 @@ """Quantum circuit representation compatible with cut-finding optimizers.""" +from __future__ import annotations + import copy import string -import numpy as np +from typing import NamedTuple from abc import ABC, abstractmethod +import numpy as np + + +class CircuitElement(NamedTuple): + """Named tuple for specifying a circuit element.""" + + name: str + params: list + qubits: tuple + gamma: float | int + class CircuitInterface(ABC): @@ -178,14 +191,19 @@ def __init__(self, input_circuit, init_qubit_names=[]): for gate in input_circuit: self.cut_type.append(None) - if not isinstance(gate, list) and not isinstance(gate, tuple): - self.circuit.append([copy.deepcopy(gate), None]) - self.new_circuit.append(copy.deepcopy(gate)) - + if not isinstance(gate, CircuitElement): + assert gate == "barrier" + self.circuit.append([gate, None]) + self.new_circuit.append(gate) else: - gate_spec = [gate[0]] + [self.qubit_names.getID(x) for x in gate[1:]] - self.circuit.append([copy.deepcopy(gate_spec), None]) - self.new_circuit.append(copy.deepcopy(gate_spec)) + gate_spec = CircuitElement( + name=gate.name, + params=gate.params, + qubits=tuple(self.qubit_names.getID(x) for x in gate.qubits), + gamma=gate.gamma, + ) + self.circuit.append([gate_spec, None]) + self.new_circuit.append(gate_spec) self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) self.num_qubits = self.qubit_names.getArraySizeNeeded() @@ -225,11 +243,10 @@ def getMultiQubitGates(self): The is the list index of the corresponding element in self.circuit """ - subcircuit = list() for k, gate in enumerate(self.circuit): - if isinstance(gate[0], list): - if len(gate[0]) > 2 and gate[0][0] != "barrier": + if gate[0] != "barrier": + if len(gate[0].qubits) > 1 and gate[0].name != "barrier": subcircuit.append([k] + gate) return subcircuit @@ -434,7 +451,6 @@ def getID(self, item_name): If the hashable item does not yet appear in the item dictionary, a new item ID is assigned. """ - if item_name not in self.item_dict: while self.next_ID in self.ID_dict: self.next_ID += 1 diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 0640ecbd4..e24ba6082 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -73,7 +73,7 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1]) == 3: + if len(gate_spec[1].qubits) == 2: # change to ==3 action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") @@ -84,7 +84,6 @@ def CutOptimizationNextStateFunc(state, func_args): next_state_list = [] for action in action_list: next_state_list.extend(action.nextState(state, gate_spec, func_args.qpu_width)) - return next_state_list @@ -92,7 +91,6 @@ def CutOptimizationGoalStateFunc(state, func_args): """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy the device constraints and the optimization settings). """ - return state.getSearchLevel() >= len(func_args.entangling_gates) @@ -123,7 +121,6 @@ def greedyCutOptimization( start_state = DisjointSubcircuitsState( circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) ) - return greedyBestFirstSearch(start_state, search_space_funcs, func_args) @@ -256,7 +253,6 @@ def optimizationPass(self): of cuts can be made without exceeding the minimum upper bound across all cutting decisions previously returned and the optimization settings. """ - state, cost = self.search_engine.optimizationPass(self.func_args) if state is None and not self.goal_state_returned: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 9cda64798..66b96c14e 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -82,12 +82,16 @@ def nextStatePrimitive(self, state, gate_spec, max_width): specification: gate_spec. """ - if len(gate_spec[1]) > 3: + gate = gate_spec[1] # extract the gate from gate specification. + if len(gate.qubits) > 2: + # The function multiqubitNextState handles + # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - gate = gate_spec[1] - r1 = state.findQubitRoot(gate[1]) - r2 = state.findQubitRoot(gate[2]) + r1 = state.findQubitRoot(gate.qubits[0]) # extract the root wire for the first qubit + # acted on by the given 2-qubit gate. + r2 = state.findQubitRoot(gate.qubits[1]) # extract the root wire for the second qubit + # acted on by the given 2-qubit gate. # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate @@ -115,7 +119,7 @@ def multiqubitNextState(self, state, gate_spec, max_width): """ gate = gate_spec[1] - roots = list(set([state.findQubitRoot(q) for q in gate[1:]])) + roots = list(set([state.findQubitRoot(q) for q in gate.qubits])) new_width = sum([state.width[r] for r in roots]) # If applying the gate would cause the number of qubits to exceed @@ -222,7 +226,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() gamma_LB, num_bell_pairs, gamma_UB = self.getCostParams(gate_spec) @@ -231,8 +235,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -273,11 +277,12 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): def lookupCostParams(gate_dict, gate_spec, default_value): - gate_name = gate_spec[1][0] + gate_name = gate_spec[1].name if gate_name in gate_dict: return gate_dict[gate_name] + # DO WE NEED THIS LOGIC? WHY WOULD THE NAME BE A TUPLE OR LIST? elif isinstance(gate_name, tuple) or isinstance(gate_name, list): if gate_name[0] in gate_dict: return gate_dict[gate_name[0]](gate_name) @@ -306,7 +311,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -314,8 +319,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -387,7 +392,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -395,8 +400,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -455,7 +460,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): """ # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1]) != 3: + if len(gate_spec[1].qubits) != 2: return list() # If the wire-cut limit would be exceeded, return the empty list @@ -467,8 +472,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return list() gate = gate_spec[1] - q1 = gate[1] - q2 = gate[2] + q1 = gate.qubits[0] + q2 = gate.qubits[1] w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) @@ -525,10 +530,10 @@ def nextStatePrimitive(self, state, gate_spec, max_width): gate = gate_spec[1] # If the gate is applied to two or fewer qubits, return the empty list - if len(gate) <= 3: + if len(gate.qubits) <= 2: return list() - input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate[1:])] + input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits)] subcircuits = list(set([pair[1] for pair in input_pairs])) return self.nextStateRecurse( @@ -630,7 +635,7 @@ def addCutsToNewState(self, new_state, gate, cuts, downstream_root): cut_triples = list() for i, root in cuts: - qubit = gate[i] + qubit = gate.qubits[i] wire = new_state.getWire(qubit) rnew = new_state.newWire(qubit) cut_triples.append((i, wire, rnew)) diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 813523e7c..6344e8e15 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -11,9 +11,14 @@ """Helper functions that are used in the code.""" +from __future__ import annotations + from qiskit import QuantumCircuit -from qiskit.circuit import Instruction +from qiskit.circuit import Instruction, Gate + from .best_first_search import BestFirstSearch +from .circuit_interface import CircuitElement +from ..qpd import QPDBasis def QCtoCCOCircuit(circuit: QuantumCircuit): @@ -33,19 +38,20 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. """ - - circuit_list_rep = list() + circuit_list_rep = [] for inst in circuit.data: - # Barrier on all qubits not assigned to a specific qubit if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: circuit_list_rep.append(inst.operation.name) else: - circuit_element = (inst.operation.name,) - if inst.operation.params: - circuit_element += tuple(inst.operation.params) - circuit_element = (circuit_element,) - for qubit in inst.qubits: - circuit_element += (qubit.index,) + gamma = None + if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: + gamma = QPDBasis.from_instruction(inst.operation).kappa + circuit_element = CircuitElement( + inst.operation.name, + params=inst.operation.params, + qubits=tuple(circuit.find_bit(q).index for q in inst.qubits), + gamma=gamma, + ) circuit_list_rep.append(circuit_element) return circuit_list_rep From de0580a07c856a38eb1313efed95e96ae932f4e1 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 22 Jan 2024 13:40:42 -0600 Subject: [PATCH 046/128] Fix cost lookup logic --- .../cutting/cut_finding/cutting_actions.py | 63 ++++++++++++------- 1 file changed, 42 insertions(+), 21 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 66b96c14e..ddaf09127 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -88,9 +88,13 @@ def nextStatePrimitive(self, state, gate_spec, max_width): # gates that act on 3 or more qubits. return self.multiqubitNextState(state, gate_spec, max_width) - r1 = state.findQubitRoot(gate.qubits[0]) # extract the root wire for the first qubit + r1 = state.findQubitRoot( + gate.qubits[0] + ) # extract the root wire for the first qubit # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate.qubits[1]) # extract the root wire for the second qubit + r2 = state.findQubitRoot( + gate.qubits[1] + ) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. # If applying the gate would cause the number of qubits to exceed @@ -164,48 +168,64 @@ def __init__(self): self.gate_dict = { "cx": (1, 1, 3), + "cy": (1, 1, 3), + "cz": (1, 1, 3), + "ch": (3, 0, 3), + "cp": (1, 1, 3), + "cs": (1, 1, 1 + 2 * np.sin(np.pi / 4)), + "csdg": (1, 1, 1 + 2 * np.sin(np.pi / 4)), + "csx": (1, 1, 1 + 2 * np.sin(np.pi / 4)), "swap": (1, 2, 7), "iswap": (1, 2, 7), + "dcx": (7, 0, 7), + "ecr": (3, 0, 3), "crx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), + ) + ), + "cp": ( + lambda t: ( + 1 + 2 * np.abs(np.sin(t[0] / 2)), + 0, + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "cry": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "crz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), + 1 + 2 * np.abs(np.sin(t[0] / 2)), ) ), "rxx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), "ryy": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), "rzz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), 0, - 1 + 2 * np.abs(np.sin(t[1])), + 1 + 2 * np.abs(np.sin(t[0])), ) ), } @@ -278,14 +298,13 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): def lookupCostParams(gate_dict, gate_spec, default_value): gate_name = gate_spec[1].name - - if gate_name in gate_dict: + params = gate_spec[1].params + if len(params) == 0: return gate_dict[gate_name] - # DO WE NEED THIS LOGIC? WHY WOULD THE NAME BE A TUPLE OR LIST? - elif isinstance(gate_name, tuple) or isinstance(gate_name, list): - if gate_name[0] in gate_dict: - return gate_dict[gate_name[0]](gate_name) + else: + if gate_name in gate_dict: + return gate_dict[gate_name]((gate_name, *params)) return default_value @@ -533,7 +552,9 @@ def nextStatePrimitive(self, state, gate_spec, max_width): if len(gate.qubits) <= 2: return list() - input_pairs = [(i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits)] + input_pairs = [ + (i + 1, state.findQubitRoot(q)) for i, q in enumerate(gate.qubits) + ] subcircuits = list(set([pair[1] for pair in input_pairs])) return self.nextStateRecurse( From 741ed420edef172cb3a54157b5b09eef61502e46 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 14:33:42 -0600 Subject: [PATCH 047/128] Fix bugs with wire cutting --- .../cutting/cut_finding/circuit_interface.py | 27 ++++++------ .../cutting/cut_finding/cut_optimization.py | 6 +-- .../cutting/cut_finding/cutting_actions.py | 44 +++++++++---------- .../tutorials/04_automatic_cut_finding.ipynb | 36 ++++++--------- 4 files changed, 48 insertions(+), 65 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index b9e14c0f7..8099cf864 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -26,7 +26,7 @@ class CircuitElement(NamedTuple): name: str params: list - qubits: tuple + qubits: list gamma: float | int @@ -188,23 +188,21 @@ def __init__(self, input_circuit, init_qubit_names=[]): self.circuit = list() self.new_circuit = list() self.cut_type = list() - for gate in input_circuit: self.cut_type.append(None) if not isinstance(gate, CircuitElement): assert gate == "barrier" - self.circuit.append([gate, None]) - self.new_circuit.append(gate) + self.circuit.append([copy.deepcopy(gate), None]) + self.new_circuit.append(copy.deepcopy(gate)) else: gate_spec = CircuitElement( name=gate.name, params=gate.params, - qubits=tuple(self.qubit_names.getID(x) for x in gate.qubits), + qubits=[self.qubit_names.getID(x) for x in gate.qubits], gamma=gate.gamma, ) - self.circuit.append([gate_spec, None]) - self.new_circuit.append(gate_spec) - + self.circuit.append([copy.deepcopy(gate_spec), None]) + self.new_circuit.append(copy.deepcopy(gate_spec)) self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) self.num_qubits = self.qubit_names.getArraySizeNeeded() self.output_wires = np.arange(self.num_qubits, dtype=int) @@ -273,9 +271,10 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): gate_pos = self.new_gate_ID_map[gate_ID] new_gate_spec = self.new_circuit[gate_pos] - assert src_wire_ID == new_gate_spec[input_ID], ( + # Gate inputs are numbered starting from 1, so we must decrement the index to qubits + assert src_wire_ID == new_gate_spec.qubits[input_ID-1], ( f"Input wire ID {src_wire_ID} does not match " - + f"new_circuit wire ID {new_gate_spec[input_ID]}" + + f"new_circuit wire ID {new_gate_spec.qubits[input_ID-1]}" ) # If the new wire does not yet exist, then define it @@ -287,6 +286,7 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): # follows the wire-cut insertion point wire_map = np.arange(self.qubit_names.getArraySizeNeeded(), dtype=int) wire_map[src_wire_ID] = dest_wire_ID + self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) # Insert a move operator @@ -295,7 +295,7 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): self.new_gate_ID_map[gate_ID:] += 1 # Update the output wires - qubit = self.circuit[gate_ID][0][input_ID] + qubit = self.circuit[gate_ID][0].qubits[input_ID-1] self.output_wires[qubit] = dest_wire_ID @@ -422,10 +422,9 @@ def replaceWireIDs(self, gate_list, wire_map): """Iterate through a list of gates and replaces wire IDs with the values defined by the wire_map. """ - for gate in gate_list: - for k in range(1, len(gate)): - gate[k] = wire_map[gate[k]] + for k in range(len(gate.qubits)): + gate.qubits[k] = wire_map[gate.qubits[k]] class NameToIDMap: diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index e24ba6082..a6e8491f1 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -49,7 +49,6 @@ def CutOptimizationCostFunc(state, func_args): def CutOptimizationUpperBoundCostFunc(goal_state, func_args): """Return the gamma upper bound.""" - return (goal_state.upperBoundGamma(), np.inf) @@ -73,13 +72,12 @@ def CutOptimizationNextStateFunc(state, func_args): # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1].qubits) == 2: # change to ==3 + if len(gate_spec[1].qubits) == 2: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: action_list = func_args.search_actions.getGroup("MultiqubitGates") action_list = getActionSubset(action_list, gate_spec[2]) - # Apply the search actions to generate a list of next states next_state_list = [] for action in action_list: @@ -237,7 +235,6 @@ def __init__( self.search_funcs, stop_at_first_min=False, ) - sq.initialize([start_state], self.func_args) # Use the upper bound for the optimal gamma to constrain the search @@ -254,7 +251,6 @@ def optimizationPass(self): all cutting decisions previously returned and the optimization settings. """ state, cost = self.search_engine.optimizationPass(self.func_args) - if state is None and not self.goal_state_returned: state = self.greedy_goal_state cost = self.search_funcs.cost_func(state, self.func_args) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index ddaf09127..d3b787203 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -81,7 +81,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): ActionApplyGate to state given the two-qubit gate specification: gate_spec. """ - gate = gate_spec[1] # extract the gate from gate specification. if len(gate.qubits) > 2: # The function multiqubitNextState handles @@ -96,7 +95,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): gate.qubits[1] ) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. - # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate if r1 != r2 and state.width[r1] + state.width[r2] > max_width: @@ -113,7 +111,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): new_state.mergeRoots(r1, r2) new_state.addAction(self, gate_spec) - return [new_state] def multiqubitNextState(self, state, gate_spec, max_width): @@ -170,62 +167,62 @@ def __init__(self): "cx": (1, 1, 3), "cy": (1, 1, 3), "cz": (1, 1, 3), - "ch": (3, 0, 3), + "ch": (1, 1, 3), "cp": (1, 1, 3), - "cs": (1, 1, 1 + 2 * np.sin(np.pi / 4)), - "csdg": (1, 1, 1 + 2 * np.sin(np.pi / 4)), - "csx": (1, 1, 1 + 2 * np.sin(np.pi / 4)), + "cs": (1, 2, 7), + "csdg": (1, 3, 15), + "csx": (1, 2, 7), "swap": (1, 2, 7), "iswap": (1, 2, 7), - "dcx": (7, 0, 7), - "ecr": (3, 0, 3), + "dcx": (1, 2, 7), + "ecr": (1, 1, 3), "crx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "cp": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "cry": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "crz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "rxx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), "ryy": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), "rzz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), } @@ -382,7 +379,6 @@ def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments. """ - gate_ID = gate_spec[0] for input_ID, wire_ID, new_wire_ID in cut_args: circuit_interface.insertWireCut( diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index f8b56fc2e..5ad413470 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,7 +21,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -55,9 +55,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 2, @@ -92,9 +92,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 3, @@ -126,7 +126,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 1201.0166532117305\n" + "Sampling overhead: 3329.001832079775\n" ] } ], @@ -147,8 +147,8 @@ { "data": { "text/plain": [ - "{0: PauliList(['IIII', 'IIII', 'IIIZ']),\n", - " 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" + "{0: PauliList(['ZIII', 'IIZI', 'IIIZ']),\n", + " 1: PauliList(['IIII', 'IIII', 'IIII'])}" ] }, "execution_count": 5, @@ -167,9 +167,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAD2CAYAAABr99spAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABS/ElEQVR4nO3deVhUZfvA8e8MDDDIJpsILuCC5i7lHm7llm9qZmJa5ltqpeLG+6aZpuZumopbKv00tTRLbTE1A9w1VzBFc0dBQNxA9m3m9wevkxMgoMDMwP25rq6Y5zznnPucM87cc86zKLRarRYhhBBCCGG0lIYOQAghhBBCPJkkbEIIIYQQRk4SNiGEEEIIIycJmxBCCCGEkZOETQghhBDCyEnCJoQQQghh5CRhE0IIIYQwcpKwCSGEEEIYOUnYhBBCCCGMnCRsQgghhBBGThI2IYQQQggjJwmbEEIIIYSRk4RNCCGEEMLIScImhBBCCGHkJGETQgghhDBykrAJIYQQQhg5SdiEEEIIIYycJGxCCCGEEEZOEjYhhBBCCCMnCZsQQgghhJGThE0IIYQQwshJwiaEEEIIYeQkYRNCCCGEMHKSsAkhhBBCGDlJ2IQQQgghjJwkbEIIIYQQRk4SNiGEEEIIIycJmxBCCCGEkZOETQghhBDCyEnCJoQQFVDHjh0ZOnSoocMQwMsvv8yQIUMMHUaRvPXWW9SuXRu1Wo2TkxNdunTh6NGjhg6rQpCETQghTNzTfOFv27aNL774onQCKgMHDx7k9ddfp1q1aqjVaurWrcu0adPIyMgwdGgGkZmZWSb7ad26NevWrePChQvs3buXatWq0aVLF27dulUm+6/IJGETQogKyNHRETs7O0OH8dQOHz5M7dq1+fbbbzl//jzz5s1jxYoVjB071iDxLF++nAYNGmBpaYmrqyuvv/46AJ6ensycOVOv7tChQ+nYsSMAQ4YMISQkhK+//hqFQoFCoWDfvn2F7s/T05PJkyczYsQInJyc8PX1ZcSIEXh6epKQkKCr9+6771KvXj2Sk5O5cuUKdnZ2LFq0SLf8woULVKpUidWrVxfpOEeNGoWvry+enp40adKExYsXk5KSwsmTJ4u0vnh65oYOQJS+ccfgVqqhowAPa1jUytBRFI2cM1HWli9fzvLly7l69Sr29vb4+vqydetWPD09GTp0KJMnT9bVHTp0KFeuXGHfvn26L3yAr7/+GoC9e/fqEoKCdOzYkTp16hAUFATAoUOHmDBhAn/++ScAtWrVYv78+XTr1o23334bjUbDN998A8DatWt59913WbNmje6x6qBBg9BoNGzatIkHDx7g7+/PgQMHuHPnDjVq1GD48OGMHz8ehUIB5CYq0dHR9OzZkwULFvDgwQN69uzJqlWrcHR0LPR8TZw4Ue+1l5cXkZGRzJo1i5UrVxa6fkmaOnUqCxcuZO7cuXTt2pXk5GR27dpVpHWXLFnCtWvXqFq1KkuWLAEo0vEDBAYGMn78eI4ePUp2dja1atXi0KFDDBs2jO+//55vv/2Wb775hj/++AMbGxvq1KnDypUreffdd+nQoQMNGjTAz8+Pnj17Mnz48GIfd3p6OitWrMDGxoYWLVoUe31RPJKwVQC3UuFakqGjMC1yzkRZMtQX/iPZ2dn06tWLIUOGsG7dOgDOnTuHtbU1AJ06ddJLGENDQ3FxcSE0NFSXsO3du5fp06cDkJGRQaNGjRg/fjyVK1fm8OHDfPDBBzg6OvLvf/9bt53jx49jbW3N7t27uXfvHsOGDeO9995j+/btxYr/kYSEBCpVqvRU6z6tlJQU5s+fz4wZMxg1apSu3MfHp0jr29vbY2FhgVqtxs3NrVj7btGiBdOmTdMr++6773jhhRf4+OOPWb58OfPnz6d58+a65YMGDSI4OJgBAwbQrl07kpKSWLNmTbH2u2LFCj766CNSU1Px8PAgJCQEd3f3Ym1DFJ8kbEIIYUCG/MJ/JCkpiQcPHtCrVy/q1q0LoPs/QOfOnYmNjeX8+fM0aNCAvXv3MmHCBBYsWADkPlaLjY2lc+fOALi5uendAfPy8uLEiRN8++23egmbRqNhw4YN2NvbA7l3Gbt168aVK1eoU6dOsY7hwoULLF68mNmzZz/VOXhaERERpKen07Vr1zLdL0DLli3zlD333HMsWLCAESNG0KNHD8aMGZOnzrJly2jcuDHr16/n0KFDuvNfVIMGDaJr167Ex8ezevVq+vXrx6FDh6hRo8ZTH4sonLRhE0IIAzLkF/4jlStXZujQoXTr1o0ePXowd+5cLl68qFvu6emJp6cnoaGhXLx4kYSEBEaMGEFqairnz58nNDSUGjVqULt2bSA3EZs7dy7NmjXD2dkZGxsbvvzyS27cuKG33wYNGuglC+3atQPg/PnzxYr/8uXLdO3alQEDBuglvcZAqVSi1Wr1yrKyskpk2wXdTdy/fz9mZmZERUWRnp6eZ/mVK1eIiYlBoVBw5cqVYu/X3t6eOnXq0LZtW9atW4e1tTUrVqwo9nZE8UjCJoQQRqw0v/Aft2bNGk6dOkWXLl3Yv38/jRo1YtWqVbrlnTt3JiQkhNDQUF588UXUajXt27cnNDSU0NBQ3d01gIULFzJnzhxGjx7N77//Tnh4OEOHDi2Vnoznzp2jffv2uvZvZa1BgwZYWVmxZ8+efJe7uroSExOjVxYWFqb32sLCgpycnBKJ56uvvuLnn3/mwIEDJCUlMW7cOL3lKSkpDBgwgAEDBrBgwQJGjhz5VEnb4zQaTb6JoShZkrAJIYQBGdMX/qN2Z7t27eK9997T6znYqVMn9u/fT3BwMC+99BLwdxK3b98+vYTtwIEDdO/enXfffZfmzZtTp04dLl++nGd/Fy5c4OHDh7rXR44cAXLPSVGcOHGCDh060L9/f1auXKnr0FCWbGxsCAgIYNq0aSxfvpxLly5x5swZ5syZA+QOufLdd9+xZ88eLl68yLhx4/LcafTy8uLUqVNcvXqVu3fvPnVCfvHiRcaMGcPixYtp27YtmzZtIigoSK9N4OjRo8nJyWHZsmWMGTOG9u3b8+abbxZpn+fOnePzzz/n1KlT3Lx5kxMnTvDuu+9y/fp1Bg0a9FQxi6KThE2IZ3Txk45ELs07AGnG7UhO9VaQfP6QAaISpsIYvvCvXLnChAkTOHToEDdu3ODo0aMcPHhQL3Hq3LkzDx484Oeff9YlZ507d2bHjh3cv39fL2GrV68e+/btY+/evVy6dInJkydz7NixPPtVKBQMHjyYc+fOceDAAUaOHEmvXr2K1H7twIEDvPTSS/Tu3ZuPP/6Y27dvExcXR1xcXLGOvSTMmDGDWbNmERgYSKNGjejatSunT58GYMKECfTs2RM/Pz98fX2xt7fnjTfe0Fs/ICAAZ2dnmjZtiouLC4cPHy52DBkZGQwYMIDu3bvreny2adOG6dOnM3ToUKKiotiyZQsbN25k8+bN2NjYoFAoWLduHTExMUyaNKnQfVhZWRESEsIrr7xCnTp16NOnD/fv3+fgwYPSS7QMKLT/vNcuyp3+e5++x2PkkiHcC80dKgClGRZOHtj59MDjrVmY2zkVa1u1bGFLp6eLo6wV55xd/KQjlm518PQP0ivPuB3JueFe1JtzEJsGLz5VHKZ0zsTT02q1BAYGsmLFCq5fv07lypVp374933//PUlJSYwYMYIdO3agUqkYMWIE0dHRumE9AK5du8aQIUM4ffo0KSkpxR7WIzY2lpEjR3L8+HHu3LmDk5OTbriNx9uY1atXjzt37nD37l3do1pXV1ccHR312rwlJiYybNgwdu/ejUqlYsCAATg6OrJhwwYiIyOBv4f16N69OwsXLiQxMZEePXqwevVqnJwK/2wZMmSIbhiT/M6nEOWNJGwVwLMmbBlx16j10Ra0OdmkXj3FjWVDsa7bkrqf/lqsbZlS8iEJmxCl61HCFhwcbOhQhDAJ8khUFEphboGqshsWztVwaNUb11fH8jBsN5qMNEOHJoQQ5c7s2bOxsbEp8L/S0qNHjwL32aNHj1Lbryiacj8Om0ajYcmSJaxatYrIyEhcXFzo378/n332WZkPsFheKC3VoNGgzck2dCgm5frid3h4ehfm9q40XHrO0OGIcmz27NlPHI8sOTlZ7/WJEycK3WZmZibr1q1jyJAhWFhYPLFuSbRnelJiMmnSpCK1uTJVH3zwAf379wfQzTzxuH9er5K6NkFBQaSl5f9DXK1WFxa2KGXlPmEbN24cgYGBvPbaawQEBHDhwgUCAwMJCwsjODgYpVJuMhZH2s3zxO9cTiXvVphZ2xo6HJPi/PK7VHl1DNcXDzZ0KEYp7U4CiZdvgUKBg3c1rJxMd55LQ3v8C7+kZGZmEhQUxMCBAwtNCori0YwKBQkPDy9wWXFncjA1jo6OumN88OBBofVL6tp4eHg89bqi9JXrhC0iIoKlS5fSt29ftm7dqiv38vJi9OjRbN68mYEDBxowQtOQdG4fYX42aDU5aLMysG3yEjVHlP14R8bKzNqenNTEPOU5KQkAKFRWANg26kDG7cgyjMw03D8fyZ+Lt3Jj5zG0ORoAlCozPF9tS9Nx/bCvI18ixfX4F76pKu5MB0KUdyZ7e+nMmTP07t0be3t77Ozs6NOnD7Gxsdja2jJgwAAANm3ahFarZezYsXrrDhs2DGtrazZu3GiAyE1PJe9WPLc4nIbLLtD8+3S8P/sdS7dahg7LaFhVq0/q1VNo/zEOVsrl46A0w7KqfPEUJO5IBL/+axKRvxzVJWsAmqwcrm07yI5XPuZu+LMN6imEEOWBSSZsISEhtG7dmosXLzJ58mRmz55NdHQ0PXr0IDk5mWbNmgG5z/mVSmWe+dasrKxo1qxZkdptCFBaqLGqWgfLKp4oVc/+KKS8cekxguyE20QG/puUK6fIiL3K/QObiPlmCs4v/RtzGwdDh2iUMhKSCRkyj5z0gscMy0pOJXjwHLLTMsowMpEfc3NzevXqhbl5uX4wY5Lk2lQMJnd179y5g5+fHz4+PgQHB+saQr799tt4eXkB6BK2mJgYnJ2dsbS0zLMdDw8Pjhw5QmZmZom0xxAVl6VrTerNO0LMN5O5OvNVclITsXCrRZXX/kuVV/NOvCxyXdmyj6yk1CdX0kL6nUSu/3yEun4yvokhWVlZMXnyZEOHIfIh16ZiMLmEbd68eTx48IC1a9fq9Vqxt7fHx8eHkJAQXcKWmpqab7IGuW/wR3VKKmHLzs42yCjbhcnKqgKoDB0GWVlZREffNnQYRVLcc2bt1ZQ6k38phThM55wV18UtoaAAChsJUgEXvv0ddbu6ZRFWhZSSklJonYyMDAIDAxk9enSBn6uPREdHl1RoFZ5cm/LHzc3tqe6GmlzCtnnzZnx9ffH29s53eZUqVXBzcwPA2tqa+Pj4fOs9mqjW2tpaV5adnU1AQAAbNmxAo9Hw+uuvs3z5cl1yV5i4uDiqV69enMMpEw2WnkNdo+FTres5Zl2JxXHp0iWqd2tUYtsrTc9yzgpydd4bJF84RPbDu/z5bjXc+k3C9ZURT1zHlM5ZcX3u3B1n88KH1tFqtIQfPk7v6nPKIKqKaejQvFOr/VNmZiY7d+7E2dm50B+5QUFBT1wuik6uTfkTFRVFtWrVir2eSSVscXFx3Lp1Cz8/vzzLNBoNZ8+epXnz5royd3d3zp8/T0ZGRp5fHbdu3crz5p49ezZ79+7l7NmzWFhY0KtXLz766CMCAwNL76BEhVF7wveGDsGopGqz0Gq1RZqwO10rY/4JISo2k0rYHt0azu8D/qeffiI+Pl73OBRyBwjcs2cPx48fx9fXV1eenp5OeHg47du319tGUFAQ8+fP141FM23aNN544w0WLVqEmZlZofG5ubkRFRX1NIdWqvzPVyEq3dBRgLe3N78Z4fnJj5yz0nd11S6uB/1WaD2FQkHPj95jxCDp1V1arlwpvCduSkoK69evp3///oUOOj516tSSCq3Ck2tT/jx6ClhcJpWwVa9eHTMzM/bv369XfuPGDfz9/QH0EjY/Pz9mz57N4sWL9RK2NWvWkJqayqBBg3RlCQkJREVF6a3v4+NDUlISkZGR1K5du9D4zM3Nn+o2Z2lTXQaMIPlQqVRGeX7yI+es9FX+sC+Ra39Hq9FCQVMaKxSYWap4YXgfLCvLQM2lJTY2ttA6KpWKoUOH4uDgUOhjt/L6njUEuTbiEZMa1sPCwoLBgwdz8uRJevfuzerVq5kyZQqtWrXCyckJ0E/YGjduzMiRI9m2bRt9+/YlKCiIgIAAxo8fT4cOHfQGzU1Kyp3p28HBQVf26O9Hy4QQJaeSuxPtvvhfG778nooqcu+utV82WpI1I2BhYcHw4cOlV70RkmtTMZhUwgYQGBjI8OHDOXbsGAEBARw7dozt27fj7u6OtbV1ns4IixcvZsGCBURERDBy5Eg2b96Mv78/O3bs0JuWytY29wshMfHvEesTEhL0lgkhSlad/h3pvPYjHOrm/dVfuYEnXb79hJo9WxsgMvFPaWlp+Pv7FzjXpDAcuTYVg0k9EoXcCYFXrVrFqlX6UyOdO3eOxo0b55kb1MzMjICAAAICAp64XQcHB6pXr054eDj16tUDICwsDFtbWzw9PUv0GIQQf6vRrQXVu77ApY3BHP0o99912y9GUHdApyJ1SBBlIycnh2PHjpHzjxk9hOHJtakYTC5hy09CQgLR0dH07NnzmbYzdOhQ5syZg6+vLyqVimnTpjFkyJAidTgwZWk3I7ix4n0UCiUKM3NqjgrSm3rq+hdvkRF3Da0mB9dXRuDU+R20Wi03lw8n/dZFlBZqao4KwsLF+IY0KU2FnbeYTdO4F7IWq2rPUXfabl15ypVT3NrwMdrsLGyea4fHWzMNEb5RUSgUODby0r2uXL+GJGtCCPGYcpGwnT17FtBvv/Y0Jk2axN27d2nYsCEajYZ+/foxb968EojQuJnbuVB3yq+YVbIn8fRuYr+bgeeYtbrlVQdMxcq9LpqsDM6Pbkxl3zd5eGonCpUl9eYcyE1A1k/EK+AbAx5F2SvsvLl0ex+nToO5+eXfY61psjKJ2fgJtSduw0xtY4iwhRBCmCBJ2B5jbm5OYGBghRt3TeXgqvtbYaYCpf4dRSv33BHmFeYWoFCiUChIj7mEdZ0XALCu7UPS+YNlF7CRKOy8qRyrknE7Uq8s5eJRlFaVuL5gAJrMNNwHzcSmfpuyCFeIZ2JpacmkSZMKHUlflD25NhWDyXU6yM+IESPQarW0bi2Nk5+FJiONmE1TC5z/8va2+VRu8zoKcxXqmo15GPYbWq2Wh2G/kZ2Y/4wSFUFh5+1xWfdjSIv8E6+ATXiOXseNFcPLIEIhnp1KpaJPnz6oVIaf5k7ok2tTMZSLhE08O21ONtcXDsStz39QezbOs/z+gc2kXj2N+6AZANg/3wMrd28uTe7Ew1O7UHs2KeuQjUJh5+2fzGwcsXmuHWbWtli4VMfMshI5qQ/LIFIhnk1qaip+fn6kpqYaOhTxD3JtKoZy8UhUPButVsuNZUOxa94Nh9Z98ixPPP0bd4O/os6UHSge64XrPnA6AA/PhKBQVbxb8YWdt/xU8m5F7ObpaHOy0aSnkJP6EDNru9INVIgSoNFouH79OhqNxtChiH+Qa1MxSMImeBj2G/cPbSEjPpL7hzZj7dUMO5/u5CTdx7HDQCKXvIPK0Z3L07oBUOs/m1GYmXN1Xj8USnMsXGpQffhSAx9F2SvsvN35bTX39q4nPfovLk15Gc+x67Fwcsel+wdc/KQj2uwsqv37c0MfhhBCCBMgCZvA3qc7Pt8XfCu96ddx+ZbXm7WvlCIyDYWdN5duw3HplreNmlPnwTh1HlyaoQkhhChnpA2bEEKIQllZWbFkyRKsrKwMHYr4B7k2FYPcYRNCCFEoc3Nz2rSRIWiMkVybikEStgrAw9rQEeQyljiKwlhiNZY4hEhOTubVV1/ll19+wcZGBn02JnJtKgZJ2CqARa0MHYHpkXMmRF4pKSmGDkEUQK5N+Sdt2IQQQgghjJwkbEIIIYQQRk4SNiGEEIVSq9Vs2rQJtVpt6FDEP8i1qRgkYRNCCFEopVJJlSpVUCrla8PYyLWpGOTqCiGEKFRKSgqdO3eWxu1GSK5NxSAJmxBCCCGEkZOETQghhBDCyMk4bEIIUcG1aNGi0DoZGRlMnTqVtm3bYmlpWQZRCZBrI/6m0Gq1WkMHIYQQd8Ku8OsrEwHouXMuLs3rGDgiIYQwHvJIVAghhBDCyEnCJoQQQghh5CRhE0IIIYQwcpKwCSGEEEIYOUnYhBCignn55ZcZMmSIocPQc+DAAXr37k3NmjVRKBTMnDnT0CEJYVQkYRNCCGFwycnJNGjQgPnz5+Pm5mbocIQwOjIOm4GEvDOXpMg4Q4dRbtl6uvHS1xOfen1juT7Pehyi/Fq+fDnLly/n6tWr2Nvb4+vry9atW/H09GTo0KFMnjxZV3fo0KFcuXKFffv2MWTIEEJCQgD4+uuvAdi7dy8dO3Z84v6ys7OZNWsW69evJzo6GmdnZ/r27cvSpUsBUCgULF68mAMHDrB7924cHBz46KOPGDNmTJGO55VXXuGVV14BYMKECcU9HSbLWD5rwHQ+b4zpnEHZnTdJ2AwkKTKOhEvRhg5DFECujzBmU6dOZeHChcydO5euXbuSnJzMrl27irTukiVLuHbtGlWrVmXJkiUAODo6Frree++9x65du1i4cCFt27blzp07HD16VK/O9OnTmT59OnPmzGHXrl0EBATg6elJ7969i3+QFYR81hRfRT1nkrAJIYQJSUlJYf78+cyYMYNRo0bpyn18fIq0vr29PRYWFqjV6iI/erxy5Qrr16/n+++/p1+/fgDUrl2b1q1b69Xr2bMn/v7+AHh7e3Ps2DEWLFggCZsQJUDasAkhhAmJiIggPT2drl27ltk+T58+DVDoPtu0aaP3ul27dkRERJRaXEJUJJKwCSFEOaJUKvnnjINZWVkGikYIUVIkYRNCCBPSoEEDrKys2LNnT77LXV1diYmJ0SsLCwvTe21hYUFOTk6R9/nocWtB+3zkjz/+0Ht95MgRGjRoUOT9CCEKJm3YhBDChNjY2BAQEMC0adNQq9V06dKFtLQ0du7cyccff8zLL7/MihUreO2116hZsyZffvklN27c0OtY4OXlxd69e3U9TO3t7VGpVAXus06dOgwaNIgRI0aQnp5OmzZtuH//PkeOHNHrBbpjxw6WLVtGt27d2L17N9999x3ff/99kY4rOTmZK1euAJCZmUlcXBzh4eHY2NhQp06dpzxbQpQfkrAJne5bp/PweixH/vOlXrlNNRf6nVjJzt6TiT/+l4GiE0I8MmPGDFxcXAgMDGTcuHFUrlyZ9u3bA7lDYty4cQM/Pz9UKhUjRozgjTfe0CVDAAEBAZw9e5amTZuSkpJSpGE91q5dy2effcbkyZOJiYnB1dVV1wHhkU8//ZTg4GA++ugj7O3tmT9/Pq+99lqRjunkyZN06tRJ9/rRsCUdOnRg3759RTsx5dyLi0dSxy/3HGlycki7nUDs4XOcnv0NqXH3DRydKG2SsAkhhIlRKBSMGTMm3zHObG1t2bBhwxPXr1WrFgcOHCjWPlUqFTNmzGDGjBkF1nF2dubHH38s1nYf6dixY562dyKvuD/Os3/4FyjMlNh6VqH17KF0XB3Azl6fGDo0UcokYROiBClV5gy+ufmp119XtV/hlYQQFZYmM5u0OwkApMbd5+LGYFrPeg+VjZqs5DTDBidKVYVI2DQaDUuWLGHVqlVERkbi4uJC//79+eyzz6hUqZKhwxPliFvbhmzvMJbECjioozBdI0aMYN26dQUu379/P5mZmaxbt44hQ4ZgYWGRb71r165x4sQJWrRooVf+zTff8P777xe4/fPnz1OjRo2nir0iU1epjOe/WqPJzkGbozF0OKKUVYiEbdy4cQQGBvLaa68REBDAhQsXCAwMJCwsjODgYJRK6SxbHN23f4aFjRqFypz4Yxf44+MgtBr5sACwr+tBzP4zhg5DiGLp27cvL7/88hPrZGZmEhQUxMCBA/NN2I4fP17gur169aJVq1YFLnd3dy96sBWcW9uGDLqyAYVSibnaEoBzK38mOy0DAGs3R17ZMYsd3SaQfu8hZmoLegcvJPS9z0n466YhQxfPqNwnbBERESxdupS+ffuydetWXbmXlxejR49m8+bNDBw40IARmp6Qt+fobr13DPoPnq+24fpPhw0clRDiaT3qKVpabG1tsbW1LbXtVyR3Tl/m0JhlmFmq8OzVFnffJoTN26Rbnhp3n/OrdtBi+hAOjgqkWUB/buw6JslaOWDSt5bOnDlD7969sbe3x87Ojj59+hAbG4utrS0DBgwAYNOmTWi1WsaOHau37rBhw7C2tmbjxo0GiNw4ZT5MxcIu7yNiC/vcspyM3ME3HyVrCnMzzFTm0lD4f+zruJN45ZahwxBClGM56Zm5c2lejCL88+9Iioqn1az39Opc+GoXDt7VeW7oK9R8pRVnFhZtaBVT59G5Ob1+/5y3IzfR7/gKGrz/L0OHVKJMNmELCQmhdevWXLx4kcmTJzN79myio6Pp0aMHycnJNGvWDIATJ06gVCpp2bKl3vpWVlY0a9aMEydOGCB645R45RZOTWqh+McjYufmddBk55B0PVZX1u2Habx57v/ISk7jxo4//rmpCqlKm4bEHZFpeET5ZG5uTq9evTA3L/cPZkxK+ILvqOPXCaemtXVlWo2GE1PX0WrGu5ycsUH3uLQ8c2pam5fWTSB6bxg/d/kP4Qu28PzEgdQbXHZTuJU2k0zY7ty5g5+fHz4+PoSFhfHf//6XUaNGERISws2bubd9HyVsMTExODs7Y2lpmWc7Hh4e3L17l8zMzLIM32j99fVurFzsabd4JE5NamFbswpefdrR/KMBXPluL5kPU3V1f+s3je+aDcNMbYHbi40MGLXxMLNUocnM1r3uumUq3bd/BgqFXr3Oayfwr93zUJiblXWIQjw1KysrJk+ejJWVlaFDEY9Juh5H1O8n8Zn4pl65x0vNSY27T+X6FaMzR8Ph/+Ju+FVOz/6WxMu3uLJlHxf+bxeNR/UxdGglxiR/Ks2bN48HDx6wdu1a1Gq1rtze3h4fHx9CQkJ0CVtqamq+yRqg++BJTU0tsNdTcWRnZxMXF1ekullZ2YVXKmMp0XfZ+eon+Ex4k5e+nojKzprkG7c5t+Jnzgf9mqd+TnomN3cdp0a3FsQe+NMAERcsKyub6Oin76lZlOtjprYgJy032VfZqMlMTNFbfmjMUnqHLKTxqD6cXbodAO+3u+DeoQm/dP0v2uzCpwZ61uMwJYnxt3V/x8ffJiNaEoOykpKSUmidjIwMAgMDGT16dIGfqY9UlPdsSSiJ74JzK36m5y+zcGvTkLijETjUr0GN7i3Z0WMir/wyi6tbD5B8M75IsZjCtcvvnLm2rM/lb0P0ym7tDafRiN5YV3UkNbb0BhYu7nlzc3N7qjvVJpmwbd68GV9fX7y9vfNdXqVKFdzc3ACwtrYmPj7/N2p6erquziNbtmwhMDCQ8PBwnJ2diYyMLHJccXFxVK9evUh1Zzp1wUNlV+Rtl5UH528Q8s7cAperbK1RWpiTce8hCjMl1bu8YJSPAS9dukT/Il6L/Dzp+ijMlDw/aRA5mVmEzcsdc829Q1Ni/pG0psbe5+jENfgu9efW3nCy0zJoMe0dTn62gcQrMfltusSPw5R4mldmqnNnAP71r1eJzH5g4IgqjqFDhxZaJzMzk507d+Ls7FzoD9ygoKCSCq3cK853waGxy/Mtv3Pyot4Yjm3mDefE1HWkxt0nbP5mWs16j5C35xS6fVP5vMnvnKldHXTj0z2SFv/gf8sql2rCVtzzFhUVRbVq1Yq9H5N7JBoXF8etW7d4/vnn8yzTaDScPXtWd3cNcruL3717l4yMvM/wb926lefDp3LlyowaNYpZs2aVSvymzsLemi7ffEKvkIX0CllIatw9Lm548oTQ5Y02R0PYgu+o2q6xrszazZG023kTjMifjxD5y1HaLx9N++VjuP3HBf5at7sswxVCVCB1B71M+t1EokNOA3D1+/2oKllR45WCh1URpsHk7rA9unWv+Ee7IICffvqJ+Ph4vYStRYsW7Nmzh+PHj+Pr66srT09PJzw8XDf/3iNdunQBeKrpVdzc3IiKiipS3aP955JyvWiPT41JSvRddnSfYOgwCuXt7U3Ulv976vULuz45aZmk30ukkoczKbfuPnEcumOTgngjbDVotEX6lfu4Zz0OU5IYcYMTQxYBsGPHL9g3rGngiCqOx+cZLUhKSgrr16+nf//+hQ44PnXq1JIKrdwr6e+Cy98Ec/mbYL2y3X2Ldj1M5fMmv3OWFp+A2sVBr8zqf68f3WkrLcU9b4+eABaXySVs1atXx8zMjP379+uV37hxA39/fwC9hM3Pz4/Zs2ezePFivYRtzZo1pKamMmjQoBKLzdzcvMi3OVUqkzv1JkWlKvq1KGj9wkT9fopqLz/PvT+vcTf8aoH1ar3eHoVCgVKtwqlJLd0v36LG8SzHYUos76Tr/nZ1rYJLBTluYxAbG1toHZVKxdChQ3FwcCj0kWhFec+WBGP6LjCVz5v8zln88b9w79iMM4t+0JV5dGpGclR8qT4OfRRPWZw3k3skamFhweDBgzl58iS9e/dm9erVTJkyhVatWuHk5AToJ2yNGzdm5MiRbNu2jb59+xIUFERAQADjx4+nQ4cOMmiueGrRwaeo3uV5nJvV5m7Y5Xzr2Nf14IUpb3NsyloufLWLtgs/xNJRBhAVpsfCwoLhw4eXSActIUpaxOoduDSvQ/OJb2Jfx53ab3TguXd7cHbZj4YOrcSYXMIGEBgYyPDhwzl27BgBAQEcO3aM7du34+7ujrW1dZ7OCIsXL2bBggVEREQwcuRINm/ejL+/Pzt27JBpqcRTS4tPQGWj1k0P808KczN8l40m5sCfXP4mmNOzvyHjQRJt5hc8p6IQxiotLQ1/f3/S0mSCcWF87p25Sui/51P95efpFbyQ5h8N4PS8TVxcX37aWBvPvdhisLGxYdWqVaxatUqv/Ny5czRu3DhPEmZmZkZAQAABAQFlGaaoAGL2nyHpxu18lzX/yI9KVZ0IHpjbgSUnI4uDowLpuXMOtd/owNXv9+e7nhDGKCcnh2PHjpGTU/hwNEIYQnTI6WI1OTE1Jpmw5SchIYHo6Gh69uz5TNvJyckhKyuLrKwstFot6enpKBSKQscdKgl1B75E3QGd0Wo1HJ2wJs/cb+2+GIGtZxXMra24tvUA59f8WuB6Tcf1o+qLub0Ybb3cOLf8Jy58tbPAfTcd1w/3jk3JSc/i0NhleZ75WzrZ0XrWe1g52ZGdlknI4DkoVea0Xz4GtasDCjMlxz75int/XivWvm2qudDxq/9gX9udPf0/487pvI8Wu2+djlJljiYrm7ijEYQv2FLgvsvapW9DyErKe8fBtWV9Gn3Ym9B355N+76Gu/H5EJOELttBqxrvEHYkg5dbdsgxXCFEOODWphc+kQSjNzYg/8ZdueCEA32Wjsa1RBYWZkr/W7ZYfhuVIuUnYzp49C+i3X3saGzZs4N///rfutVqtpmbNmsUaj+1pWDjYUO+drvzacxK2NavQZu4wfntjul6doxNWo8nKRmGm5LUDS7i48XfMLC3yXe/Moh90jS9f3TOfG78WPH2Ug3c1XFvWZ1fvKVRt3wSfCW/mGe+nxdR3CF/wnd74YVV9G5OZlMq+4Qtxbl6XJmNeZ+97nxdr32l3E9njN4OW09554vnZ+97nemPsFLTvspbfUB6Q2wB2fXW/fJedXbpdN5CuEEIUh1Jljs/EN9n77udkp6bnWR6+cAtJ1+NQWpjTO/QLrv94GI0RDtQuiq/cNOAqqYRtyJAhaLVavf9KO1kDcGleh7gjEWizc3h4NQZLR7s8Uxo9+kdnZmlBUlQ8OelZha7n4F2NzMQUUuMK7iVTpXUDon4/BUDsgT9xalJLb7lCqcShXjUaj3qN7tumU3fgSwAkRcZhZqkCcsdnS7+XqLdeUfadk55JZkLyE8+NVqul45oAum6eopsvr7B9CyFKlqWlJZMmTSqTpw2iYC4veJOVmkGHL8fRdctUXJ7Xb7Od9L/hLjSZ2fC/7zBRPpSbO2wjRoxgxIgRhg7jqVk42OhNbZSVnIaFnXWe6Y46rByHW9sGXFz/O2i1ha5X6/X2XNt+qNB9p9y6o3utMNPP462c7XBs4Mmh0ct4eD2W7j9MJ+7wOZKj72CutuS1g0swr2TF7wNm6K1XlH0Xxb7hC8m4n4RdbXc6/99/+bHDuEL3LYQoWSqVij59+hg6jArPukplHJ+ryc9d/4uFfSW6bJzET53zts9uNLIPkb/+UaQp8IRpKDd32ExdZmIKFnZ/D0apslHrTbb+yP4PF/FDq5F4dG6O/f/uYD1pvZqvtOLGjqNP3ndCst42tDn6g8BmJqaQEnOXhItRaDKzuf3HeRzqVadO/44kR8Wz3XcMu3pNpt0X+glzUfZdFBn3kwB4eDWG9PtJWDrZFbpvIUTJSk1Nxc/Pj9TUvJ9LouxkJCQTf+IvslPSSY25R3ZqBiobtV4dr97tcGrspde2TZg+SdiMxJ3Tl6nS+jkUZkpsPd3IuP8Q/nErW2mRe0M0Jz2T7LQMctIyn7iea8v6JFyO1kvgrN0cUfyjF+3tP87j0bk5AG7tGuVpvJ+TkUVK9F2s3RwBcGxSi4eRcaBQkP6/ZCojMQWV3d9zshZ130Xx6MPI0skOtYtDbgL3hH0LIUqeRqPh+vXraJ4wq4cofXdPX8auljsKMyUqW2tUtmqykv/u+OTesSl13+zMwdFL83yHCNNWbh6JmrrMhGQufxtCj+0z0Go1/PFx7uTJHp2aYeFgw/Xth3h5wySU5mYoLcyJ3HGU5KjcSe3zWw+gVl9frm3TfyTZfuVYQt+Zq5dIJVyK5l74VXr8NIOcjGwOj8vtcFCnf0eSb90l7vA5jk9dR/sVY1CamxO9N4zES9GkRN2h/YqxdN82HXO1JWHzNhV732aWKl5a/zEO3tWw967GzZ3HOLvsx7/3fSSCblunkZOeidLcnOOfrgWtlms/HChw30IIUV5lPkzl4oY9dN82HaW5OSc/26D3PeG7ZBSptx/QddMUAPZ/sCjPpOjCNEnCZkQubQzm0kb9OeBu7Q3X/b3H77Mirwfwx8Q1eq8V5mYk34zP91Fr+MIthC/cold2Zcs+3d/3z13PMx9ddloGof+el29MRd13TkZWvsf1+L53dMs7d+mT9i2EEOXZ1e/3Fzhcx3dNh5VxNKKsyCPRCkSbncOhMcsq3L6FEM/OysqKJUuWYGVlZehQhKiQ5A6bEEKIQpmbm9OmTRtDhyFEhSV32IQQQhQqOTmZTp06kZz85HEThRClQ+6wGYitp5uhQyjXnvX8Puv6muwcHl6LBcCuVlWU5mYGiUOIkpSSklJ4JVEsxvRv3JhiEXlJwmYgL3090dAhiCd41uuTEnOP759/H4Bu30+jkrtTSYQlhChn5LtAFJU8EhVCCCGEMHKSsAkhTMq+ffv44IMPdK8jIyPp3r17oesdPnyYWbNmAbmj9rdp0wYHBwc2b847GnxBy7VaLcOGDaN9+/Z069aNqKgo7t+/z1tvvVUCR2bc1Go1mzZtQq1WF15ZCCP04uKRDIn9Ic9/g65sMHRoRSKPRIUQFcK8efNYu3YtkDuR+fbt2/nyyy/zrVvQ8p9++glLS0sOHDjAqVOnmDhxIt988w329vacO3eORo0alfpxGIpSqaRKlSoon2K2EiGMRdwf59k//Au9Mu1Tzt6hVJmjycouibCKRBI2IUS59/DhQxITE3Fyym1LaGZmhptbwQ2sC1p+6dIlXnjhBQB8fHw4ePAgAD169OCHH34o1wlbSkoKnTt3JjQ0FBsbG0OHI8RT0WRmP3Hmh/pDulP/392wrelGZlIqt49dYN/QBQD0O76Cq1sPYOlgg2evdiRFxvFrz4/LKHJ5JCqEqAAuXryIl5fXM2+ncePG/Pbbb2i1Wn777Tfi43Onh6tduzZnz5595u0LIQyn2X/68/zkQfy17jd+6jye3wfO5P5Z/bm1n3vvFdLvPmTnq5M49L9pHMuK3GETQpgUtVpNenq67nV6ejpqtZpz586xYMECunfvzoABA0pl3z169OCPP/6gU6dONG3alCZNmpTKfoQQpcOtbcM8bdbiDkew/4NFNBrRm7D53/HX2t26ZffPXterezf8ap5pHMuKJGxCCJNSr149/vzzTzIyMrC0tCQ0NBQfHx8aNWrEkCFDiIuLy7OOt7c3165dy2drxTd9+nQAQkJCsLS0BODq1avl+nGoEOXFndOX80yTmJ2WgUO96pirLYnZf+aJ698Nv1ya4T2RJGxCCJPi4ODAf/7zHzp16oSFhQWurq589dVXT1zH3t4ee3t77t27p2vH9vrrrxMWFkalSpU4duwYixYtYvDgwaxfv77A5Xfv3qVfv36Ym5tTo0YNli5dCsCuXbv0eq6amhYtWhRaR6vVkpiYiK2tLQqFogyiEqLk5aRnkhSZ90ddpapFGyszOzWjpEMqMknYhBAmZ+DAgQwcOFCvLDo6mh9++IGkpCR8fHzw9vbWWz5hwgS+/PJLPvnkEwC2bt2aZ7uPkrWCljs7O7Nv3z69svv375OYmEjjxo2f9nBMgkKhwM7OztBhCFEqEi5Fk52WgXuHpjy4cMPQ4eRLEjYhRLlQrVo1li1bVuDyF198kRdffLHE9+vo6MjGjRtLfLtCiJKntDBH7eKQpzztTgIRq36h2X/eICc9k5gDZzCzsqDaSz6cXbq97APNhyRsQgghhKgQ3Fo3wO/PoDzlmxr+m7B5m0m/95Dn3utBi+nvkJmYwu0/LhggyvxJwiaEEEKIcu/Q2OUcGvvkoTguBO3kQtDOfJf90HJEaYRVZDIOWznw8ssvM2TIEEOHUaaOHTtG27ZtsbKyomrVqnz88cfk5OQYOiwhhBCiVEjCJkxOVFQUXbp0oV69epw6dYqVK1eyatUqXWNyIYQQoryRhM1ILF++nAYNGmBpaYmrqyuvv/46AJ6ensycOVOv7tChQ+nYsSMAQ4YMISQkhK+//hqFQoFCocjTiy0/np6eTJkyhQ8//BAHBwdcXV1ZtmwZGRkZ+Pv7U7lyZTw8PPI04o6NjWXAgAE4ODigVqvp2LEjJ0+eBECj0VCjRg1mz56tt05GRgaVK1cmKOjvdgNLly6lfv36WFlZUbduXWbNmkV2dtHmZFu5ciV2dnZ89dVXNGzYkD59+jBjxgyWLl1KSkpKkbYhhBBCmBJpw2YEpk6dysKFC5k7dy5du3YlOTmZXbt2FWndJUuWcO3aNapWrcqSJUuA3F5rRbF06VI+/fRTTp48yebNm/H392fnzp28/PLLnDhxgu+//57Ro0fTuXNnGjRogFarpU+fPmRkZLBjxw7s7e2ZOXMmXbp04fLlyzg7O/PWW2+xYcMGJk2apNvPTz/9RHp6Om+88QYA06ZNY+3atSxevJhmzZpx4cIFPvjgA9LT05kxY0ahcR8+fJiuXbvqTULdvXt3Ro0aRVhYWKn0BBTClIW8MzffsacMwdbTjZe+nmjoMIQwOZKwGVhKSgrz589nxowZjBo1Slfu4+NTpPXt7e2xsLBArVY/cTLr/HTs2JHx48cDMGnSJObPn4+ZmZmubMKECcyfP5/Q0FAaNGhAaGgox48fJyIiggYNGgC541Z5enqyYsUKPv30UwYPHsycOXM4ceKEbjDO9evX06dPH+zt7UlNTWX+/Pls27aN7t27A+Dl5cXMmTMZPXp0kRK22NhY2rVrp1f26NhjY2OLdQ6EqAiSIuNIuBRt6DCEEM9AEjYDi4iIID09na5du5b5vps2bar7W6lU4uLiojc3olKpxNXVVTfBdUREBE5OTrpkDcDS0pJWrVoREREBQP369WnZsiUbNmygRYsWxMfH89tvv/Hzzz/rtpGWlsbrr7+uN1p6Tk4O6enp3LlzBxcXl1I9biGEEMLUSMJm5JRKJVqtVq8sKyurRLatUqn0XisUinzLNBpNsbY7ePBgpk+fzsKFC/n2229xdnbWJaSPtvX999/nGYkeivY4t2rVqnnmi7x9+7ZumRBCCFHeSKcDA2vQoAFWVlbs2bMn3+Wurq7ExMTolYWFhem9trCwKJMhLRo2bMi9e/c4f/68riwjI4Njx47pTXz95ptvkpiYyO7du1m/fj2DBg3CzMxMtw0rKyuuXbtGnTp18vz3qN6TtGvXjt9//10vkdy9ezfW1tY0b968BI9YCCGEMA6SsBmYjY0NAQEBTJs2jeXLl3Pp0iXOnDnDnDlzgNwx1r777jv27NnDxYsXGTduHDdu6M9z5uXlxalTp7h69Sp3794tsTtw/9S5c2datmzJwIEDOXz4MOfOnWPw4MGkp6fz4Ycf6uo5OjrSs2dPPv30U8LCwnjnnXf0jnfSpElMmjSJ5cuXc/HiRSIiIti8eTMTJkwoUhwffvghiYmJDBs2jIiICH7++WemTJmCv78/lSpVKvHjFkIIIQxNEjYjMGPGDGbNmkVgYCCNGjWia9eunD59Gsht+N+zZ0/8/Pzw9fXF3t5e19vykYCAAJydnWnatCkuLi4cPny4VOJUKBT8+OOP1K9fn549e9KiRQvi4uL4/fffcXZ21qv7zjvvEB4eTrNmzfJMij1lyhS++OIL1qxZQ9OmTXnxxRdZtGgRnp6eRYqjevXq7NmzhwsXLvD8888zfPhwhg8fzqxZs0rqUIUQQgijotD+s4GUEOKZpcTc4/vn3wfgjVOrqOTuZOCIjN+dsCv8+krucA89d87FpXkdA0dUfvzYYazR9BJ18K5Gn/2LDR2GMGHG9H6GsntPyx02IYQQQggjJ71Ey6HZs2fnmW3gccnJyWUYTfEcPHiQHj16FLh8165d+Pr6lmFEQlRcSpU5g29ufur111XtV4LRCFGxVYiETaPRsGTJElatWkVkZCQuLi7079+fzz77rFw2Uv/ggw/o379/keqeOHGi0DqZmZmsW7eOIUOGYGFhUWj9RwPmPo0XXniB8PDwApd7eHg89baFEMXj1rYh2zuMJdGIHj8JUVFViIRt3LhxBAYG8tprrxEQEMCFCxcIDAwkLCyM4OBgvSmOygNHR8ciT09VFJmZmQQFBTFw4MAiJWzPQq1WU6eOtF2qiDIS/77zm5mUasBIxCP2dT2I2X/G0GEIIagACVtERARLly6lb9++bN26VVfu5eXF6NGj2bx5MwMHDjRghEJUbA/+usmZxT9w45c/dGXBg2ZRq087mozth31tdwNGJ4QwFVVaP0fD93vh2MgTm2ounJ63iT8Xby18RRNh0reWzpw5Q+/evbG3t8fOzo4+ffoQGxuLra0tAwYMAGDTpk1otVrGjh2rt+6wYcOwtrZm48aNBohcCAFw+4/z/NrzYyJ/OoL2sYGQtdk5XP3hAL++MpG7Z64aMMKKy76OO4lXbhk6DCGKzNzaioTLUZycsYHU2w8MHU6JM9mELSQkhNatW3Px4kUmT57M7NmziY6OpkePHiQnJ9OsWTMgt42WUqmkZcuWeutbWVnRrFmzIrXhqujMzc3p1asX5ubl/oasKEMZiSmEvDOX7LTMAutkJqUS8vYcstMyyjAyAVClTUPijkQYOgwhiuxWaBinZ39L5M9H0GSWzgDyhmSS38B37tzBz88PHx8fgoODUavVALz99tt4eXkB6BK2mJgYnJ2dsbS0zLMdDw8Pjhw5QmZmZqm3zTJlVlZWTJ482dBhiHLm6pZ9ZD4spK2aFtLuJBD5y1Hq9O9YJnGJXGaWKjSZ2brXXbdMRakyY3ffqfDY8J2d107Auqojv/5rEtrs0p8iT4iKyiQTtnnz5vHgwQPWrl2rS9YA7O3t8fHxISQkRJewpaam5pusQW4i8qhOSSRs2dnZeSYlN3YpKSmF1snIyCAwMJDRo0cXeC4fFx0tPcrSbyfo/o6NjcVKk2a4YIzUX9+FgAIobOhuBZz/9nes2kpnlKeVlZVdaB0ztQU5/7vbqbJRk5mo/9lwaMxSeocspPGoPpxduh0A77e74N6hCb90/W+Rk7WsrGz5jBDPpCjv57JU3Pe0m5vbUz2xMsmEbfPmzfj6+uLt7Z3v8ipVquDm5gaAtbU18fHx+dZLT0/X1YHcxGTUqFGEhIRw584dqlatir+/P/7+/kWKKy4ujurVqxf3cAxq6NChhdbJzMxk586dODs7FymxDQoKKonQTFplpZovXF8BoGXLljyQhC2Pz52742xe+LA6Wo2W8EPH6F294LEFxZPNdOqCh8ou32UKMyXPTxpETmYWYfNyx1xz79CUmAN/6tVLjb3P0Ylr8F3qz6294WSnZdBi2juc/GwDiVdiihzLpUuX6G9in5PCuDzp/WwIxX1PR0VFUa1atWLvx+TasMXFxXHr1i2ef/75PMs0Gg1nz57V3V0DcHd35+7du2Rk5G0Dc+vWLb0kJDs7Gzc3N/bs2UNiYiJbtmxh5syZbNmypdSOR4iKKlWbRVFnxkvXGtcv6vJEm6MhbMF3VG3395y/1m6OpOXTaDvy5yNE/nKU9stH0375GG7/cYG/1u0uy3CFqLBM7g7bo0d4CoUiz7KffvqJ+Ph4vYStRYsW7Nmzh+PHj+uNkJ+enk54eDjt27fXlVWqVIkZM2boXjdr1oxevXpx6NChIg1E6+bmRlRU1NMclsFcuXKl0DopKSmsX7+e/v37F2mg4alTp5ZEaCYt/XYCh/41DYDjx49jVcXBoPEYo6tf7uT6V3sKradQKOj53/cY8Zb06H5aR/vPJeV6wc01ctIySb+XSCUPZ1Ju3dXrsftPxyYF8UbYatBoCXl7TrFj8fb2JmrL/xV7PSEeKez9XNaK+55+9ASwuEwuYatevTpmZmbs379fr/zGjRu6R5ePJ2x+fn7Mnj2bxYsX6yVsa9asITU1lUGDBhW4r6ysLA4ePMh//vOfIsVmbm7+VLc5DSk2NrbQOiqViqFDh+Lg4FCkR6Kmdg5KQ4ry77aVVatWlcnf81F5xOtErgvOTQ4KutGmUGBmYc7zw/tg5WhbpvGVJypV4R/1Ub+fotrLz3Pvz2vcDS94KJVar7dHoVCgVKtwalKL6JDTxY5FPiPEsyjo/WxubYWdV24ypFSZo3ZxwLGhJ1kp6SRFll6CV1bvaZN7JGphYcHgwYM5efIkvXv3ZvXq1UyZMoVWrVrh5JT7pfh4wta4cWNGjhzJtm3b6Nu3L0FBQQQEBDB+/Hg6dOjwxEFzR40aha2tLYMHDy7twzJqFhYWDB8+XHrSihJVyd2Jtgs/BBS5nQ/+SaFAoVDgu2yMJGtlIDr4FNW7PI9zs9rcDbucbx37uh68MOVtjk1Zy4WvdtF24YdYyrURRsK5aW16BS+gV/ACrN0cee7dHvQKXkC7hR8aOrQSYXJ32AACAwNRqVT89NNPhIaG0qZNG7Zv385nn33GlStX8nRGWLx4MZ6enqxevZpff/0VZ2dn/P39+eyzzwqclmr8+PEcPXqU0NDQCp+opKWl8dFHHzF//ny9XrlCPKu6fp2wsKvE6dnf5BmktXL96rwwZTAenZoZJrgKJi0+AZWNGnN1/j3BFeZm+C4bTcyBP7n8TTBmlirc2zehzfz32Td0QRlHK0RecUcjWFe1n6HDKDUmmbDZ2NiwatUqVq1apVd+7tw5GjdunCcJMzMzIyAggICAgCJtf+zYsYSEhBAaGoqzs3OJxW2qcnJyOHbsGDk5MsaSKHk1e7SkRvcW3D56ngcXb6JQKHBs6InLC/XybasqSk/M/jMk3bid77LmH/lRqaoTwQNnAZCTkcXBUYH03DmH2m904Or3+/NdTwhRMkwyYctPQkIC0dHR9OzZ85m2M3r0aEJDQ9m7dy8uLi4lFJ0Q4kkUCgVubRvi1rahoUOp0C59G0JWUt4haFxb1qfRh70JfXc+6fce6srvR0QSvmALrWa8S9yRCFJu3S3LcIWoUMpNwnb27FlAv/1acd24cYOlS5diaWmpmzEBwNfXl127dj1riEIIYdTyG8oDIP74X6yv7pfvsrNLt+sG0hVClB5J2B5Ts2bNIo8LVZFYWloyadKkIs1yIIQQQoiSZ3K9RAsyYsQItFotrVu3NnQo5Y5KpaJPnz6oVCpDhyKEEEJUSOUmYROlJzU1FT8/P1JTC5moWwghhBClQhI2USiNRsP169fRPGH0cyGEEEKUHknYhBBCCCGMnCRsQgghhBBGThI2USgrKyuWLFmClZWVoUMRQgghKqRyM6yHKD3m5ua0adPG0GEIIYQQFZYkbKJQycnJvPrqq/zyyy/Y2NgYOhwhRDHZeroZOgQdY4pFmCZjew+VVTySsIkiSUlJMXQIQoin9NLXEw0dghAlpqK+n6UNmxBCCCGEkZOETQghhBDCyEnCJgqlVqvZtGkTarXa0KEIIYQQFZIkbKJQSqWSKlWqoFTK20UIIYQwBPkGFoVKSUmhc+fO0vFACCGEMBBJ2IQQQgghjJwkbEIIIYQQRk7GYavgWrRoUWidjIwMpk6dStu2bbG0tCyDqIQQQgjxOEnYRKEsLS2ZNm2aocMQQgghKix5JCqEEEIIYeQkYRNCCCGEMHKSsAkhhBBCGDlJ2IQQQgghjJwkbEIIIYQQRk4SNiGEEEIIIyfDelQA447BrVRDRwEe1rColaGjEKXFWN5nIO+1f5JrUzJC3plLUmScocMwKbaebrz09URDh1EuSMJWAdxKhWtJho5ClHfyPjNecm1KRlJkHAmXog0dhqig5JGoEEIIIYSRk4RNCCGEEMLIScImhBBCCGHkJGETQgghhDBykrAJIYQQQhg56SUqdCKXDOFe6Ne5L5RKVJWrYtu4Mx6D52Dh5GHY4IQQQogKTO6wCT02DXxpsi6WxkE38Qr4ltTrYVyb94ahwxJCCPGY7lun03bBB3nKbaq5MCT2B1xb1jdAVKI0ScIm9CjMLVBVdsPCyQPbhu1x6TqclItHyUl9aOjQhBBCiAqrQiRsGo2GRYsWUb9+faysrKhevToBAQGkpKQYOjSjlnkvhgdHfgClWe5/QgghhDCICtGGbdy4cQQGBvLaa68REBDAhQsXCAwMJCwsjODgYJTKCpG3FknSuX2E+dmg1WjQZqYBUKVPAGZWlQB4cHQ7sd9N11snPeo81YcuwaXHh2UerxBCCFERlPuELSIigqVLl9K3b1+2bt2qK/fy8mL06NFs3ryZgQMHGjBC41LJuxWeY79Gm5nOg0NbeHgmGPdBM3XLK7d5jcptXtO9TvjjR25tmIRT53cMEa7R0Wq1xB2J4K+1u3Vll78N4blhPbG0r2TAyIQQQpgyk07Yzpw5w6effsq+ffvQarV07tyZlStX4u3tTc+ePdm8eTObNm1Cq9UyduxYvXWHDRvGxIkT2bhxoyRsj1FaqLGqWgcAdc1GZMRdJWq1PzVHrclTN/NuNDdXjaTO1F0oLa3LOlSjkxp3n5Ah87h35qpeefjCLZxd/iNt579P7Tc6GCg643Wqt+KJyy1ca9J4TWTZBCP0yLURwniYbMIWEhLCv/71L2rWrMnkyZNRq9WsW7eOHj16kJycTLNmzQA4ceIESqWSli1b6q1vZWVFs2bNOHHihAGiNx1V35xGxMjncO72PpXqvqAr12o0XF/0Fm6vT8Tas4kBIzQOGYkp7O43jYdXY/JdnpORxcHRS1FaqvDq1baMozNuTdbF6v5O/usI1+a+znOLTqOqXDW3UNpPGoxcG+OV+TAVC7u8d+0t/ncnPycjq6xDEqXMJBO2O3fu4Ofnh4+PD8HBwajVagDefvttvLy8AHQJW0xMDM7OzlhaWubZjoeHB0eOHCEzMxMLC4syi9+UWLnXxaHFq8Rs/IS603/TlcdumYmZ2g7Xf/kbMDrj8dfa3QUmawBotaBQcHzKWmr2aIlSZZL/9EqFqrKb7m9zG8fc/9u56JULw5BrY7wSr9zC89U2KJRKtBqNrty5eR002TkkXY99wtrCFJnkt8a8efN48OABa9eu1SVrAPb29vj4+BASEqJL2FJTU/NN1iD3LtujOiWRsGVnZxMXF/fM2ylpWVlVANVTr1/ltf9ycWI7ks7uw7ZxR5IvHOZe8Fc898XpYsaRRXT07aeOw1hpczScX7sTFID2SRW1pMU/IHzTb7h2blpW4ZWZZ32flaTy+l57WnJtSkZWVrahQ9D56+vd1H+3O+0Wj+RC0K9kJqbg3LwOzT8awJXv9pL5MNXQIQK55yw6OtrQYRgVNzc3zM2Ln36ZZMK2efNmfH198fb2znd5lSpVcHPL/QVobW1NfHx8vvXS09N1dR4ZMWIEv/zyC4mJidja2vLGG28wf/78IiV0cXFxVK9evbiHU+oaLD2HukbDQut5jlmXb7nNc215/qfcTCQ7OYHri97Gc/Q6zO2cihXHpUuXqN6tUbHWMQUOSisWufYscv05IyfyQ/K5UozIMIr6PisL5fW99rTk2pSMmU5d8FDZGToMAFKi77Lz1U/wmfAmL309EZWdNck3bnNuxc+cD/rV0OHpXLp0if5G+L1oSFFRUVSrVq3Y65lcwhYXF8etW7fw8/PLs0yj0XD27FmaN2+uK3N3d+f8+fNkZGTkudN269YtnJ2d9ZKxUaNG8fnnn1OpUiXu3r3LG2+8wezZs5k2bVqpHZMpubN7JVkPYon6v3F65U6d3qFK73EFrFW+KXlyw+w89RXFqy+EEPl5cP4GIe/MNXQYooyYXML2aLBbRT5fej/99BPx8fG6x6EALVq0YM+ePRw/fhxfX19deXp6OuHh4bRv315vGw0aNND9rdVqUSqVXL58uUixubm5ERUVVZzDKRP+56sQlV4y26ra72Oq9vv4qdb19vbmNyM8P89Kk5nNgW6TyU4u2kkeP+dTFvZuXcpRlb2SfJ89q/L6Xntacm1KxtH+c0m5bnzNXoyZt7c3UVv+z9BhGJVHTwCLy+QSturVq2NmZsb+/fv1ym/cuIG/f24D+McTNj8/P2bPns3ixYv1ErY1a9aQmprKoEGD8uxj7ty5zJw5k5SUFJycnJg7t2i/YMzNzZ/qNmdpU10GjODDWqVSGeX5KQneb77E+TWFP4ZQ2VjhM6QnqkrqQuuaGmN5n0H5fq89Dbk2JUMlnYWKTaUyzu9FU2RyQ/xbWFgwePBgTp48Se/evVm9ejVTpkyhVatWODnltql6PGFr3LgxI0eOZNu2bfTt25egoCACAgIYP348HTp0yHcMtokTJ5KcnMz58+f54IMPqFq1alkdnjBRDYb9K7c7fSFPOxv79y2XyZoQQojSZXIJG0BgYCDDhw/n2LFjBAQEcOzYMbZv3467uzvW1tZ5OiMsXryYBQsWEBERwciRI9m8eTP+/v7s2LHjidNSPffcczRt2pS33367tA9JmDib6i503TwFy8q2uQX5JG4NP3iVxv6v5V0ghBBCFMIk7+/a2NiwatUqVq1apVd+7tw5GjdunCcJMzMzIyAggICAgGLvKysri0uXLj1TvKJicG5Wh76HArny3T4ubw4lJeYeZlYqPDo1p/47XXHxyb9Xs/ibbeOOuh7JwrjItRHCsEwyYctPQkIC0dHR9OxZ9OEV/ikxMZHt27fTp08f7O3tOXv2LDNnzqRbt24lGKnxuLsniLvB/wdKJTU/WInas7FuWeKpXcR8+ykKMxXWtX2o8f4yNJnpXJrcGYW5Ck1mOh6D52DXpDPZyQ+49rkf2qwMADzHfI1lFU8DHZVhWVa2peEHr9Lwg1cNHYoQopQ5eFejzefvo9Vo0WbncDhgJck39YeRsqnhSrsvRqBUmXNz13EivvwZgFaz3sOpSS0UZkrCP/+OW3vDC9yP77LR2NaogsJMyV/rdnP1e/023G5tGtJ+xRgeXssdLPfQ2OUkR8XT7osR2HpWwdzaimtbDzyxnW31ri/w/OS3qOTuxDd1Cn6qZFerKn32LWJXnyncOX2ZBsN64vXai2iycrh/9hrHJksHg9JSbhK2s2fPAvrt14pLoVCwceNGxo8fT2ZmJq6urvTt25fp06eXUJTGIzvpPnd2r6T+/D/IiLvGzS8/xHtmqG55zKZp1J64DQuX6lye3oPUyD9R12xMvdn7UZiryIi7xvWFA7H7/A8eHNyMbQNfqvpN4f7B74jfEUj1974w4NEJIUTpS7/3kOC35pCVlIpHp2Y0HdePw+NW6NV5YfLbnJ7zLXdOXaL7tunc+PUPzKxU2Netxs5XP0Ht4sBLGz9+YsIWvnALSdfjUFqY0zv0C67/eBjNPwbxjdpzkqMTVuuVHZ2wGk1WNgozJa8dWMLFjb+Tk5aZ7z7iT/zFL13+S6/gBU885qbj+hF39Pzf+/39lC4R7LByHFXaNOD2Y8tFyZGE7TF2dnYEBweXUETGLeXycWwadURhrsKqWj2yH95Fq9Gg+N/jZHXNRuSkJKB1dEeTmYZ5pcq5Q6mY546WnpP6ELVX7mj9VtWeI/Fk7j/YnJQEzO1dDHNQQghRhtLvPdT9rcnKQZujyVPHvq4Hd07lNquJDj5NldbPEfXbCXIyMlGYKbGwtybjftIT95P0v6FENJnZoNWi1eZ9NO3RuTk9fppB/ImLnJ79LVqNRpfUmVlakBQVT056wfOLZjxILvR4nZvXJS0+Qe84kyL/HuZEk52d7zkQJcMkOx3kZ8SIEWi1Wlq3Ln/jW5WGnKT7mNtU1r1Wqm3JSU3UvXZsP5DL07oRMbI+Vh71sHDJHak660EcFz/25fK0bji07AWA2qsZyX8dIWJ0Y+K2z8f55XfL9mCEEMKAzKwsaPbf/pwP2plnmUL5dw+kjMQULCvbkvkwleSb8fQ9vJTuW6dzdun2Iu2n0cg+RP76B9rsHL3yu2eusq2dP7v6fIqFrTV1/DrqlnVYOY7Xjy7lzomLuXMaP4MmY/pydln+sbq2rI+1myPxx/96pn2IgpWbhE0Uj5lNZXJSEnSvNWlJmFnb617f/HIE9ReeoNGXlwEFCX/8COROBl1vzkGeW3iCm6tzx727vX0+ji/60TDwLF7jNnJjxftleCRCCGE4CjMl7VeMIWLlzyT8dTPP8sdzJAs7azIeJOHeoSlqVwe2thnF9g7jaDnjXRRmT/469urdDqfGXoTN25xnWXZquu7u2/Wfj+DYuJZu2f4PF/FDq5F4dG6OvffTj4dW7SUf7p25mu+dOPu6Hrww+W32vS9NYUqTJGwVVCXvViRFHECbk0167BXM7Zx1j0MBFEozzCo5AGBu70J20j00WZm6W/FKtS1mVja5lbVazO2cAVDZu5KTdK9Mj0UIIQyl3cIPidl3hpu7T+S7PPFSNM7N6gC5Sc/tYxdAARkJyaDVkpWchpmFOUpzM8ysLLB0yjtXqXvHptR9szMHRy/N9y6Zyvbv+bDd2jYk6Xpu5wOlRW6rp5z0TLLTMnTt1yp5OBf7OB0beeLWtiFdvv2Equ2b0GL6ENSuDlTycObFJaM4MHJJoY92xbMpN23YRPGY2zri3GUoFz9uD0olNd5fTuLp3eQk3cexw0DcB07n0uTOKFWWmNlUpmq/j8mIvcLNlR+A0gxtThbV3l0IgEtPfyIXD+bOnjVoM9PwGPK5gY9OCCFKn0enZnj2aotNdVe8erfjfsR1jn+6Do9OzbBwsOH69kOcmv0N7RZ+iMLcjKjfTpB8M56U6LvU6vMiPX6cgZmligtf7SInI4uq7ZtQrXNzTkz7Wm8/vktGkXr7AV03TQFg/weLSLuTwIuB/hwavRSvPu3wHvgSOZlZpETf5fD43I4PL2+YhNLcDKWFOZE7jpIcFY/C3IzOaz/il64f6e3DuXldfCa+ibW7E12/+5SIVb9wKzSMlp8NIfyLH/hzyTb+XLINgBcXj+Ti+j2kxSfQYeU4rBzteHHxSADOLtv+xA4U4ukptPm1XhTlSv+9cM0IfvjUsoUtnQwdhSgtxvI+A3mv/ZNcm5LxY4exJFyKLrXtN/Z/jajfT+X7aLWkuLaoh2MjL/5au7vU9vE4B+9q9Nm/uEz2Vd7JHTYhhBDCCBS188GziD9xkfgTF0t9P6LkSRs2IYQQQggjJwmbEEIIIYSRk0eiFYCHdeF1yoKxxCFKhzFdX2OKxRgY0/kwpliKy9bTzdAhmBw5ZyVHOh0IIYQQQhg5eSQqhBBCCGHkJGETQgghhDBykrAJIYQQQhg5SdiEEEIIIYycJGxCCCGEEEZOEjYhhBBCCCMnCZsQQgghhJGThE0IIYQQwshJwiaEEEIIYeQkYRNCCCGEMHKSsAkhhBBCGDlJ2IQQQgghjJwkbEIIIYQQRk4SNiGEEEIIIycJmxBCCCGEkZOETQghhBDCyEnCJoQQQghh5CRhE0IIIYQwcpKwCSGEEEIYOUnYhBBCCCGMnCRsQgghhBBGThI2IYQQQggj9//PxqrTJ2cpmgAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "execution_count": 6, @@ -188,9 +188,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtMAAAD2CAYAAAAUCgudAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPVUlEQVR4nO3deVxU1fsH8M8MMwPDLrKqyCKS4QaY5kYqKmqUUC6YppmZmblUlgtpYq6ZlmtmYppmLi2mmZoJ7rmloLikooiAoKggMCwDM/P7g5/zbQQEhuXOwOf9elnMOefe88y9M8PDnXPPEWk0Gg2IiIiIiKjSxEIHQERERERkrJhMExERERHpick0EREREZGemEwTEREREemJyTQRERERkZ6YTBMRERER6YnJNBERERGRnphMExERERHpick0EREREZGemEwTEREREemJyTQRERERkZ6YTBMRERER6YnJNBERERGRnphMExERERHpick0EREREZGemEwTEREREemJyTQRERERkZ6YTBMRERER6YnJNBERERGRnphMExERERHpick0EREREZGemEwTEREREemJyTQRERERkZ6YTBMRERER6YnJNBERERGRnphMExERERHpick0EREREZGemEwTEREREemJyTQRERERkZ6YTBMRERHVA7169cLIkSOFDqNCXn/9dTRr1gxyuRwNGzZE7969ceLECaHDKhWTaSIiIiKqEKVSWSv9dOzYERs2bMCVK1dw8OBBNGnSBL1790ZKSkqt9F8ZTKaJiIiIjMSqVavg4+MDU1NTODo6YsCAAQAAd3d3zJ07V6ft6NGj0b17dwDAyJEjERUVhe+//x4ikQgikQiHDh0qtz93d3fMmDED48aNQ8OGDREQEIBx48bB3d0dmZmZ2najRo3CM888g5ycHMTHx8Pa2hpfffWVtv7KlSuwsLDAt99+W6HnOX78eAQEBMDd3R1t2rTB0qVLoVAo8M8//1Ro+9okEToAIkMU9cZCZN9KEzoMAICVuzN6fj+tWvdpSM/PWNTEeQCAormLoEm9W+37rSyRixMkM6YIHQYZMUP7XKmp96yQZs2ahSVLlmDhwoUICgpCTk4O9u7dW6Ftly1bhps3b8LFxQXLli0DANjZ2VVo2+XLl+PDDz/EiRMnUFRUBE9PTxw7dgxvv/02fvrpJ/z444/YvHkzTp48CUtLS3h5eWH16tUYNWoUunXrBh8fH4SFhSE4OBhjxoyp9PPOz8/H119/DUtLS7Rv377S29c0JtNEpci+lYbMa8lCh1Fj6vrzMyaa1LtAkvDnQiN0AGT0+LlSsxQKBRYtWoQ5c+Zg/Pjx2nJ/f/8KbW9jYwOZTAa5XA5nZ+dK9d2+fXtERETolG3btg3PPfccpk+fjlWrVmHRokXw8/PT1g8bNgwHDhzAkCFD0KVLF2RnZ2Pt2rWV6vfrr7/GlClTkJubi8aNGyMqKgqNGjWq1D5qA4d5EBERERm4S5cuIT8/H0FBQbXed4cOHUqUPfvss1i8eDEWLlyIrl27YtKkSSXarFy5EkVFRdi4cSN+/PFH2NjYVKrfYcOGITY2FseOHUPPnj0xcOBA3L59W+/nUVOYTBMREREZObFYDI1G9zumwsLCatm3hYVFqeWHDx+GiYkJkpKSkJ+fX6I+Pj4ed+7cgUgkQnx8fKX7tbGxgZeXFzp37owNGzbA3NwcX3/9daX3U9OYTBMREREZOB8fH5iZmWH//v2l1js6OuLOnTs6ZTExMTqPZTIZVCpVtcSzbt067Nq1C0eOHEF2djY++OADnXqFQoEhQ4ZgyJAhWLx4Md577z29Eur/UqvVpSbtQuOYaSIiIiIDZ2lpicmTJyMiIgJyuRy9e/dGXl4e9uzZg+nTp6NXr174+uuv8corr8DNzQ3ffPMNEhMTdW4y9PDwwMGDB3Hjxg3Y2NjAxsYGUqm00rFcvXoVkyZNwtKlS9G5c2ds2bIFL7zwAoKCgvDKK68AACZOnAiVSoWVK1fCwsICBw4cwGuvvYa///673D4vXryIvXv3IjAwEA4ODrh79y5Wr16NhIQEDBs2rNLx1jRemSaiWtf3l9novHhsiXLLJg4YmfozHDu0ECAqIiLDNmfOHMybNw/Lly9Hq1atEBQUhHPnzgEApk6diuDgYISFhSEgIAA2NjYYNGiQzvaTJ0+Gvb092rZtCwcHBxw/frzSMRQUFGDIkCHo27evdmaOTp06Yfbs2Rg9ejSSkpKwfft2/PDDD9i6dSssLS0hEomwYcMG3LlzB+Hh4eX2YWZmhqioKLz44ovw8vJCaGgoHj58iKNHj3I2DyIiIiLSj0gkwqRJk0q92c/KygqbNm166vaenp44cuRIpfq8deuWzmNTU9MSw0cAIDw8XJsou7q6YvDgwTr19vb2FV5wxcvLC/v27atUnELilWkiIiIiIj3xyjRRNRJLJRhxe6ve229wGViN0RAREZVt/vz5mD9/fpn1OTk5NdJvv379cPTo0VLrAgICKrwQjaGo88n0ggULcO7cOZw9exYJCQlwc3Mr8ZUFUXVx7twSO7q9j0dcuKBa9N3xGWSWcoikEtw7dQUnp0dCo1YLHRYRUZ0wduxY7XCMCxculKg/c+aMzmOlUokNGzZg5MiRkMlkT93308Y2R0ZGIi8vr9Q6uVxeXtgGp84n0+Hh4bCzs4O/v7/OGvJENcGmeWPcOXxe6DDqjKjhC1CYU/yB2z3yI7i/3AkJOyt/wwwREZVkZ2enne0jIyOj3PZKpRKRkZEYOnRoucn00zRu3FjvbQ1RnR8zfePGDTx48AB//fWXQS5BSVQfKbNyIbMuuQiAzKa4TFVQvNDA40RaJDGBiVRSYkGC+uqtmNPoe+JQqXWy37djc3Ji7QZEVI7GgX7o/9cXGH5rCwae/ho+77wkdEhE1cZok+nz588jJCQENjY2sLa2RmhoKFJTU2FlZYUhQ4Zo23l6egoYJdUnNl6N8Ci+Yncq13eP4lPQsI0nRGLdjyB7Py+oi1TITkjVlvX5OQKvXfwOhTl5SNx9srZDJaIqati2GXpumIrkgzHY1fsjxC7ejnbThuKZEbW/LDZRTTDKZDoqKgodO3bE1atXMWPGDMyfPx/Jycno168fcnJy4OvrK3SIVA85dWqJtL8vCR2GUfj3+30wc7BBl6XvoWEbT1i5OcEjtAv8pgxB/LaDUGblatv+OTAC23zfholcBueurQSMmoj00XLMS7gfewPn5v+IR9dTEL/9EK58txetx4cKHRpVkkQiQf/+/SGR1PlRwpVidEcjPT0dYWFh8Pf3x4EDB7QD1YcPHw4PDw8AYDJNgjAxlUKtLNI+Dto+C2KpCfa9Ogv4z/CEwPVTYe5ihz9eCoemqHqWdTU2iuT72PPyJ/Cf+hp6fj8NUmtz5CTexcWvd+Fy5B8l2qvylbi99zSa9mmP1CMlb5IhIsPl2KEFrv8YpVOWcjAWrcaFwNzFDrmpDwWKjCrLzMwMM2bMEDoMg2N0yfTnn3+OjIwMrF+/XueOTxsbG/j7+yMqKkqwZLqoqAhpaWmC9E3Vq7CwqNw2JnIZVHlKAIDUUg7lI4VO/bFJKxAStQStx4cibsUOAID38N5o1K0Nfg/6uMKJdGFhEZKTq3d2kIo8v5qWcTkRUW8sLLNeamUOsUyCggdZEJmI4dr7OUGv/NfEeQCAhkWFen0QH36QjgZ7fq22OIqKCnG3Bp4f1R9lfa7IHW2Rl56pU5Z3L+P/6xrUWDJdU+/ZukqhUJTbpqCgAMuXL8fEiRNhamr61LbGeOydnZ31uupudMn01q1bERAQAG9v71LrnZyc4OzsrNe+i4qKMHnyZGzatAlqtRoDBgzAqlWrYGZmVqHt09LS4OrqqlffZFjmNuyNxlLrUutEJmK0Cx8GlbIQMZ8XzyndqFtb3Hniimlu6kOcmLYWASsmIOVgLIryCtA+4g3889kmPIq/U+FYrl27hsHV/Lp62vMzFDIbc/SI/BhiqQQiEzFSj5zH1U37BYunJs4DAMR27wMfK5tKb9fB1g7r/DqUKPeJ1m9+1mvXrsGXn19UBYb2uVJT79m6avTo0eW2USqV2LNnD+zt7cudzSMyMrK6Qqs1SUlJaNKkSaW3M6pkOi0tDSkpKQgLCytRp1arERcXBz8/P733P3/+fBw8eBBxcXGQyWTo378/pkyZguXLl1clbKpjNCo1YhZvQ59tsxCD4mTa3NkOeXdLTit0a9ffcA16Di+smoiiPCXunryCfzcYzxKpQlIk38fuvlOFDsNgyU1M4GVhJXQYROXKu5cJuYOtTpnZ/z9+fIWayJgZVTL9+CsIkUhUom7nzp24d+9elYZ4REZGYtGiRdr5DyMiIjBo0CB89dVXMDExKXd7Z2dnJCUl6d0/GY4TgxdCkVD2kB1VnhL5Dx7BorE9FCn3n7qQyKnwSAyK+RZQaxA1fEGlY/H29kbS9u8qvd3TlPf8qKSaOA8A0HDOIiD1brXvt7K8vb2RtMn4riSR4Sjrc+Xe6X/RqLsvzn/1s7ascQ9f5CTdq9Hx0jX1nq2r4uPjy22jUCiwceNGDB48GBYWJac3/a9Zs2ZVV2i1Rt+RDUaVTLu6usLExASHDx/WKU9MTMSECRMA6H/zYWZmJpKSknS29/f3R3Z2Nm7duoVmzZqVuw+JRKLX1wNkeKTS8t8aSX+dRZNe7fDgwk3cj71RZjvPAS9AJBJBLJeiYRtPJEedq3Qs1f26qsjzI101cR4AoFAirfZ96kMikfLzi6qkrM+VS9/uRvDv8+A37TXc/Pkw7P2a49lR/XAm4vsaj4ev6YpLTU0tt41UKsXo0aNha2tb7jCP+nTsjeo3qkwmw4gRI7B+/XqEhIQgODgYSUlJWLt2LZycnJCSklIimd60aRMSE4sXMEhPT4dSqcTcuXMBAG5ubhg+fDgAIDs7GwBga2ur3fbxz4/riP4r+cBZdPlyHERiEf5dX/rQDZvmjfHczOE4NXM9bL2boPOSd7Ez8EMUPORriojqhwfnbyD6zUXwnz4Urcb2R156Js59vgVXNwp3DwTpRyaTYcyYMUKHYXCMKpkGgOXLl0MqlWLnzp2Ijo5Gp06dsGPHDnz22WeIj48vcWPiunXrSlzJnjlzJgCgW7du2mTayqp47OGjR4+0l/kfLz/+uI7ov/LuZUJqKYdEXvodzSKJCQJWTsSdIxdwffMBmJhK0eiFNui06B0cGr24lqOluqS0Gw8fU748uBYjIaqY5Khzlf5WjgxPXl4epkyZgkWLFunMqFbfGd2iLZaWllizZg3S0tKQnZ2N/fv3o1OnTrh48SJat24N8RMrqh06dAgajabUf4cOHdK2s7W1haurK2JjY7VlMTExsLKygru7e+08OTI6dw6fR3Zi6eNd/aaEwcKlIf6evBpA8RLZR8cvh2vvdmg2qFtthklERFRlKpUKp06dgkpVP9dIKIvRXZkuTWZmJpKTkxEcHFyl/YwePRoLFixAQEAApFIpIiIiMHLkyArdfEj107Ufo1CYnVei3LFDC7R6NwTRoxYh/0GWtvzhpVuIXbwdz88ZhbS/L0GRcr82wy2TiVyGPttnwbZ5E5yY+i0Sdh4v0aZxoB/8Pg6DulCFB3E3ceqTdQCA1hNeQdN+HSASiXDlu7248dPhEts+5jt5MNz7d0L+/Swos3IR/ebnOvWWTRzQfd1HsGnWCPsHf4b0c9d16rsuGw+5gw3+GjqvzD48QrrAZ8xLUCkLkZeWgaOTVugsplNWzA7tvNF+1htQFxZBo9Hg6ITlXEyCiIjKVSeS6bi4OABVX/kwPDwc9+/fR8uWLaFWqzFw4EB8/vnn5W9I9VZp0+EBxXevb3QtOYUjAMSt2KFdxMVQqAuKcHDUF3hmRFCZbXwnD0b0W18g984D9Nr8CRo864asW6nwGtwdO154HyamUoREL3lqMg0A57/8udRkHQDy7j/C/rA56BDxRom6Bs+6QWb99LvHASA95jr29P8EGpUa7cKHwSOki05MJnJZqTE/uHATe/p/AgDwGhKIZ9/sh7PzN5fbHxER1W9GN8yjNNWVTEskEixfvhwZGRl49OgR1q1bxzFBVC9o1OoSK5Q9KePf25BZW0AkFkNiJkPBoxyo8guhSH0IiZkMEgszKLNyy+2r9fhQ9Ns5p9ShLqp8JZSZOaVu1/aDgbiwvPwV/3Ju34NGVTxVobpIVWLawrJiVv9n9TaZlRwPL98qty8iovrE1NQU4eHh5a5+WN/UiSvT48aNw7hx44QOg6hOS9hxDEFbZqAotwCpx+OQe+cBgOJx468cWw6RWIR/5m566j6ufLcHsUu2Q2opR9C2T5F+9hqybpY/HZNzp5Z4dPMO8stJ+P/L2tMFjXv44sKKJxJwjabMmBv38IXflCGQWspxQI85wYmI6jKpVIrQ0FChwzA4deLKNBHVvI4LRmN3v2n4tcsEQAM07dse1p4uaNq3PX7p9B5+6TQez77ZD2b2ZS+NXZBRfNW5MCcPKYdi0cDHvUJ9t54Qiktf76xwrHIHW3RdNh6Hx34FVZ5Sp+5pMaccjMXuftNwdsGP8J8+tML9ERHVB7m5uQgLC0NubvnfQtYnTKaJqEI0ajWUj4pXIc1/kAXTBlaASITCnDyolUVQ5SuhKiyC1MIMIhMx5I62JfYhtTIHAIjEYji2b4HshPKvSksszCB3sEW3bz5A1+Xj0bCNJ1q+2x8AYNHYvkR7mbU5ukd+hFMzvit9ppUyYhbL/vdFnfKRAqp8ZcltiYjqMbVajYSEBKifsupvfVQnhnkQUdV1j/wIDVt5oCg3H/b+zXFm1gY07uELma0lEnYcQ8wX29Hn5wiolIVQZipwYcWvUOUp8SDuJl78fR5EYjHuHCmeKtDKwxnPzRiOg299odNH+1kjYOvtCpFEjNt7TuHhpVsAgK7LJ+DYxBUwMZWi58bpsPVuAhvvJri95xTiVv6GXb0/BlA820enRWNwafUuAECvTdOxM3CyTh+tx78Cq6aOaP/pCABA/LaDiN9+CK3Hh+L2/n/w6FpyqTF7vhoA79d7QaPWQF2kwomPvqnhI05ERHUBk2kiAoBSF5JJORir/Tlx9wkk7j5Ros25+T+WKHPwa47rW6JLlP9dRoJ6bOIKAMVzce8P+6zMGHOS07XT4pk72+nE99jZ+ZtLnYUjbuVvT4355q9HcfPXo2X2TUREVBom00RU7WojKc1Ne4h/5jz9hkciIqo+ZmZmWLZsGczMzIQOxaAwmSYiIiKickkkEnTq1EnoMAwOk2miUli5O1dpe3WRSjvlm7WnC8QS/VfRrGostbXPqqrOY1YTauqYiVycoKmRPVeOyMVJ6BCIyMDl5OTg5Zdfxu+//w5LS0uhwzEYTKaJStHz+2lV2l5x5wF+avcOAKDPTxGwaNSwOsKqNlV9fjXB0I9ZTZHMmCJ0CEREFaZQKIQOweBwajwiIiIiIj0xmSYiIiIi0hOHeRAREZFgui59D15hPUqUFyrysNlruAARUVnkcjm2bNkCuVwudCgGhck0ERERCSrt5GUcHvOlTplGz1X2xFIJ1IVF1REWPUEsFsPJyQliMQc2/BeTaSIiIhKUWlmEvPTMMutbjOyLFm/2gZWbM5TZubh76op2oamBp7/GjV+OwNTWEu79uyD7Vhr+CJ5eS5HXLwqFAoGBgYiOjuZsHv/BZJqIiIgMlu9Hg9Fy7Ms4O28z7hw+D4mFGZoE+um0efatF3F5zW7seTkcIgObVpPqPibTREREJCjnzi0xLF53RdO045dweOxXaDUuBDGLtuHf9fu0dQ/jEnTa3o+9gdgl22slVqInMZkmIiIiQaWfu45jk1bqlBXlFcD2GVdI5Ka4c/j8U7e/H3u9JsOrF9q3b19um4KCAsyaNQudO3eGqalpLURlHJhMExERkaBU+Upk30orUW7hUrHFm4pyC6o7JCqFqakpIiIihA7D4PB2TCIiIjJImdeSUZRXgEbd2godClGZeGWaiIiIBCWWSSB3sC1RnpeeiUtrfofvR4OgylfizpHzMDGToUlPf8St2FH7gRKVgsk0ERERCcq5ow/CLkSWKN/S8k3EfL4V+Q+y8Oxb/dB+9htQPlLg7skrAkRJVDom00RERCSYY++vwrH3Vz21zZXIPbgSuafUup87jKuJsIgqjGOmiYiIiIj0xGSaiIiIiEhPHOZhYKLeWFjq9EBUNit3Z/T8fprQYRDpxVDe88b0PvrgFJCSK3QUQGNz4KvnhY6CiITGZNrAZN9KQ+a1ZKHDIKJawvd85aXkAjezhY6CiKgYh3kQEREREemJyTQRERERkZ6YTBMRERER6YnJNBERERGRnphMExERERHpibN5kFbfX2YjKyEVf3/0jU65ZRMHDDyzGntCZuDe6X8Fio6ofuu69D14hfUAAKhVKuTdzUTq8Ys4N38zctMeChwdEVH9xWSaiMhIpJ28jMNjvoTIRAwrdyd0nD8a3b+djD39PxE6NKNxa9lIPIj+vviB2ASyho1h7d8PjV+fB4l1Q2GDIyKjxGSaiMhIqJVFyEvPBADkpj3E1R8OoOO8tyC1lKMwJ0/Y4IyIpU8APKdsh0ZVhNwbZ5G4cjSU95PQ/NM/hA6NiIxQvUimFyxYgHPnzuHs2bNISEiAm5sbbt26JXRYRER6kzs1gPtLHaEuUkGjUgsdjlERSWSQNnAGAMjsmyAv8SLubPkU6oI8iE3lAkdHRMamXiTT4eHhsLOzg7+/PzIzM4UOx+j13fEZZJZyiKQS3Dt1BSenR0Kj5i9zoprm3LklhsVvgkgshkRuCgC4uHoXivIKAABN+3WA74eDdLax8W6C0zPX4+rG/bUer7EQm8oBtRoaVZHQoRCREaoXyfSNGzfg6ekJAGjVqhVycnIEjsi4RQ1foP1KuXvkR3B/uRMSdh4XOCqiui/93HUcm7QSJqZSuPfvjEYBbRDz+RZt/e29p3F772nt46Z928N/+lDE/3RIgGiNQ97ty7i3ZxUsvJ+HibmV0OEQGRy1SoXkA+dw85cjyEt/BKmFGZr0bodmA16A1JLf5ABGPjXe+fPnERISAhsbG1hbWyM0NBSpqamwsrLCkCFDtO0eJ9L0dMqsXMisLUqUy2yKy1QFhQCgTaRFEhOYSCXQaDS1FyRRPabKVyL7VhoyryYh9ottyE66h+fnvVVqW3MXOzw/fzQOj10KVZ6yliM1bNkXDyEmzBLnBslxeWIrmDp5wmPyj0KHVWc5dXwWgeunYuCZ1RiZ+jPavD9A6JCogh7duIPfXngf0SM/x63fT+DuqStIjjqHk9PWYrvfGNz+84zQIRoEo02mo6Ki0LFjR1y9ehUzZszA/PnzkZycjH79+iEnJwe+vr5Ch2h0HsWnoGEbT4jEui8Lez8vqItUyE5I1Zb1+TkCr138DoU5eUjcfbK2QyUiALGLt8ErrAcatm2mWyES4YWVkxC38jdkXEkUJjgDZuH9PJ5dGouWK6/A76d8eH/2F0ydedGlpkjMzZB5PQn/zNmE3LsZQodDFaRIfYB9r36KrJv/+92P/1w8K1Tk4+CoL3Dn8HkBojMsRplMp6enIywsDP7+/oiJicHHH3+M8ePHIyoqCrdv3wYAJtN6+Pf7fTBzsEGXpe+hYRtPWLk5wSO0C/ymDEH8toNQZuVq2/45MALbfN+GiVwG566tBIyaqP7KTkhD0l//wH/aazrlbd8fAGV2Lv79bq9AkRk2sUwOMxcvmDq5QyyVCR1OnZcSHYNz83/ErV1/Q60sFDocqqC4lb8h715m2Q00Gmg0GpyetaHef0NtlGOmP//8c2RkZGD9+vWQy/83XsfGxgb+/v6IiooSJJkuKipCWlpalfZRWCjcDTCK5PvY8/In8J/6Gnp+Pw1Sa3PkJN7Fxa934XJkySmjVPlK3N57Gk37tEfqkQsCRFyssLAIycnJgvVfmvy7mdqfU1NTYabmtGXlqa/HrKrv+Ytf70Lw7/Pg3Kkl0k5cgmP7Z9B8aE/8HvRxpeMwtPdRWQoLnQBIhQ4DhYWFSE6+K3QYBkPI31+lMabXtKEpyi3A9S3R5TfUaJB5NQkXdx9BA79m5bc3cM7OzpBIKp8aG2UyvXXrVgQEBMDb27vUeicnJzg7O+u17+3bt2P58uWIjY2Fvb19pabQS0tLg6urq179Pja3YW80llpXaR9VkXE5EVFvLCyzXmplDrFMgoIHWRCZiOHa+zmk/X2pFiMs6dq1axhcxeNe3RqI5fjS8UUAQIcOHZBRTxLDqqivx6yi7/lj768qtTz9n6vY4DIQACCzNkfAiok4NmklCjIqd6O1Ib6PyuKz4iLkTVsKHQauXbsG1z78Zu4xoX9/PcmYXtOGxk1iiwj7nhVu/9GQt7E/93oNRlQ7kpKS0KRJk0pvZ3TJdFpaGlJSUhAWFlaiTq1WIy4uDn5+fnrvv0GDBhg/fjzu3r2Lr776qiqh1kkyG3P0iPwYYqkEIhMxUo+cx9VNnHKLyBA880YfyB1t0WH2SJ3y+J8O4/K3u4UJysC4T9ogdAhEBk8MUY22r2uMLplWKBQAAJGo5InbuXMn7t27V6UhHr179wYA/Pbbb5Xe1tnZGUlJSXr3DQAnBi+EIqFqQ0VqkiL5Pnb3nSp0GDq8vb2RtP07ocPQkX83E8deigAAnD59GmZOtoLGYwzq6zGrzvd83IodiFuxQ69tDfF9VJYJl52QlC90FMXH7M8qfubXJYb2+8uYXtOGRpmpwNG+Myu8INT8tcuw9gXj/5ZG31ENRpdMu7q6wsTEBIcPH9YpT0xMxIQJEwAId/OhRCLR6+uB/5JKje6UCE4qrfpxr24K8f/G8ru4uMCiUUMBozEO9fWYGcp73hDfR2WRXgdgAMm0VCo1mmNWGwzltfyYMb2mDU4TILl/Z9zccezp7USAuXNDtB3cG2KJSe3EZoAM65VfATKZDCNGjMD69esREhKC4OBgJCUlYe3atXByckJKSkqJZHrTpk1ITCyeHio9PR1KpRJz584FALi5uWH48OG1/TSIiIjqBYm5Gaw9iq/4iaUSyB1sYdfSHYWKfGTfMpwr2aSr9YRXkLj3dPEaE6XN1iECoAH8Ph5crxNpwAiTaQBYvnw5pFIpdu7ciejoaHTq1Ak7duzAZ599hvj4+BI3Jq5bt67EleyZM2cCALp168ZkmoiIqIbYt22Gvr/O1j5+dlQ/PDuqH9L+voR9A2YJGBk9TYNn3dBz4zREv7kIRYp8bfKspQHazXgdzV+r+I2KdZVRJtOWlpZYs2YN1qxZo1N+8eJFtG7dGuInFh05dOhQLUZHREREj6WduKSdcYaMS6OANhhwYiWu/xiF61uikZ1YPBVks0Hd0Oq9UDR4hrOlAEaaTJcmMzMTycnJCA4OrtJ+VCoVCgsLUVhYCI1Gg/z8fIhEIpiamlZTpBVnIpehz/ZZsG3eBCemfouEncdLtGkc6Ae/j8OgLlThQdxNnPpkHQCg1w/hsPfzwqXVuxC38ren9tN16Xto4OOGwuw8PLqRghNTvtWpt/drjs6Lx8LG0wU/dxiHvPRMAIBr0HNoM/FVqAqLcG3TX7j569Ey+2jxZl94hHQBRCJkJ97F8Q9WlbixofPisbBu1giqfCWOT16N3DsP0PaDgXDp2hoAYOXhjIurduLKuj3lHToio9d8aE80HxIIjUaNE1PXIvPf29q6Hus+hqmtJQCgoW8z7HnpE2RcScTz894qXsXURIzYL7Yh5WAsPEK6wGfMS1ApC5GXloGjk1ZArTSs+YBrgrogF9dm9kR+8hU0HfsN7F4YolOfeWoX0n6eD5FEBvs+76Bh92EouHsLCUuGQiSRQqMqQtN3V8PcvY1Az4DIMMgdbNFm0gA0G9QdP7V7BwDgP21ovbmvpSLqTDIdFxcHoOo3H27atAlvvvmm9rFcLoebm1ul5puuLuqCIhwc9QWeGRFUZhvfyYMR/dYXyL3zAL02f4IGz7oh40oi/v74GzQKaAO5o22F+jo5bS3Sz5U+R+Sj68nY0/8T9No4/X+FIhHafTIMu/tNh6pAib6/zkbSX2dRmJ1b6j6u/XAA/67fBwDounwCGr3QBikHY7X1Tfu2h6qgEPte+RQN23ii3Sev4+h7y3D+q59x/qufAQAv71+ExD+4dDnVfTJbSzzzRhD+CA6HlZsTOi18G38O+t/X5Aff+gIAYNrQGn1/jkDGlUTYNG8Mm+ZNsOflTyB3sEXPH6Yj5WAs0mOuY0//T6BRqdEufBg8Qrrgxk+Hy+q6zhBJTNFs+g6k7/umRJ1GrUbKxmlosfg0xDIzXP2kO2zbvwSZfRM8s/AYRGIxsi5EI+2n+fD8eKsA0RORMTHK5cRLU13J9MiRI6H5/yUyH/8TIpEGij/wH18FLkvGv7chs7aASCyGxEyGgkfFCzXkpj6sVF8d5oxC319no3EP3xJ1hTl5xeOl/sPMzgr597NQlJsPjUqNR/F34ODfvMz9q/+zMpZIBGQ9MX2StWcjPDh/AwDw4MJNOD3fQqfe1rsJlI8UyE2r3PMiMkYOfl5I+/sSNEUqZN24A1M76+I3zhM8Xu6MW7+fAADk3c2AqkAJkYkYMhtzFDzMBgDk3L6n/RZIXaSCRl2xqa6MncjEBNIGpU9zVZR1HxJbR5jILSEykcCs8TNQXDsFkYkEov8fJqjOzYLco21thkxERqrOXJkeN24cxo0bJ3QYtS5hxzEEbZmBotwCpB6PQ+6dB5Xex5nPNqLgYTbM7G3Q95cIpJ+9BmVW6VeYH8t/kAUze2vIHW1RqMiH0/PPlrukeOvxofAaEoishFTk3tVNijP+vY1mA7shfvshNO7hC3lDG516zwEvlD9FD1EdIbO1hPKRQvu4MCcPMmtznTIA8Hw1AEcnrgAAKLNykXP7Hl49vgISuQyH312q09ba0wWNe/jiwopfazx+QyexcUBR5j0UPkyF2MwSOZePwrpt8RoDuTdjcfubd6G8n4Rm03isiKh8debKdH3VccFo7O43Db92mQBoiodLVNbjK1j59x/h/vmbsPJwqdB2J6Z+ixdWTUK31R8g82pSiQT5SXErf8OOrhORfSsNXoN76NSlRMcg6+Yd9P1lNhoH+uHhlUSdercXn0fi7hOVeFZExkv5SAGZtYX2sdRSXuIPXMumjhCZiLVTizXq1hZyR1v80mk8dnT7AB3mjILIpPgjXu5gi67LxuPw2K+gylPW3hMxUCKRCE3HfYOEL4chYclrkDdtBWnDRgAAc09ftFh0Al6f7MLtb8cLHCkRGYM6c2W6vtKo1dqrVfkPsmDawKrMtiZmMkgszFDwIEunXGpljsLsXJiYyWDX0h2K5PQK9X335BX8OWg2JOZm6LHuI6SfLR5zbdHYHoqU+zptxTKJ9qYnZVYuVPklf6HHLt4OAHDp2rp4Xsv/59ihBTKvJ5d7tZyorkg/dx2+Hw2GyEQMS1dHFDzMKjHPq+erAbi54z83/YqAgswcQKNBYU4eTGQSiCUmMLEwQ/fIj3BqxnfaO/EJsGr5AqzmRkOVl4ObCwfAwrsj1IUFEEuLbzY3MbeB2NRc4CiJyBgwmTZw3SM/QsNWHijKzYe9f3OcmbUBjXv4QmZriYQdxxDzxXb0+TkCKmUhlJkK7Ve4z88fDefOLWEilaCBjzuOjFsKxw4t0CTQD2civtfpo9vq9yG1ModYaoJL3+xC/v8n212XT8CxiStg2cQBnZe8iwY+buj27YeI3xKN+O2H8NysEWjY2hPqIhXOLfgR6sIiiCQmCFw/Bb8HTdHpw3/aUNi3bQaIRci5fQ8Xlv4CAOjw2UjEfvkzRGIReqz9COoiFRQp97WzkgD/nzT8yiEeVH8oM3Nw/cco9NsxBxqNGienR+q87wHAo39n7A+bo90m9UgcPEO7ot9vc2BiKsWVdXuhKiiE7+TBsGrqiPafjgAAxG87iPjth4R4WrXuxsIByL0ZA7GZBRTXTsHavw9U2Q9h120okr6bjNwb5yCSSNH49XkQS2XIuhCN1C0RgNgEgAauo74U+ikQkREQaTSlLWtDQvmt2/vIvJZcI/tuPeEVJP11VmeKrerm2P4Z2LXy0M7cURtsvZsg9PDSWuuvIhR3HminEBp0dg2nEKqA+nrMavI9XxmG+D4qy+CDwM1soaMAPK2A7T3Kb1dfGMpr+TFjek0bg/r6GV0RvDJdj8St2FHjfdw7cxX3zlyt8X6IiIiIDAFvQCQiIiIi0hOTaSIiIiIiPXGYh4Gxci99kQEqG48ZGbOqvH7VRSpk3UwFUDyPtFhiIkgcta2xgUyyYShxGApDew0ZWjxUdzGZNjA9v58mdAhEVIuq8p7/7w1BfX6KqDc3BH31vNARUGn4+4vqKw7zICIiIiLSE5NpIiIiIiI9MZkmIiIiItITk2kiIiIiIj0xmSYiIiIi0hOTaSIiIiIiPTGZJiIiIiLSE5NpIiIiIiI9MZkmIiIiItITk2kiIiIiIj0xmSYiIiIi0hOTaSIiIiIiPTGZJiIig9KrVy+MHDlS6DBq1alTp9C5c2eYmZnBxcUF06dPh0qlEjosIqoAJtNEREQCSkpKQu/evfHMM8/g7NmzWL16NdasWYNPPvlE6NCIqAKYTBMRUbVbtWoVfHx8YGpqCkdHRwwYMAAA4O7ujrlz5+q0HT16NLp37w4AGDlyJKKiovD9999DJBJBJBLh0KFD5fbn7u6OmTNn4t1334WtrS0cHR2xcuVKFBQUYMKECWjQoAEaN26MlStX6myXmpqKIUOGwNbWFnK5HN27d8c///wDAFCr1WjatCnmz5+vs01BQQEaNGiAyMhIbdmKFSvQokULmJmZoXnz5pg3bx6KiooqdKxWr14Na2trrFu3Di1btkRoaCjmzJmDFStWQKFQVGgfRCQcidABUM374BSQkit0FEBjc+Cr54WOgohq2qxZs7BkyRIsXLgQQUFByMnJwd69eyu07bJly3Dz5k24uLhg2bJlAAA7O7sKbbtixQp8+umn+Oeff7B161ZMmDABe/bsQa9evXDmzBn89NNPmDhxIgIDA+Hj4wONRoPQ0FAUFBRg9+7dsLGxwdy5c9G7d29cv34d9vb2eP3117Fp0yaEh4dr+9m5cyfy8/MxaNAgAEBERATWr1+PpUuXwtfXF1euXMHYsWORn5+POXPmlBv38ePHERQUBLH4f9e3+vbti/HjxyMmJgZdu3at0PMnImEwma4HUnKBm9lCR0FE9YFCocCiRYswZ84cjB8/Xlvu7+9foe1tbGwgk8kgl8vh7Oxcqb67d++ODz/8EAAQHh6ORYsWwcTERFs2depULFq0CNHR0fDx8UF0dDROnz6NS5cuwcfHBwCwceNGuLu74+uvv8ann36KESNGYMGCBThz5gzat2+vbRMaGgobGxvk5uZi0aJF+PXXX9G3b18AgIeHB+bOnYuJEydWKJlOTU1Fly5ddMoeP/fU1NRKHQMiqn1MpomIqNpcunQJ+fn5CAoKqvW+27Ztq/1ZLBbDwcEBbdq00SlzdHTEvXv3tLE2bNhQm0gDgKmpKZ5//nlcunQJANCiRQt06NABmzZtQvv27XHv3j38+eef2LVrl3YfeXl5GDBgAEQikXY/KpUK+fn5SE9Ph4ODQ40+byISFpNpIiKqNWKxGBqNRqessLCwWvYtlUp1HotEolLL1Gp1pfY7YsQIzJ49G0uWLMGPP/4Ie3t77R8Lj/f1008/wdvbu8S2FRmi4uLigrS0NJ2yu3fvauuIyLDxBkQiIqo2Pj4+MDMzw/79+0utd3R0xJ07d3TKYmJidB7LZLJamRauZcuWePDgAS5fvqwtKygowKlTp9CqVStt2WuvvYZHjx5h37592LhxI4YNGwYTExPtPszMzHDz5k14eXmV+Pe43dN06dIFf/31l06Sv2/fPpibm8PPz68anzER1QQm00REVG0sLS0xefJkREREYNWqVbh27RrOnz+PBQsWACieQ3rbtm3Yv38/rl69ig8++ACJiYk6+/Dw8MDZs2dx48YN3L9/v9quXD8pMDAQHTp0wNChQ3H8+HFcvHgRI0aMQH5+Pt59911tOzs7OwQHB+PTTz9FTEwM3njjDZ3nGx4ejvDwcKxatQpXr17FpUuXsHXrVkydOrVCcbz77rt49OgR3n77bVy6dAm7du3CzJkzMWHCBFhYWFT78yai6sVkmoiIqtWcOXMwb948LF++HK1atUJQUBDOnTsHoPgmwODgYISFhSEgIAA2NjbaWTEemzx5Muzt7dG2bVs4ODjg+PHjNRKnSCTCb7/9hhYtWiA4OBjt27dHWloa/vrrL9jb2+u0feONNxAbGwtfX1+0bt1ap27mzJn48ssvsXbtWrRt2xZdu3bFV199BXd39wrF4erqiv379+PKlSto164dxowZgzFjxmDevHnV9VSJqAaJNE8OXqM6Z/BBw5jNw9MK2N5D6Chqh+LOA/zU7h0AwKCza2DRqKHAERk+HrPK4zEjotrCz5uy8co0EREREZGemEwTEZFBmz9/PiwtLcv8Z8iOHj361NiPHj0qdIhEVEX1Ymq8BQsW4Ny5czh79iwSEhLg5uaGW7duCR0WERFVwNixYzF48OAKtz9z5ky5bZRKJTZs2ICRI0dCJpM9te3jxVr08dxzzyE2NrbM+saNG+u9byIyDPUimQ4PD4ednR38/f2RmZkpdDhEVIrC7Dztz3npjzgej7Ts7OwqvKR4RSmVSkRGRmLo0KHlJtNVIZfL4eXlVWP7JyLh1Ytk+saNG/D09AQAtGrVCjk5OQJHZPiy4w7h2oyn3y3YbifvXaWqy0lKx/mlP+PmL0e0ZX+8OBWuQe3RZtKrsPdlIkJERIbLqMdMnz9/HiEhIbCxsYG1tTVCQ0ORmpoKKysrDBkyRNvucSJNFWfRojPabEgt8c97TjREMjM4vjRR6BCpDsi8lozd/abi+o9RUBX8by5hjVqD2/tOY0/IDCRHnRMwQiIioqcz2mQ6KioKHTt2xNWrVzFjxgzMnz8fycnJ6NevH3JycuDr6yt0iEZNLJVB2sBZ55/IRIpbq0bDqlV3NBn1pdAhkpFTF6kQNWIB8h9kld2mUIWDoxcjN+1hLUZG9YFEIkH//v0hkdSLL2iJqAYZ5adIeno6wsLC4O/vjwMHDkAulwMAhg8fDg8PDwBgMl3NNEWFuPH5AIilZvD8eBtEFVgil+hpkg+cRXbi3ac30migylfi2uYD8J1c8RvQiMpjZmaGGTNmCB0GEdUBRplMf/7558jIyMD69eu1iTQA2NjYwN/fH1FRUYIk00VFRUhLS6v1fstTWOgEQFqlfdz+Zhzyb19Ci8WnYWJurWcchUhOLid5qiPy72Zqf05NTYWZOq/sxvXUxc37K9ZQBFzdFg37sM41G5AR4uusdAqFotw2BQUFWL58OSZOnAhTU9Ontk1OTq6u0IiMVn34vHF2dtbr2yqjTKa3bt2KgIAAeHt7l1rv5OQEZ2fnSu+3oKAA48ePR1RUFNLT0+Hi4oIJEyZgwoQJFdo+LS0Nrq6ule63pvmsuAh505Z6b39351d4cHAjmn92AKZOHnrv59q1a3Dt00rv7Y1JA7EcXzq+CADo0KEDMurgh05VTWkQgGdkDhCLRE9vqAEeJqYa5HtLaHydlW706NHltlEqldizZw/s7e3Lnc0jMjKyukIjMlr14fMmKSkJTZo0qfR2RpdMp6WlISUlBWFhYSXq1Go14uLi4Ofnp9e+i4qK4OzsjP3798PT0xMXLlxAnz594OTkVKk5TuuSR2f3InnDx3AbHwmrlgFCh0N1SL6mCOWk0QAAjUaDPE1h+Q2JiIgEYHTJ9OOv70SlXM3auXMn7t27p/cQDwsLC8yZM0f72NfXF/3798exY8cqlEw7OzsjKSlJr75r0oTLTkjKr/x2ebcv4ebiIXAKnQz7niOrHIe3tzf+NMDjUxPy72bi2EsRAIDTp0/DzMlW0HgMUcrOk7gyd2u57UQiEdq81gdJH39bC1EZF77OShcfH19uG4VCgY0bN2Lw4MGwsLB4attZs2ZVV2hERqs+fN7oM6oBMMJk2tXVFSYmJjh8+LBOeWJionY4RnWNly4sLMTRo0fx0UcfVai9RCLR6+uBmia9DqCSyXRR1n3Ez30Z5h6+cHxpEgozSo4Fl1g7VOpGRKlUapDHpyYoxP8by+/i4sIFSErh/ObLuLF8F5TZeYCmjDnLRcX/eW7cq7CtJ6+dyuDrrHSpqanltpFKpRg9ejRsbW3LHeZRXz63iJ6GnzdlM7pkWiaTYcSIEVi/fj1CQkIQHByMpKQkrF27Fk5OTkhJSSmRTG/atAmJiYkAimcCUSqVmDt3LgDAzc0Nw4cPL7Wv8ePHw8rKCiNGjKjR52SIHv3zB5R3E6C8m4C4UaUvd9vq2wSYOrnXbmBUZ0jMTdFtzYeIGrEA6iIV8GQ+LRIBGg3az34Dts9wvDRVL5lMhjFjxggdBhHVAUaXTAPA8uXLIZVKsXPnTkRHR6NTp07YsWMHPvvsM8THx5e4MXHdunUlrmTPnDkTANCtW7dSk+kPP/wQJ06cQHR0dI0uNWuoGga+gYaBbwgdBtVxjbv7os/2WTjz2Ubcj9H9at6yqSP8Pg5DswEvCBQd1WV5eXmYMmUKFi1apDMrFBFRZRllMm1paYk1a9ZgzZo1OuUXL15E69atIRbrrkVz6NChSu3//fffR1RUFKKjo2Fvb1/VcInoKZw6+uClPQtxPzYe98/fgEalho1XY7h0bQWR2GjXlSIDp1KpcOrUKahUKqFDISIjZ5TJdGkyMzORnJyM4ODgKu1n4sSJiI6OxsGDB+Hg4FBN0RFReex9vWDv6yV0GERERJVSZy77xMXFAajazYeJiYlYsWIF4uPj4eHhAUtLS1haWqJfv37VFCURERER1SV15sp0dSTTbm5u0JQ1qwAREdUZpqamCA8PL3f1QyKi8tSZK9Pjxo2DRqNBx44dhQ6FiIgMnFQqRWhoKKRSqdChEJGRqzPJNBERUUXl5uYiLCwMubm5QodCREaOyTQREdU7arUaCQkJUKvVQodCREaOyTQRERERkZ6YTBMRERER6YnJNBER1TtmZmZYtmwZzMzMhA6FiIxcnZkaj4iIqKIkEgk6deokdBhEVAcwma4HGpsLHUExQ4mDiCgnJwcvv/wyfv/9d1haWgodDhEZMSbT9cBXzwsdARGR4VEoFEKHQER1AMdMExERERHpick0EREREZGemEwTEVG9I5fLsWXLFsjlcqFDISIjx2SaiIjqHbFYDCcnJ4jF/DVIRFXDTxEiIqp3FAoFAgMDeRMiEVUZk2kiIiIiIj0xmSYiIiIi0hPnmSYiojqlffv25bYpKCjArFmz0LlzZ5iamtZCVERUVzGZJiKiesfU1BQRERFCh0FEdQCHeRARERER6YnJNBERERGRnphMExERERHpick0ERER1Zju3btj9OjRQodBVGOYTBMRkVHr1asXRo4cKXQYOo4cOYKQkBC4ublBJBJh7ty5QodULfQ51r/++iu+/PLLmgmoFhw9ehQDBgxAkyZNIJfL0bx5c0RERKCgoEDo0MhAcDYPIiKiapaTkwMfHx8MHToU77//vtDhCMrOzk7oEKrk+PHjaNasGSZNmgRXV1fExMRg7NixuHv3LlavXi10eGQAmEwTEZHgVq1ahVWrVuHGjRuwsbFBQEAAfvnlF7i7u2P06NGYMWOGtu3o0aMRHx+PQ4cOYeTIkYiKigIAfP/99wCAgwcPonv37k/tr6ioCPPmzcPGjRuRnJwMe3t7vPrqq1ixYgUAQCQSYenSpThy5Aj27dsHW1tbTJkyBZMmTarQ83nxxRfx4osvAgCmTp1a2cNRo2r7WHfv3h1eXl6IjIwEABw7dgxTp07FhQsXAACenp5YtGgR+vTpg+HDh0OtVmPz5s0AgPXr12PUqFFYu3atdqjIsGHDoFarsWXLFmRkZGDChAk4cuQI0tPT0bRpU4wZMwYffvghRCIRAGDkyJFITk5GcHAwFi9ejIyMDAQHB2PNmjUVSvSnTZum89jDwwO3bt3CvHnzaiyZjnpjIbJvpdXIvvWlLlJpf/5zUATEEhMBoynJyt0ZPb+fVn7DGsBkmoiIBDVr1iwsWbIECxcuRFBQEHJycrB3794Kbbts2TLcvHkTLi4uWLZsGYCKXQl96623sHfvXixZsgSdO3dGeno6Tpw4odNm9uzZmD17NhYsWIC9e/di8uTJcHd3R0hISOWfpIEQ4lj/V1FREfr374+RI0diw4YNAICLFy/C3NwcANCjRw+dZD46OhoODg6Ijo7WJtMHDx7E7NmzARQvvtOqVSt8+OGHaNCgAY4fP46xY8fCzs4Ob775pnY/p0+fhrm5Ofbt24cHDx7g7bffxltvvYUdO3ZUKv7HMjMzYWFhode2FZF9Kw2Z15JrbP9VlXUzVegQDAqTaSIiEoxCocCiRYswZ84cjB8/Xlvu7+9foe1tbGwgk8kgl8vh7OxcoW3i4+OxceNG/PTTTxg4cCAAoFmzZujYsaNOu+DgYEyYMAEA4O3tjVOnTmHx4sVGm0wLcayflJ2djYyMDPTv3x/NmzcHAO3/ASAwMBCpqam4fPkyfHx8cPDgQUydOhWLFy8GAFy5cgWpqakIDAwEADg7O+tcOfbw8MCZM2fw448/6iTTarUamzZtgo2NDYDiq/N9+vRBfHw8vLy8KvUcrly5gqVLl2L+/Pl6HQOqe3gDIhERCebSpUvIz89HUFBQrfV57tw5ACi3z06dOuk87tKlCy5dulRjcdU0IY71kxo0aIDRo0ejT58+6NevHxYuXIirV69q693d3eHu7o7o6GhcvXoVmZmZGDduHHJzc3H58mVER0ejadOmaNasGYDiJHnhwoXw9fWFvb09LC0t8c033yAxMVGnXx8fH20iDRSfSwC4fPlypeK/fv06goKCMGTIEJ0/SKh+YzJNREQGSywWQ6PR6JQVFhYKFE3dVlvHeu3atTh79ix69+6Nw4cPo1WrVlizZo22PjAwEFFRUYiOjkbXrl0hl8vxwgsvIDo6GtHR0dqr0gCwZMkSLFiwABMnTsRff/2F2NhYjB49GkqlstrjvnjxIl544QXteGuix5hMExGRYHx8fGBmZob9+/eXWu/o6Ig7d+7olMXExOg8lslkUKlUqKjHwxrK6vOxkydP6jz++++/4ePjU+F+DI0Qx7osj8c57927F2+99Ra+/fZbbV2PHj1w+PBhHDhwAD179gTwvwT70KFDOsn0kSNH0LdvX4waNQp+fn7w8vLC9evXS/R35coVZGVlaR///fffAFDh83nmzBl069YNgwcPxurVq7U3NxIBTKaJiEhAlpaWmDx5MiIiIrBq1Spcu3YN58+fx4IFCwAUz2u8bds27N+/H1evXsUHH3xQ4it8Dw8PnD17Fjdu3MD9+/fLvZrq5eWFYcOGYdy4cfjhhx9w48YNnDlzRntT3WO7d+/GypUrcf36daxYsQLbtm3D5MmTK/S8cnJyEBsbi9jYWCiVSqSlpSE2Nhbx8fGVODrVS4hj/aT4+HhMnToVx44dQ2JiIk6cOIGjR4/qJLWBgYHIyMjArl27tIlzYGAgdu/ejYcPH+ok08888wwOHTqEgwcP4tq1a5gxYwZOnTpVol+RSIQRI0bg4sWLOHLkCN577z3079+/QuOljxw5gp49eyIkJATTp0/H3bt3kZaWhrQ0w5ptg4TDZJqIiAQ1Z84czJs3D8uXL0erVq0QFBSkHdc8depUBAcHIywsDAEBAbCxscGgQYN0tp88eTLs7e3Rtm1bODg44Pjx4+X2uX79erzzzjuYMWMGnn32WbzyyitISEjQafPpp5/iwIEDaNu2LebPn49FixbhlVdeqdBz+ueff+Dn5wc/Pz+kpqZi1apV8PPzE3wlQCGO9X9ZWFjg+vXrGDJkCLy9vTFgwAB07twZK1eu1LZp1KgRvL29YWVlBT8/PwBAmzZtYGtrC29vbzRu3FjbdubMmejWrRtCQkLQqVMnZGRkYOLEiSX67dChA7p27YrevXujb9++aN26Nb777rsKxfzdd98hOzsb69evh4uLi86/uqjvL7PRefHYEuWWTRwwMvVnOHZoIUBUhk2keXKAFBFVmeLOA/zU7h0AwKCza2DRqKHAEVFdxNdZzRGJRNi0aRNef/11oUOhKno8z/SBAweEDqXCfuv2vmBT4/X9ZTayElLx90ff6JRbNnHAwDOrsSdkBu6d/leQ2J7G1rsJQg8vFaRvXpkmIiIiItJTvZhnesGCBTh37hzOnj2LhIQEuLm54datW0KHRURENWDcuHHaBUFKc/jwYSiVSmzYsAEjR46ETCYrtd3Nmzdx5swZtG/fXqd88+bNeOedd8rc/+XLl9G0aVO9Yjc28+fPf+p8yzk5OTqPz5w5U+4+K3JuHnvy3OjD0tKyzLrw8HCEh4dXuQ+q2+pFMh0eHg47Ozv4+/sjMzNT6HCIiKgGvfrqq+jVq9dT2yiVSkRGRmLo0KGlJmynT58uc9v+/fvj+eefL7O+UaNGFQ/WyI0dOxaDBw+u1n2Wd24q62l/WAFAbGxsmXWVXeGxPum74zPILOUQSSW4d+oKTk6PhEatFjosQdSLZPrGjRvw9PQEUDwdz5N/KRNVp/ux8bi89g/t48uRf6Dl2Jdh7thAwKiorinMycONnw9rH58Mj8QzI4LQuHtbiMT1ewSfjY2NzgId1c3KygpWVlY1tn9jYmdnZ/QJZ2VXQKRiUcMXoDAnDwDQPfIjuL/cCQk7K3dDal1h1J+458+fR0hICGxsbGBtbY3Q0FCkpqbCysoKQ4YM0bZ7nEgT1SRldi7+GjYPu/tNw81fj2rLL63ehZ/830Hcyh0lFkQg0sftfaex3W8Mzi34UVuW9OcZHBg2DzsDJyP79l0BoyMiY6bMyoXM2qJEucymuExVUDwd4uNEWiQxgYlUUq9/vxltMh0VFYWOHTvi6tWrmDFjBubPn4/k5GT069cPOTk58PX1FTpEqkdUykJEjViAlOiYUus1ajXOztuMS9/squXIqK5Jjo7BwbcWo1CRX2p95tUk7Ht1FnLvZdRyZMZFIpGgf//+kEjqxRe0RoXnRliP4lPQsI1niW+47P28oC5SITshVVvW5+cIvHbxOxTm5CFx98knd1VvGGUynZ6ejrCwMPj7+yMmJgYff/wxxo8fj6ioKNy+fRsAmExTrbr1+wncPXml7Ab//wf7uc+3oiAju3aCojpHo9Hg9Kfri68APeUqkCLlPi6t5h9uT2NmZoYZM2bAzMxM6FDoCTw3wvr3+30wc7BBl6XvoWEbT1i5OcEjtAv8pgxB/LaDUGblatv+OTAC23zfholcBueurQSMWlhG+Wff559/joyMDKxfvx5yuVxbbmNjA39/f0RFRQmSTBcVFXFFpHrqwrcVS1zUBYX459vf4DasRw1HRHXRwzPXkHXjTvkNAVzdfACOwwJgYlb1G7iMjUKhKLdNQUEBli9fjokTJ8LU1PSpbZOThZnvty7iuamYwsIiwfpWJN/Hnpc/gf/U19Dz+2mQWpsjJ/EuLn69C5cj/yjRXpWvxO29p9G0T3ukHrkgQMTFCguLqvx6cHZ21usbEaNMprdu3YqAgAB4e3uXWu/k5ARnZ2e99j1u3Dj8/vvvePToEaysrDBo0CAsWrSoQncUp6WlwdXVVa9+ybhFOr0CE1HFvuj5YcFKfDNtRA1HRHXRixbeGGTVukJti7Lz0PlZX9wpqn/fhFRklUGlUok9e/bA3t6+3M/3yMjI6gqt3uO5qZi5DXujsdRasP4zLici6o2FZdZLrcwhlklQ8CALIhMxXHs/h7S/L9VihCVdu3YNg6uYgyUlJaFJkyaV3s7ohnmkpaUhJSUF7dq1K1GnVqsRFxdXpavS48ePx7///ousrCycP38e58+ff+ocmkQAIIKowm3Fooq3JfovcSVeZwBgYnwf8URkBGQ25ui9+RP0j1qC/lFLkJv2AFc37Rc6LMEY3ZXpx18RiUpJSHbu3Il79+5VKZn28fHR/qzRaCAWi3H9+vUKbevs7IykpCS9+ybj9feg+chNvKcdG/00g8eNwvR3f675oKjOuRt9HnFT11eorUhqgiNxZyCxlJffuI6Jj48vt41CocDGjRsxePBgWFiUnLngv2bNmlVdodV7PDcVc2LwQigSDHfYqCL5Pnb3nSp0GDq8vb2RtP27Ku1D31ENRpdMu7q6wsTEBIcPH9YpT0xMxIQJEwBU/ebDhQsXYu7cuVAoFGjYsCEWLiz7q47/kkgken09QMav1ahgnP60AkmOSIR2Y1+BZROHmg+K6hyXIU64vvhX5N9/VO4fbp6vBMC9RfPaCczApKamlttGKpVi9OjRsLW1LXcoAT/Xqw/PTcVIpUaXnglOKhUuBzO6syWTyTBixAisX78eISEhCA4ORlJSEtauXQsnJyekpKSUSKY3bdqExMREAMUzgSiVSsydOxcA4ObmhuHDh+u0nzZtGqZNm4YrV65g8+bNcHFxqZXnRsbLK6w7Lkf+gZzb957azntYL1i6MpEm/ZjIpPCdPBgnp60tu5FIBIlchtbjQmovMCMkk8kwZswYocOgUvDckLExygF1y5cvx5gxY3Dq1ClMnjwZp06dwo4dO9CoUSOYm5uXuDFx3bp1mDlzJmbOnIl79+4hMzNT+3jdunVl9vPss8+ibdu2JZJtoifJrC0QtO1TWDZ1Ki4oZWirR2gXPD9vVO0GRnVOizf6wO/jsJIV//+ak1qYoeem6bB9hjdDP01eXh4mTJiAvLw8oUOhJ/DckLExuivTAGBpaYk1a9ZgzZo1OuUXL15E69atIX5iovFDhw7p3VdhYSGuXbum9/ZUf1i7OyPk4BIk/HoUV384gOyEVIikEjh1aIEWb/aFS9fWpY71J6qsth8Ogmuf9vh3w59I+usfFCnyIXdqAK/B3dH8tUDIHWyFDtHgqVQqnDp1CiqVSuhQ6Ak8N2RsjDKZLk1mZiaSk5MRHBys9z4ePXqEHTt2IDQ0FDY2NoiLi8PcuXPRp0+faoyU6jKpuRm8X+8N79d7Cx0K1XF2Ld3R+Yt3ALwjdChEVMNsvZug0xfvQKPWQFOkwvHJq0sMKzSRy/D8nFGwbOoEsYkYB16fj6K8Arx+czPuxxTf+Hk58g/c3nu6zH46Lx6LJr3aIenPMzgx9dsS9W0/GAiXrsXTc1p5OOPiqp24unE/grbO1LZxeM4b29qMhvJR6XOKt5vxOpw7Fk/2cHvfacSt/K3E8whYNgGmdlZQPlLg+AeroMzKhffw3mg1tj80ajV2BEwq/6DVojqTTMfFxQGo2s2HIpEIP/zwAz788EMolUo4Ojri1VdfxezZs6spSiIiIqLKyX+QhQOvL0Bhdi4a9/BF2w8G4vgHX+u08f1wMG7uOIa04xd1yhUp97FvQMVmPYldvB03fzkKj9Aupdaf/+pnnP+qeDaql/cvQuIfJ6EuLNLu366lO9rNeL3MRBoArm0+gLNzfwBEIry4cy4SfjuOnOR0bf0zr/dG+rnruPTNLrgFP4+W40IQs3ALbu85hetbohF68MsKPZfaxGT6P6ytrXHgwIFqioiIiAyVqakpwsPDy11hj2ofz01J+Q+ytD+rC1XQqNQl2jh3aQkTUwl8PxyEO0cv4MLSXwAAcqcG6PvrbOTdzcSpGet09vWk3LSHsPYof9IFW+8mUD5SIDftoU6556sBuPnr0adum/14yj+NBmqVCuonhvNYe7rg1q4TAID0mHi0fKc/YoCnxi00o7wBsTTjxo2DRqNBx44dhQ6FiIgMnFQqRWhoKKRSqdCh0BN4bspmYiaD78eDcTlyT4k6Ox93pByMxb6BEWjY2hPOnVoCAH7p+B72vToLt/efQfuIN6olDs8BL+DmjmO6hSIRmvbtgMQ9pyq0D/f+naFIuY/cVN2EPOPKbTTu4QsAcO3VDqYNLKsj5BpVZ5JpIiKiisrNzUVYWBhyc3OFDoWewHNTOpGJGC98PQmXVu9C5r+3S9TnP8xCyqHzgEaDO4fPo4GPGwCg4GE2AODWrr9h18qjWmJxe/F5JO4+oVPm3MkHDy4moEiRX+72Th2fhfewXvj7o29K1F3fEg2JhRn6/BwBi8b2Ja5+G6I6M8yDiIiootRqNRISEqBWl/y6nITFc1O6LkvexZ1D53F735lS6++evIKGbTzx4PwNNGzjicQ9pyCRm0JVUAiNWg2njj7IvlU8xEJiYQaxiRjKrMr/weLYoQUyryeX2PbJIR4iEzHMGloj716mTju7lu5o98nrODB8AVT5yhL7VxcW4dQnxdMWew0JhOLOg0rHWNt4ZZqIiIjIgDXu4Qv3/p3hEdIFfX+ZjQ6fjdSWe7zSFQBwdv4PaDd9KPr9NgcalRop0TGwad4YL+1biL47PkObSQNwZvZGAIBHaFc0G9S9RD9tPxiI5yJGoEmvdgja9ikgEkHuYIt2M17XtilOmnWHeIhlErh0bY2U6BhtmWVTR3Rc8HaJPjp9PgYya3MErvsYfX+ZDbuW7gCArsuLV7G2bdEUfX+ZjaBtn6JBC1dc++EvAIBrn/YI2vYpzBs1RNC2T6vtKnt1EGk0mnIWpSUiIjIeZ86UfuXuv3JychAYGIjo6GhYWj59TGb79u2rK7R6j+emYn7r9j4yryXX2P47zHkT55f+goIavKnP89UAKLNykXzgbI318V+23k0QenhprfT1JA7zICKiesfMzAzLli2DmZmZ0KHQE3huat7pmetrvI/yZvWoS5hMExFRvSORSNCpUyehw6BS8NyQseGYaSIiqndycnLQo0cP5OTkCB0KPYHnhowNr0wTEVG9pFCUvUobCau+nxsrd2ehQzA6Qh4zJtNEREREBqTn99OEDoEqgcM8iIiIiIj0xGSaiIjqHblcji1btkAulwsdCj2B54aMDZNpIiKqd8RiMZycnCAW89egoeG5IWPDVyoREdU7CoUCgYGB9f5GN0PEc0PGhsk0EREREZGemEwTEREREemJyTQRERERkZ5EGo1GI3QQREREtUmj0SA7OxtWVlYQiURCh0P/wXNDxobJNBERERGRnjjMg4iIiIhIT0ymiYiIiIj0xGSaiIiIiEhPTKaJiIiIiPTEZJqIiIiISE9MpomIiIiI9MRkmoiIiIhIT0ymiYiIiIj0xGSaiIiIiEhPTKaJiIiIiPTEZJqIiIiISE9MpomIiIiI9MRkmoiIiIhIT/8HF25/4kKNwE8AAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "execution_count": 7, @@ -211,17 +211,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "576 total subexperiments to run on backend.\n" - ] - } - ], + "outputs": [], "source": [ "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", From 06cf8691e0618c7d68abacc2504cc28ef1832b79 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 24 Jan 2024 16:00:12 -0500 Subject: [PATCH 048/128] Update cco tests --- .../cutting/cut_finding/circuit_interface.py | 12 +-- .../cut_finding/optimization_settings.py | 2 +- .../cut_finding/search_space_generator.py | 74 ++++++++++++------- .../cut_finding/test_best_first_search.py | 3 +- test/cutting/cut_finding/test_cco_utils.py | 2 - .../cut_finding/test_circuit_interfaces.py | 1 - .../test_disjoint_subcircuits_state.py | 5 -- .../cut_finding/test_optimization_settings.py | 2 +- .../test_quantum_device_constraints.py | 2 +- 9 files changed, 58 insertions(+), 45 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index d09b5a706..4d9e8acc8 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -183,11 +183,11 @@ def __init__(self, input_circuit, init_qubit_names=[]): if not isinstance(gate, CircuitElement): assert gate == "barrier" self.circuit.append([gate, None]) - self.new_circuit.append(gate) + self.new_circuit.append(gate), else: - gate_spec = CircuitElement( + gate_spec = CircuitElement( name=gate.name, - params=gate.params, + params = gate.params, qubits=tuple(self.qubit_names.getID(x) for x in gate.qubits), gamma=gate.gamma, ) @@ -261,10 +261,10 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): """ gate_pos = self.new_gate_ID_map[gate_ID] + new_gate = self.new_circuit[gate_pos] new_gate_spec = self.new_circuit[gate_pos] - print (new_gate_spec, input_ID) - assert src_wire_ID == new_gate_spec[input_ID], ( + assert src_wire_ID == new_gate_spec[input_ID ], ( f"Input wire ID {src_wire_ID} does not match " + f"new_circuit wire ID {new_gate_spec[input_ID]}" ) @@ -443,7 +443,7 @@ def getID(self, item_name): """ - if not item_name in self.item_dict: + if item_name not in self.item_dict: while self.next_ID in self.ID_dict: self.next_ID += 1 diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 29dff1157..b7e62d8e3 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -75,7 +75,7 @@ class OptimizationSettings: """ max_gamma: int = 1024 - max_backjumps: int = 10_000 + max_backjumps: int = 10000 rand_seed: int | None = None LO: bool = True LOCC_ancillas: bool = False diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index a4cf39db8..1e6dd54b9 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -10,8 +10,15 @@ # that they have been altered from the originals. """Classes needed to generate and explore a search space.""" +from __future__ import annotations +from dataclasses import dataclass +from typing import Callable + +from .cutting_actions import DisjointSearchAction + +@dataclass class ActionNames: """Class that maps action names to individual action objects @@ -25,9 +32,12 @@ class ActionNames: group_dict (dict) maps group names to lists of action objects. """ - def __init__(self): - self.action_dict = dict() - self.group_dict = dict() + # def __init__(self): + # self.action_dict = dict() + # self.group_dict = dict() + + action_dict: dict[str, DisjointSearchAction] + group_dict: dict[str, DisjointSearchAction] def copy(self, list_of_groups=None): """Return a copy of self that contains only those actions @@ -102,7 +112,7 @@ def getActionSubset(action_list, action_groups): a for a in action_list if len(groups.intersection(set(a.getGroupNames()))) > 0 ] - +@dataclass class SearchFunctions: """Container class for holding functions needed to generate and explore @@ -170,25 +180,33 @@ class SearchFunctions: is None is likewise equivalent to an infinite min-cost bound. """ - def __init__( - self, - cost_func=None, - stratum_func=None, - greedy_bound_func=None, - next_state_func=None, - goal_state_func=None, - upperbound_cost_func=None, - mincost_bound_func=None, - ): - self.cost_func = cost_func - self.stratum_func = stratum_func - self.greedy_bound_func = greedy_bound_func - self.next_state_func = next_state_func - self.goal_state_func = goal_state_func - self.upperbound_cost_func = upperbound_cost_func - self.mincost_bound_func = mincost_bound_func - - + # def __init__( + # self, + # cost_func=None, + # stratum_func=None, + # greedy_bound_func=None, + # next_state_func=None, + # goal_state_func=None, + # upperbound_cost_func=None, + # mincost_bound_func=None, + # ): + # self.cost_func = cost_func + # self.stratum_func = stratum_func + # self.greedy_bound_func = greedy_bound_func + # self.next_state_func = next_state_func + # self.goal_state_func = goal_state_func + # self.upperbound_cost_func = upperbound_cost_func + # self.mincost_bound_func = mincost_bound_func + + cost_func: Callable = None, + stratum_func: Callable = None, + greedy_bound_func: Callable = None, + next_state_func: Callable = None, + oal_state_func: Callable = None, + upperbound_cost_func: Callable = None, + mincost_bound_func: Callable = None + +@dataclass class SearchSpaceGenerator: """Container class for holding both the functions and the @@ -205,6 +223,10 @@ class SearchSpaceGenerator: functions by a search engine. """ - def __init__(self, functions=None, actions=None): - self.functions = functions - self.actions = actions + + # def __init__(self, functions=None, actions=None): + # self.functions = functions + # self.actions = actions + + functions: SearchFunctions = None + actions: ActionNames = None diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index ea215cb18..6b9fd598c 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -1,5 +1,4 @@ -import numpy as np -from pytest import fixture, raises +from pytest import fixture from numpy import inf from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index cf702df0c..8a4e5fd36 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -66,8 +66,6 @@ def test_QCtoCCOCircuit(test_circuit, known_output): test_circuit_internal = QCtoCCOCircuit(test_circuit) assert test_circuit_internal == known_output - -# TODO: Expand test below to cover the wire cutting case. def test_CCOtoQCCircuit(InternalTestCircuit): qc_cut = CCOtoQCCircuit(InternalTestCircuit) assert qc_cut.data == [ diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 73afc1e65..29835520b 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -1,4 +1,3 @@ -import numpy as np from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 63b73e4ab..1fd733bab 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -1,4 +1,3 @@ -import io, sys from pytest import mark, raises, fixture from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( @@ -8,11 +7,7 @@ disjoint_subcircuit_actions, ) -from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - PrintActionListWithNames, -) -from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import calcRootBellPairsGamma @mark.parametrize("num_qubits, max_wire_cuts", [(2.1, 1.2), (None, -1), (-1, None)]) diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index caaeafaad..38eb01705 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -4,7 +4,7 @@ @pytest.mark.parametrize( "max_gamma, max_backjumps ", - [(2.1, 1), (2, 1.2), (0, 1), (-1, 0)], + [(0, 1), (-1, 0)], ) def test_OptimizationParameters(max_gamma, max_backjumps): """Test optimization parameters for being valid data types.""" diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index cd5dbe6c3..9c28bad99 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -3,7 +3,7 @@ @pytest.mark.parametrize( - "qubits_per_QPU, num_QPUs", [(2.1, 1.2), (1.2, 0), (-1, 1), (1, 0)] + "qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)] ) def test_DeviceConstraints(qubits_per_QPU, num_QPUs): """Test device constraints for being valid data types.""" From d377b5d6d6f5a152fd75f96d26c93fd220350ed1 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 15:48:38 -0600 Subject: [PATCH 049/128] Update indices to params in gate dict --- .../cutting/cut_finding/cutting_actions.py | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 2beda27a1..e849416ce 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -141,16 +141,16 @@ def __init__(self): "ecr": (1, 1, 3), "crx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "cp": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "cp": ( @@ -162,37 +162,37 @@ def __init__(self): ), "cry": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "crz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), 0, - 1 + 2 * np.abs(np.sin(t[0] / 2)), + 1 + 2 * np.abs(np.sin(t[1] / 2)), ) ), "rxx": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), "ryy": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), "rzz": ( lambda t: ( - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), 0, - 1 + 2 * np.abs(np.sin(t[0])), + 1 + 2 * np.abs(np.sin(t[1])), ) ), } From 949266e5d02c4479b3377e461d55e6b3b86b227c Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 15:51:25 -0600 Subject: [PATCH 050/128] re run tutorial for correct outputs --- .../tutorials/04_automatic_cut_finding.ipynb | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 36cda3661..b83d11745 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,9 +21,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 1, @@ -55,9 +55,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 2, @@ -92,9 +92,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAGRCAYAAAAHNgAMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpF0lEQVR4nO3deVhU5f/G8fcMMwjIoqKCAoobai4plmallpZmmtqmbVrZbmn1bbOyLFtts7TN7Je2qy1mWVm5lmVqrrgk4grIpgIiizDM/P6gUAIRFM6Zgft1XV4yz3POzD0zZ87MZ85znrG4XC4XIiIiIiIiYhir2QFERERERERqGxViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBrOZHUBEpCIW3/giWXuSzY7hNgIiQ+n34XizY1SZIWN/YWfCYbNj0Co8kG+nXWx2jAq5fxUk5pidAsL8YEoPs1NUjLs8ZuBZj5uIVA8VYiLiEbL2JJMRm2B2DKkmOxMOs3VnhtkxPEpiDuzKMjuFZ9FjJiLuREMTRUREREREDKZCTERERERExGAqxERERERERAymQkxERERERMRgKsRERERquO2PX8CeabeWaj+asoe1Qy0c2brChFQiIrWbCjERERERERGDqRATERERERExmAoxERERERERg6kQExEREQB2v34jG0c1ZsvYjmZHERGp8Ty6ENu4cSNDhw4lKCiIwMBAhg0bRlJSEgEBAVxzzTVmxxMREfEoDS8aTZuJC82O4ZFibos0O4KIeBib2QFO1eLFixk8eDDNmzdnwoQJ+Pr6MmvWLAYOHMiRI0fo0qWL2RGlhnA4YVkyLEyAQ0fBzwa9Q+HScPC3m51Owvp2pduj1xHUJpzc1HS2/t8PbJ2+wOxYYoKZz/QiPKQuF9+uQuK/vPyCKMzJLNVemJ0BgMXuA0BAxz4cTdljYDIRkdrLIwuxtLQ0RowYQXR0NIsWLcLX1xeAkSNH0qJFCwAVYlIldmXBvX9CUm7RZQvgAv5Mg2lb4dlu0CfUzIS1W/CZreg36xE2v/sty8e8TqOubeg5+XYKc/PZ/tHPZscTcRs+4e1I//0LXIWFWLy8ituzd6wGqxd1mrQ2MZ1ni3//frI2L6Xg0H623tcFn6ZtafnwHLNjiYgH8MhCbPLkyaSnpzNz5sziIgwgKCiI6OhoFi9erEJMTltSDtzxO6TnH2tzHdefVwgPr4Fp50D3RobHE6DD7YM5sGEn657/DIDMHYnUaxtBp3uGqRATOU6jgWNI+/5N9ky9mcaX3Yutbj2yd6xm/6dP0LDfzdj865kd0e04j+aS9OXzpP82m/yDCVi9fakT2orgC0bS+LJxxctF3DoFKBqaeMbrG0xKKyKeyCPPEZs9eza9evUiKiqqzP6QkBBCQ4sOUzgcDu69914aNGhAvXr1uOWWW8jLyzMyrniomTtKFmH/5QKcLnh9C7hcJ15Oqk/j7u1IXLq+RFvi0g34RzTGr0kDk1KJuJ86jZvTdvIfFGans/PZy9h6b2eSvnyekMsfotmdb5sdzy3te/cuDi39iPCbXqbDm1uJenYpjS69G8c/wzlFRE6Xxx0RS05OJjExkREjRpTqczqdxMTE0LVr1+K2559/nqVLlxITE4O3tzdDhgzh4YcfZurUqRW6PYfDQXJycpXlF8+QU2jh+/gmFA1GtJxwORcQexgWb0+lnX85VZuctoICR6k238b1yE3LKNGWm5r+T199cpIOGRHNFAUFDhISEsyOUWUcBQVmRwCKcnjK41pQEAJU/ERVvxZn0nrCd9WQo4CEhJQqv97qUJnHLGPVNzS9/lnqnTOsuM2vxZlVmMVzHjcRObnQ0FBstsqVVh5XiGVnZwNgsZT+cDx//nxSU1NLDEt8//33eemllwgLCwPgqaee4uqrr2bKlCl4HTdO/kSSk5OJiIiomvDiMfzanE37V1ZXePnrHnyGtO/frMZE8mzwxYTZA82O4TZiY2MZXpP2TW2eBp8ws1MQGxtLRMS1ZseokDOmbca3WYcqvc6dk6/myLYVOA4fYNPocEKveozGl44pd53Y2FgiBnjGdPeVeczs9ZtweN1CGvS+DltA1R9h96THTUROLj4+nvDw8Eqt43GFWEREBF5eXixfvrxE+969exk7dixwbKKOjIwM4uPjSxRm0dHRZGVlsWfPHlq1amVUbPEwFkvlRu1arCcv6qXq5aZm4NuoXok2n38u/3tkTEQqrtUjX5gdwW00v+d9dr96HRtHNcI3ogN1255DULdLCeoxtMwvg0VEKsvjCjFvb29GjRrFzJkzGTp0KIMGDSI+Pp4ZM2YQEhJCYmJiceGVlZUFQL169YrX//fvf/tOJjQ0lPj4+Kq8C+IBMgusjI5xUVjOsMTjvf/i43R9+8FqTlW7rRz+Itm7Sw4TTl39N00v6MLGKV8Wt4Vd2IUj8ak1elgiQFRUFPFzPzA7RpXpd+cKYvdlmx2DqKgoFi/xjH3+2K0hxLvBKc9RUVH85CHvk5V5zPzbn0fH6TvJjl1N9vaVZG35lZ2TryKo20BaPf5tqWLMJ+KMSmXxpMdNRE7u3/kpKsPjCjGAqVOnYrfbmT9/PkuWLKFnz57MmzePSZMmERcXVzyJR0BAAACZmZnFD05GRkaJvpOx2WyVPswoni8c6HcIfk4sfzkL0MQPBrVvhFVfkFYru7307mrLewsY9N1zdB1/Lbu+XE7Drm1oP3oga5760ISExrLba9a+yWZ3jx/ls9ntHvO42ncAblCI2WvwY2bxsuHf/lz8259LyLAHOLjsE/ZMGcmRLb8S0LFPiWXbPPlD5bJ40OMmItXDIwsxf39/pk+fzvTp00u0b968mU6dOmG1Fg0rq1evHhEREWzYsIG2bdsCsH79egICAoiMjDQ6tniYm1vD8iTId5actv5f//6m2Jh2qAgzycGNO1ly80tEP3odHe8cQm5aBusmf66p60WkWviEtwfAkZlqchIRqQk8shArS0ZGBgkJCQwaNKhE+6233soLL7xAr169sNvtPPXUU9x0000VmqhDarc2QfB6D3hgDeSUnrAPgAc7wiX6QtNUCYvXkbB4ndkxxA3c/MRvZkeQGmT7Y31o0Ota/FqfhS2oEUeT4kj8+DG86tYjoNOFZscTkRqgxhRiMTExAKV+yPmxxx7jwIEDdOjQAafTyVVXXcXkyZNNSCie6OxGML8fzN8H3+yFhJyi9gFhcHtbaO5vbj4REakeQdEDOfTrp+z//EkKcw5jC2pMQIfeRI6biS2wodnxRKQGqPGFmM1mY+rUqRX+3TCR/6pfB25qA2c3hBv/+cL9upYqwkTEfR34+X0OLPoArFaa3/kOvpGdivv2TB3N0eSdOPOyaXDBDYQMuQ+A7Li1JH78KC5HAf7tzyPshmc5mrKbPa/fCFYrVlsdWjw0B5t/PXPulMFCrxpP6FXjzY4hIjVYjSnExowZw5gx5f/WiYiISE3nyDpE2sJ3aPfSnxxN3sW+d+8i6tklxf3N7noXq90bV6GDLXe3p9GA28FqY/8nj9Nq/Nd4+R77lilt4bs07H8bwReOJPmryRxa+hGNLxtnxt0SEalxKvdjSSIiIuLWsnesxr/jBVhsdnzC2+I4fACX01ncb7V7A+DMz8M7pAUWuw/Z21di9anL7leuIfaJfhz5eyUAvs06UpidAUBhdga2oEaG3x8RkZpKhZiIiEgNUph1CJt//eLLVt8ACnMySyyz6+Vr2Hxna/zbnYvFaqXg0H5y92yixQOfEzluFnvfvh2AgI4XkLbwXbaM60Tm+p+o12OYkXdFRKRGUyEmIiJSg3j51y8+igXgzM3Cyy+oxDItH5pNp/d2k7n2R3L3bcXLvwH+7c/Dyy8A70YReNWpS2HOYRI+eoSwkS/QYWoMoZc/ROLHjxp8b0REai4VYiIiIjVI3ageZG35FVehg7ykOGyBDbFYj73dOwuOAmDx9sFaxw9rHV/qRvUgLzEWV6GDwuxMCnMO4+UXCC5X8QyBtqDGOLIOmnKfRERqohozWYeIiIiALaABDS++le2P9garlWZ3vEXmuoUUZh2iQZ/riJs0CJfTgavgKPXPu5o6IS0AaHTJnWx//AJcjgLCb34ZgCbDJ7DvnTvB6oWr0EHzMe+ZeddERGoUFWIiIiI1TKMBtxfNhvivFmcW/xn1zKIy1wnuO4rgvqNKtPk260DbF/RD2SIi1UFDE0VERERERAymQkxERERERMRgKsREREREREQMpnPERETEdK3CA82OALhPjooI8zM7QRF3yVER7pTVnbKIiDlUiImIiOm+nXax2RE8zpQeZifwPHrMRMSdaGiiiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMhZiIiIiIiIjBVIiJiIiIiIgYTIWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMhZiIiIiIiIjBVIiJiIiIiIgYTIWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFsZgeQU7P4xhfJ2pNsdgwCIkPp9+F4s2PUOvevgsQcs1MUCfODKT3MTiEicnLu8t4Jev8UERViHitrTzIZsQlmxxCTJObAriyzU4iIeBa9d4qIO9HQRBEREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZimr69lrHYbo/bNPuX1ZzW5qgrTiIiIiIjUTirEapnQczswr899ZOp3VERERERETKOhibVMUJswFWEiIiIiIibz6EJs48aNDB06lKCgIAIDAxk2bBhJSUkEBARwzTXXmB1PRETELblcEHcYVqXBpkNQ4DQ7kcjpSc6FNWmw9gBk5pudRqRiPHZo4uLFixk8eDDNmzdnwoQJ+Pr6MmvWLAYOHMiRI0fo0qWL2RHdTlDrpmTGJZodQ0yUFbOM2AkXlrtMt/kuY8KIiOFcLvghAT7ZCTsOH2tvUAeubA43tgEfL/PyubOLP3scu78fPw57ApfzWOXaoFMLBi14nl/vnsreBStNTFg7xRyCD3bAihT4993L2woDwuC2ttDUz9R4IuXyyEIsLS2NESNGEB0dzaJFi/D19QVg5MiRtGjRAkCFWBlCenYgbs5Ss2OIieq2O5fOs5JKtefFb2PHM5fSqP/tJqQSEaNM3Qof7wTLf9rTj8KM2KIjZG/1BF+P/HRQvVbc9xZDl7xKp3GXs+n1rwDw8vGm95vj2PX1byrCTLA8GR5ZA47/fH+Y74Tv4uG3FJh+LrQKNCefyMl45NDEyZMnk56ezsyZM4uLMICgoCCio6MBFWJl8apjx5nvKL7cf+5ELpk3CSwl35L7znyEwQsnY7Hpa9Gaxmr3xl4/tMQ/i5edPW/dSkDHCwgf/ZrZEUWkmvySWFSEwbEjB//69/KmdHh1s5GpPEduagZ/PPguZ95/FcFntgKg2+M3YPW2s2rCByanq32Sc+HRv6CwnEEcGfnwv9Xg0NBbcVMeWYjNnj2bXr16ERUVVWZ/SEgIoaGhAMydO5fzzz8ff39/IiMjDUxpPi9f7+K/7f6+5Gdml+hfce806reNoNM9w4rbokZeTNM+nfntnjdwOQqNiiomcTkK2Dn5Sqx2H1o+NAeLl4pvkZrqs10VW+77BMg4Wr1ZPNW+hWuIm7uM3m+OI6L/WbQddTG/3TMVR3ae2dFqnXl7i458nWwwfWJO0bBFEXfkcYMPkpOTSUxMZMSIEaX6nE4nMTExdO3atbitfv363HPPPaSkpDBlypRK357D4SA5Ofm0MleHggLHCfssXla6PXY9hfkFrJ9c9JthTfucyf5fN5VYLifpECvHz6DXtLEkLt2AI/coZz91I39N+pjMuP0VzpGQUDtmYUzJtgMhRX+nphCUXWBaloKCEMB+2tez790x5O3bQrtXVuPld2pjNwoKCkhIqP53ufK2+dqoNr325PSlHPUiJr1JhZYtcMLX29Lp3zD75At7mKrYj6x5chaX/fIyF37wEJumfEXa2thTzqLX8KlbsCcU8KL0QNv/cjFvRy6tCw8ZkEpqs9DQUGy2ypVWHleIZWcXvTFYLKVfePPnzyc1NbXEsMSLL74YgG+++eaUbi85OZmIiIhTWrc6PRt8MWH2sj84uwqdrH9lDgPmTGQ9RYWYX2gDclPSSy2759s/iOh/Fr3fGocjN5+UP7fx96yFFc4RGxvLcDd8fKqDX+uzaP/qGgAuGzyYnLi/TMtyxrTN+DbrcFrXkTJ/CgeXfkSbSYuoE9LilK8nNjaWiAEdTytLRZS3zddGtem1J6fv+P1XRTz+3Mvc8uUL1ZjIHFWxH3HkHmXzO9/S88Xb2Pj6l6d8PXoNn54un2dW6AtEl9PFj7/+ydQ+/QxIJbVZfHw84eHhlVrH44YmRkRE4OXlxfLly0u07927l7FjxwI6PwygMDefvIOZ1A1rCFBihqf/WvXY+9QNb0RQq6b8ft9bRkUUE2Wu/ZGEWQ/RbMx0Ajr0MjuOiFSzwtzDJ1/o+OVzKrd8beP658iaq1AnH5mlMOcwLlcFZvm1WHBqexY35XFHxLy9vRk1ahQzZ85k6NChDBo0iPj4eGbMmEFISAiJiYlVWoiFhoYSHx9fZddXVVYOf5Hs3eUPmYz/ZS3hF3Xj4KZdHNiw84TLtbyyNxaLBauvneDOLUlYvK7COaKiooifWztOUo7NtvPw9qK/v1uwgKi65g1NHLs1hPhTPCUhd98Wdr1yDSHDHqBhv5tOO0tUVBQ/GfAaqcg2X5vUpteenD6XC+7ZWkDiURsnG8plwcXCqY/TePp4Y8IZyJ32I3oNn54Z8UF8n3ayYYlFI6ieHNGbvmPc77Oc1Cz/zk9RGR5XiAFMnToVu93O/PnzWbJkCT179mTevHlMmjSJuLi4E07icSpsNlulDzMawW4/+VOXsGgt5702BovVwt8zyx5uGNQmjLOeGMmqJ2ZSLyqcc1+9i/l9/8fRQ1kVzuGOj091yEwH/inEQhqHEF7fvCz2HcApFGKOwweIe/Yy/Fp0ofHgeylIL/2BxBbYqFKTdtjtdkO2gYps87VJbXrtSdW4wQGTY06+XO9QC9GtKnY+madxp/2IXsOn56Yg+OGfX+Q50XExCxBoh+EdG+Dj1cCoaCIV5j57pErw9/dn+vTpTJ8+vUT75s2b6dSpE1arx424rBa5qRnY/X2x+dYps99i86LXm+PY/+smdny6CK86dpr27kzPl+5g2a2vGJxWjJD51/fkp+wmP2U3MaPDylym43u7qRMSaWwwEal2V0TC6gOwtPRPCRZr6gePdjYsksgpaxEAD3aCl2OKCq7/FmMWwG6FF8/Sj5SL+/LIQqwsGRkZJCQkMGjQoBLthYWFFBQUUFBQgMvlIi8vD4vFQp06ZRcnNc3+5RvJ2lv2jHZdHx5B3SbBLLruOQAKjxbw2z1TGfTDC7S6ug87v1he5nriuYL73khw3xvNjiEiJvCywAvdin64ee5uyDpudLUV6NcUHuwIwT6mRfQYcXOXETd3mdkxar0RLaCeN0z/G/b9Z5LPzvXh3g7QWQfCxI3VmEIsJqZovMV/zw/7+OOPufnmm4sv+/r60rx5c/bs2WNgOvPEfraYgqzcUu2Nu7ej411DWTL6JfIOHjuJ9dCWPWx4ZS49nhlN8h9byE48YGRcERGpRjYr3NUObm4Dc3bBtG1F7VN6wHkh5mYTORUDwqB/U1i0Hx5dW9T25jlwTmNzc4lURI0vxG666SZuuukm4wO5ibKmrAdIXf03H0WU/i02gJhp84iZNq86Y4mIiIl8vOCshscu1/M2L4vI6bJYSh75ahFgXhaRyqgxJ1ONGTMGl8vFOeecY3YUERERERGRctWYQkxERERERMRTqBATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmM3sAHJqAiJDzY4AuE+O2ibMz+wEx7hTFhGR8rjTe5Y7ZRERc6gQ81D9PhxvdgQx0ZQeZicQEfE8eu8UEXeioYkiIiIiIiIGUyEmInIS/ec8yfmv3212DBEREalBNDRRRMQAVrsNZ4HD7BgiIrXae++9x2effVZ8efv27YwePZrmzZuX2f7cc88Vt/3+++8sW7aMxx9/HAA/Pz+6d+8OwL333svll19evOzq1at5+OGHAcjKysLlcvHuu++Walu3bh2HDh1i3LhxfPLJJ9V3x8UtqRATkVqh3U2X0O7mAQQ0DyU/K4eUVdtYdusrXLX6bWI/W8ym178qXvbcV+4ksEUTFl45kfNfv5umvTsD0HrEhQAsvGIiySu3lHt7V61+m51f/Uqdev5EDjmPrD3JZO5IwDe0Ab9c80yJZQd8MZGsfalseuMrrlz5Jj8MfYK0v7YX94ec054BXz7FV+fcTXbCgap6SEREap3bb7+d22+/HYCdO3cybNgwHnzwQerXr19m+/EmT57MzJkziy83a9aMZcuWlXk73bt3L+57/fXXyc3NLbMNoEGDBgQFBbF582Y6duxYhfdW3J0KMRGp8bo8OJwOd17G2uc+Zf/yjdjq+hDet2uF1l31xEz8m4eQm5LO6ieK3oCPZhyp0Lrtb7mUrdMX8MNlj2GxeeEd4Mel3z6Lf0RjjsSnAkUzp4We24G1z3/GkX2p7P91E1HX9ytRiEVdfxH7l29SESYiUkUKCgq44YYbeOedd6hfv/5J2w8fPkxmZibBwcHFbfv376dPnz40adKEqVOn0rhx4zJv67PPPmPu3Lnltg0cOJAvv/xShVgto3PERKRGs/nWoeOYoWx45Qv+nrmQw7uSOBSzm01vfF2h9QuycnDmOyjMyyc3LYPctIwKDzE8sGEnG16dy+FdSWTGJpC2Npb0v+Npc13f4mXaXNeX9G37OLB+BwDbP/6FyCHnYvf3BcA70I/mg84h9pNfKnnPRUTkRMaPH8+gQYM4//zzK9S+fft2WrRoUaJt165dLF++nCFDhvDAAw+UeTuxsbF4e3sTGRlZblurVq2IiYk5vTslHkeFmIjUaPXaRmDzrcP+5RsNv+0DG3aUaov9+Bdaj7gQi9WKxctK6+EXEvvpouL++J/WUHA4h5ZX9AKg5ZW9yT+cQ/zPfxmWW0SkJvvhhx/YuHEjjz32WIXaT6Rhw4YADB8+nPXr15e5zKeffsp111130japnVSIiUit5nK6wGIp0Wa1V82obUfO0VJtO79cjnegH+EXRRNxcTe8A/3Y9dWvx/IUOtnx+RKibrgIgKjr+hE3ZymuQmeVZBIRqc2SkpJ46KGH+Pjjj7FarSdt/1dUVBS7du0qvpydnU1hYSEAv/76K61bty7z9ubOncvw4cNP2rZz504NS6yFdI6YiNRoGbEJOHKP0rTPmaRv21uqP+9AJn4h9Uu0NejYgvzjzgNzFjiweFXN91YFR3LZ/c3vRF1/EVgt7PluJfmHc0osE/vZIjqNu5y2o/pT/4zmLLnl5Sq5bRGR2u7ZZ5/l8OHDXHvttcVtffv2JSUlpcz2J598EoCgoCCCgoI4ePAgwcHB/P3339x22234+/tjt9uZPn168XqjRo3io48+YtWqVbRs2bL4yBlQZhvAjz/+yJ133lldd1vclAoxEanRHDl5bJn+HV0evJrCvHz2/7oRLx9vwvtFEzNtHvt/20S7Gwew78fVHElIo+2o/viHN+TQcYVY1r5UmpzXgYDmIeRn5ZB/OAeXo/CUM23/+BcGLXgegIVXPFmqPzvhAIlLN9B90s0k/RbDkX2pp3xbIiJyzFtvvcVbb711wr7yPPLII7z77rs8/vjjdOvWjXXr1pW53EcffQRAjx49+P7770v0ldV26NAhMjMz6dSpU0XvhtQQKsREpMZbP3k2eQcP0/6WgZz99I3kZ2aT8uc2AGLe/Ab/8Eb0efd+nI5Cts/6iT3frSSwRZPi9be8+y312zdjyOJXsNf1rdD09eU5uHEn6dv2YfW2kbpme5nLxH6yiIiLurH9k0Vl9ouIiLHOP//8UpN4VIUGDRroN8RqKRViIlIrbHv/B7a9/0Opdkd2Hr+NnVbuukf2pbLw8tJHrsrzZfcxJ+yz2LzwaRjI5rfnn3AZv9AG5KZlEP/TmkrdroiIiHgGFWIiIkaxWPBpEEDUqP7Y/XyIm7201CI2Px/qNm1Ap7uH8vfMhRWeKl9EREQ8iwoxEZFK6jTuCjqPu/yE/Z+2Hllmu39YQ65a8w45yYdY8b+3KTiSW2qZc56/hRaXn8/+Xzex+Z1vqyyziIiIuBcVYiIilbT9o5/Z8+0flV7vSEIas5pcVe4yK+57ixX3lX/CuIiIiHg+FWIiIpWUn3GkxPT2cvruXwWJOSdfrrqF+cGUHmankOriLtsZaFsTERViIiLiBhJzYFeW2SmkptN2JiLupGp+oVREREREREQqTIWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMsyaKiIiInMSeN27i4JIPiy5YvfAODiMweiBhNzyHLTDY3HAi4pFUiImIiIhUgP8ZvWj58FxchQ5ydq5l75u3kn8gnjZPfm92NBHxQCrERERERCrAYvPGXj8UAO+G4eTu3cz+z5/EeTQXax1fk9OJiKfROWIiIiIip8BaxxecTlyFDrOjiIgH8uhCbOPGjQwdOpSgoCACAwMZNmwYSUlJBAQEcM0115gdT0RERGqo3H1bSf3hLepG9cDLL8DsOCLigTx2aOLixYsZPHgwzZs3Z8KECfj6+jJr1iwGDhzIkSNH6NKli9kRpYZwOOHXZJi7+1jb4v0QGQB1PfAVdCQ+je0f/0zauh24Cp0EtWpK1A0X0bBLa7OjiVRKVswyYidcWO4y3ea7jAkjtULW5mWsH+GPy1mIq+AoAZ370XzMdLNj1XrbMuDTnccuz9oBI1tDUz/TIolUiAd+jIS0tDRGjBhBdHQ0ixYtwte3aFz2yJEjadGiBYAKMakSu7PgvlWQmFOy/aOd8OVeeC4aeoWak62yXC4X6174jJi3vgGnCywAFlL+3Ersp4uI6H8Wvd++F3tdnecgnqFuu3PpPCupVHte/DZ2PHMpjfrfbkIqqcnqRvUg8r4PsVht2Bs0xWr3NjtSrZbrgCfWwbLkku1f7IEv9xQVY/e0B6vFjHQiJ+eRQxMnT55Meno6M2fOLC7CAIKCgoiOjgZUiMnpS86BO/4oXYT9K9cBD66BNWnG5jpV6yfPJmbavKIiDMAFuI4dLYj/+S+Wjn4Zp6PQnIAilWS1F02ccPw/i5edPW/dSkDHCwgf/ZrZEaWGsXr74tOkNXVCIlWEmazQBQ+vKV2E/csFfBQHb28zNJZIpXhkITZ79mx69epFVFRUmf0hISGEhoZy9OhRbrvtNlq2bElAQABRUVFMmzbN4LTiqT7YAYeOnrjfRVFNM2VLiXrGLWXvP1hUhJ3E/l83Ef/LWgMSiVQ9l6OAnZOvxGr3oeVDc7B4eZkdSUSqye8psLICX4R+GFf0xaqIO/K4oYnJyckkJiYyYsSIUn1Op5OYmBi6du0KgMPhIDQ0lJ9//pmWLVuyadMmBgwYQEhICMOHD6/Q7TkcDpKTT/B1i9RYOYUWvo9vQtH4vROPaXABsYdh8fZU2vnnGxWv0nZO/xGX01mhZTdOn49Xp6bVnKjyCgo0K9nxCgocJCQkmB2jyhQUhAD207qOfe+OIW/fFtq9shovv8BTzFFAQkLKaeXwFCnZdiCk6O/UFIKyC8wNZICq2M6qSm3a1qrDJ3ENgTqU9x4NRe/TH24+zPVNDxsRS2qx0NBQbLbKlVYeV4hlZ2cDYLGUfuHNnz+f1NTU4mGJdevW5Zlnninu79KlC0OGDGHFihUVLsSSk5OJiIg4/eDiUfzanE37V1ZXePnrHnyGtO/frMZEp+e+eufSuU5oma+b/4pfGcNQN9zmnw2+mDD7qX24roliY2MZ7obP06k6Y9pmfJt1OOX1U+ZP4eDSj2gzaRF1Qlqc8vXExsYSMaDjKa/vSfxan0X7V9cAcNngweTE/WVyoup3OttZ5L2zqjRLbdrWqsOZH6dhC/Q56XIul5P3f/iD8U8PNCCV1Gbx8fGEh4dXah2PG5oYERGBl5cXy5cvL9G+d+9exo4dC5z4/LCCggJ+++03OnfuXN0xxcNZrJUb0lTZ5Y1mrUABVrzsSb5dFHE3mWt/JGHWQzQbM52ADr3MjiMiRqjo+67L/d+jpfayuFzufnZLaaNHj2bmzJkMGTKEQYMGER8fz4wZMwgJCWHTpk1s27aNdu3alVrvjjvuYN26dfz+++94e1fsJFsNTaydMgus3BzTBGcFi5KJrdPoGljOCWUm2/7aPOI/X37yBS0QeEYzus/6X/WHqqSVw18ke7dei/+q2yKUnnPHmx2jyozdGkJ8XuWHjOXu28Lfj5xLo0vuJPzGyaedI8KngGln1I7hYrHZdh7eXjQ08aW2KUTVrflDE091O6sOtWlbqw7jtzfi72xvTjY0EWBQoyxui8is/lBSq9WKoYkAU6dOxW63M3/+fJYsWULPnj2ZN28ekyZNIi4ursxJPP73v/+xcuVKlixZUuEiDMBms1X6MKN4vnCg30H4ZX/5y1mAUF+4tH0jvNz4QJL/nZdXrBBzQadbB7vlNm+3e+TuqtrY7TVr32TfAeRVbh3H4QPEPXsZfi260HjwvRSkly7UbYGNKjVph91ur1GPa3ky04HtRX+HNA4hvL6pcQxxKttZdalN21p1uMYFT62v2LKjOgQQHqgf3Rb345GfbPz9/Zk+fTrTp5f8EcXNmzfTqVMnrNaSIy7vu+8+Fi9ezJIlS2jYsKGRUcWD3dym6Iec851FJ/uWxQXc1Q63LsIA6kWF0/LK3uz66tdylwuKCqfF0PMMSiVyejL/+p78lN3kp+wmZnRYmct0fG83dUIijQ0mItXu4qbwcRzszCp/uQFh0EqnF4ub8shCrCwZGRkkJCQwaNCgEu3jxo1jyZIlLF26lEaNGpmUTjxRVBC81gMeXA25hUVHv44vyCzA/R3gUg+ZL+HcV+7EkZPHvh/LnoSkXtsILv5sAjbfOgYnEzk1wX1vJLjvjWbHEBET1PGCN3vC2JUQd4JirE8oPNHF0FgilVJjCrGYmBig5EQde/fuZdq0adSpU4cWLY7NotWrVy9+/PFHoyOKB+rRCL7pB9/Gww/xcPAo1LUV7dyvioRIDxrpYPPx5sL3HyRpxWY2v/Mt+5dtACC4S2vOuOVSmg8+B5uPfqBUREQ8QyMf+Kg3LEmCr/bA7iNFI1Q61oerI6F7I7C6+YgVqd1qdCHWvHlzPHAuEnEzwT5FwxRvbmN2ktNnsVpp2rszQa3D+KLbHQD0/b+HqNs02ORkIiLuwXk0h9gn+pGXsI1md75Lg97XlOjf/doNHE3ehctZSONLxxDc90ZcLhf73rqdvMTtWL19aX7P+3g38pDhEh7O2wsuCS/6J+JpakwhNmbMGMaMGWN2DBEREfFgFlsdWj06j7SF75bZ3+Saifg0bYOz4Chbx3Wifq9rObz2Byz2OrR94Vey49aS+NF4WjzwqcHJRcTTeNzviImIiIhUF4uXF/b6oSfs92laNDzCYvMGixWLxULe/lj8Wp8FgF+raLK2/mZIVhHxbCrERERERCop5euXqN/zSiw2O77NO3F4/U+4XC4Or/8JR2aq2fFExAPUmKGJIiIiIkY49Otscnauo8WDnwMQ1G0g2dv/JHbChfhFnolvZGeTE4qIJ1AhJiIiIlJBmet+4sCi/6P1EwuwHPe7pU2vexqAwxsXY7HrZ0BE5ORUiImIiIgcZ+eLV5Kzaz1Wn7pkx64iMHoAhVmHaNDnOva8cSP2Bk3Z8dQAAFo+OBuLl42dk6/CYrXh3agZEbdPM/keiIgnUCEmIiIicpxW4786Yd+ZHyaX2d72uWXVlEZEaipN1iEiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMJ0jJiIipgvzMztBEXfJIdXDnZ5fd8oiIuZQISYiIqab0sPsBFIbaDsTEXeioYkiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBrOZHUCOWXzji2TtSTY7RrUJiAyl34fjzY4hIqeppu+rqpr2fcapKdtmbdhmPOm5qg3Ph5hDhZgbydqTTEZsgtkxRETKpX2VuCttm55Dz5WIhiaKiIiIiIgYToWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiMe45KunOfeVO0u1+4c34qakL2ncvZ0JqURERCpPsybWMue/fjetR1wIgLOwkNyUDJJ+38y65z8lJ/mQyelERETcj947RaQ66IhYLZT851bmdL6VL8+6i1/vfp3gjpFc8N4DZscSERFxW3rvFJGqpkKsFnLmO8hNyyAn+RApf25j+yeLaHx2W+z+vmZHExERcUt67xSRqqahibWcb0h9Igefg9NRiKvQaXYcEZEqccm8SXj7+2Kx20hdtY0/H30fl1P7OKkaeu8Ukarg0YXYxo0befLJJ1m2bBkul4u+ffvyzjvvEBUVxaBBg5g9e7bZEd1S6LkduD7uYyxWKzbfOgBsfudbHLlHTU4mIlI1Fo98gYIjuQBc8P6DRF7Wk93zfzc5lXgyvXeKSFXz2EJs8eLFDB48mObNmzNhwgR8fX2ZNWsWAwcO5MiRI3Tp0sXsiG4rbd0OVtz7Jl517EQOOZemvTqzfvLnZscSOSUh57Snwx1DaNAxEv/wRqyb/DmbXv/K7FhSTfIP5+AdWLdUu3dQUVvh0QKA4iLMYvPCy27D5XIZF1JqJL13GiOsb1e6PXodQW3CyU1NZ+v//cDW6QvMjiVSLTzyHLG0tDRGjBhBdHQ069ev56GHHuKee+5h8eLF7Nu3D0CFWDkK8/LJ2pNMxvZ4Nrw8h6z4VHo8d4vZsUROic3Ph4wd8fz1zMfkpKSbHUeqWWZcIsGdW2Kxlnz7ati1NU5HIVm7k4rbBnz5FNdu/oCCI7nsXfCn0VGlhtF7Z/ULPrMV/WY9QsLS9Xx78YNseGUu3cZfR9tR/c2OJlItPLIQmzx5Munp6cycORNf32MnyQYFBREdHQ2oEKuMDa/MofWICwk+s5XZUUQqLXHJetY9/xl7vv0DZ36B2XGkmv394UJ8GgVx3ut3E9y5JQHNQ2gx7Dy6PnwNcXOWkn84p3jZn656ijldbsPL15vQ8zuamFpqIr13Vr0Otw/mwIadrHv+MzJ3JBI3dxnbPviRTvcMMzuaSLXwyEJs9uzZ9OrVi6ioqDL7Q0JCCA0NBWDMmDFEREQQGBhIWFgY9913H/n5+UbGdXtZu5OJ/+Uvosdfa3YUEZFyZScc4IfLHqdOUF36fTieIUtepfO4K9j89resHD+j1PKFefns+3E1zQacbUJaqcn03ln1GndvR+LS9SXaEpduwD+iMX5NGpiUSqT6eNw5YsnJySQmJjJixIhSfU6nk5iYGLp27Vrcds899/Dyyy9Tt25dDhw4wNVXX83zzz/PU089VaHbczgcJCcnV1X8chUUOAy5nbJsfvtbBn33HKE9O5C8cku13EZBgYOEhIRquW6pnLyUjOK/k5KS8HHmmhemgsx8fbgjM19PZj8X6Vv3svjGF0/Ybw/ww+pt4+jBw1i8rERcfBbJf1TPfq0i3HXfl5JtB0KK/k5NISjb848oG71tVtd7p7tuM1WprOfKt3E9ctMySrTlpqb/01efnCRzfjy7NjwfcvpCQ0Ox2SpXWnlcIZadnQ2AxWIp1Td//nxSU1NLDEs844wziv92uVxYrVZ27NhR4dtLTk4mIiLi1ANXwrPBFxNmD6zW21hx31tltqf9tZ1ZTa6q1tuOjY1luEGPpZSvvtWX1xpfCkD37t1J94BCzIjXhycx8/Xk7s+Fd5AfF77/EFa7DYuXlaRfN7L9459Ny+Ou+z6/1mfR/tU1AFw2eDA5cX+ZnOj0Vde2afR7p7tuM1XJ3fcjx6sNz4ecvvj4eMLDwyu1jscVYhEREXh5ebF8+fIS7Xv37mXs2LFA6fPDXnzxRZ599lmys7MJDg7mxRdP/E2qiIh4tuyEAyy45BGzY4hIJeWmZuDbqF6JNp9/Lv97ZEykJvG4Qszb25tRo0Yxc+ZMhg4dyqBBg4iPj2fGjBmEhISQmJhYqhAbP34848ePZ9u2bXz66ac0adKkwrcXGhpKfHx8Fd+Lsq0c/iLZu40ZBmmGqKgo4ud+YHYMoWho4orBTwGwevVqfELqmZqnImr666OyzHw96bmoHHfd98Vm23l4e9Hf3y1YQFRdzx+aWFO2TXfdZqpSWc9V6uq/aXpBFzZO+bK4LezCLhyJTzVtWCLUjudDTt+/81NUhscVYgBTp07Fbrczf/58lixZQs+ePZk3bx6TJk0iLi7uhJN4tG/fnjPPPJORI0eydOnSCt2WzWar9GHGU2W3e+TTUWF2u3GPpZQv23psttEmTZpQt2mwiWkq5kSvD5ufD4EtinZ+VrsN30b1aNAhkoLsPLL2eP4HshMx8/VU0/dVVc1d932Z6cA/hVhI4xDC65sap0rUlG3TXbeZqlTWc7XlvQUM+u45uo6/ll1fLqdh1za0Hz2QNU99aELCY2rD8yHm8Mg9lr+/P9OnT2f69Okl2jdv3kynTp2wWk88GWRBQQGxsbHVHVFEDNLwzFZc8vXTxZfbjx5I+9EDSf5jCwuvnGhiMhERqYyDG3ey5OaXiH70OjreOYTctAzWTf6c7R+Zd46nSHXyyEKsLBkZGSQkJDBo0KDitszMTObNm8ewYcMICgoiJiaGZ599lgEDBpiYVESqUvLKLdU+0YyIiBgjYfE6EhavMzuGiCFqTCEWExMDlJyow2Kx8Mknn/C///2P/Px8GjduzBVXXMHTTz99gmtxH/Wiwun58h24nC5cjkJ+f+AdjuxLLbHMea+NISAyBJufD7u++pWtM76v0HrHCz6zFd0n3YzFamHbBz+ye96KEv0R/c+i24QbqNs0mE9bjyxuv+iTx7D51cHmW4ct737H7vm/4x/eiMt+fon0bfsAWPv8p6St1dFHkZrMP7wRvd++D6fDgcXLiz/HzyB9294Sy5S1r/Ly9WbA3InUaxPOykfeY/f838u9nXNfuZPwi7oR/9MaVj7yXqn+svZVVruN/rOfKF6m0VlRzOl8K/mZ2WXeRtfx1xLSoz1e3naSV25h7bOflOhv1C2KsyfeiLPAgcvl4rexU8lJOkS3CTcQek7RDL37Fq4m5s1vTvq4iXECWzZh2LIp/DjsCdLWlZw1OaxvV7o+NAJnQSEHY3ax6vH/A6DLg8Np0qszLkchqyZ8UGqbPl5Z2/fxvIPq0mf6//DyLvrItWLcmxxJSNN2IyI1uxALDAxk0aJFJiU6PXkHD7PohhcoyMoh7MIunHn/Vfx+/9sllln5yHs4CxxYvKxc/usbbP/klwqtd7wez4xm+V1TyDuQyaAFzxP/0184cvKK+1PX/M13Fz/EkEWvlFhvyc0v4SxwYPf35bKfXir+EHVgQxy/XPdcFT4SIuLOspMO8sPQCeByEXpeRzqPu4Lld00psUxZ+yrnUQdLR79M21H9K3Q7G16Zy66vfqPFsPPK7C9rX+UscBQPT23QIZJuE244YREGsPHVL3D+89tGl3z9NEGtm5IZt7+4/+CmXfww5HEAWl/Tl/Y3D2Tt858S++mioqLNYuHS+c+y+5vfOZKQVqH7JdXvzPuvInnl1jL7ujwwnCW3vEzO/oNc9Onj1G/fHIvVQnCnlvw4dAJ+oQ04f+pYfh5+4i9wy9q+C3Pzi/tbDD2PlFXb2DTlSyKHnEv7Wy9lzVMfarsREU58MpWHGTNmDC6Xi3POOcfsKFUi7+BhCrJyAHAWFOIqdJZa5t8PDF51vMmKT6Uwr6BC6/3Lq44dq7eN7MQDFB4tIPWv7QSf2bLEMkfTj1B4tPRMWv/ets2vDhmxx2aVbNCxBQO/eYaeL9+BzbdOJe+1iHgaV6ETXC4AvAN8ObR1T6llytpXuZzOUj/cWp6c5PJnTDvRvupfLa/oxa6vfyv3Ov7NabF5UXAkj5zjfvj8+H4oeV+z/p35zeXCWViIs7Cw3NsR4zTs2obc1Axykg6W2Z/+9z68A+tisVqx+XhzNPMIgS2bcHDTLqBou/MPb4jV+8TfW5e1fR8vc0ci3v5FEyR5B9Ul7+BhQNuNiNSgQqym8vLxpstDw9n6/g9l9vd5536uXDmNtDXbiz8MVWQ9AO96/iW+HT6amU2dev4VznbJ108zdMmrxP+yFoCc1HS+6nkPPw57giPxaXQae3mFr0tEPFeDDpFc+t1z9HjuVpJ+iylzmRPtqwxhsdDsku7s/WHVSRftPukmrvzzTXJT0yk4UvqHzsMu7MLgH1+k7aj+HNiws0Rf5JBzyU48YOo021JS53uvIObNeSfs3z1vBf0/n8Dlv71B5s5EcvYfJH17PKHndcBi86Je2wj8wxtRJ6j898bytu9DW3bT6Ky2DF3yKh3HDGXH50tK9Gu7Eam9VIi5MYuXld5v38uWd74l4+99ZS6z/K4pfNnjbsL6diUoKrzC6wHkZ2bjHVS3+LJ3YF2OZhypcL6FV0zk6/PG0emeYdgD/HDmO3BkFw1r3P3NChp0alHh6xIRz3Voyx5+uOxxFt/0Ij2ev6XMZcraVxkltOcZHNy8u3j/VJ7VT87iqx53U6d+AGEXdinVn7h0AwsGjmftC58R/eh1xe0h57Qn6vqL+OPBd6syupyG8H7RHNy4k6PpJ35fO+eFW1kwcDxfnzcWXNDskrPJjE1g9/w/GDD3STreNYT0v/cVH8U6kfK27453D2PPt38wv+8D/HbPVM59+Y7iPm03IrWbCjE3dt6rd7F/2Ub2LVxTZv+/QyUK8/Jx5B4tHpNe1nq2uj54B/qVWL8wLx9nvgO/0AZYvW00PiuqeDhGeSxWKxavok3HkXuUwqMFFB7Nx+5/7LepQs/tSNbupMrdYRHxOMcP2So4nFPi3Jj/LvPffVVZytpXna7/Dku0eFnxbVzvhDldhU4KsvMozMsvsx+Kvsj6t79Bh0i6PX4Dy+54rdQ6Yp4GHSMJPbcDF3/2OE16d+bsp28q9by7nM7ikSF5Bw9Tp34AANs//ImFV0wk5q1vyNgej8vpxMvHmzrBgaVu56TbtwXyDhUVcnkHMotvQ9uNiNSYyTpqmrALuxA55Fz8IxrTYuh5HNqym9VPziLswi541/Nn97wVXPTxY1htXli9bexZsJIj8aknXK/FsPOx+Xiz7f9KDlVc/eRM+kz/HxarhS3Tv8ORnYdvo3qcccdg1j77CQ27tiF6/LX4NQ2m/5wn2TL9Ow6s38GF//cQuIpmJYuZNg9nvoOmvc+ky0PDceQcpSArlxX3v2XSoyciRml8dju6PDgcV6ETi8XC6qdmAZx0XwVwwfsPEtyxBY6cPBpGt2HNxBPvq868/yoiLjkb34b16D/nSX6+5hl8GwaVu69KXLIeq7eNJud34s9H3y++Lv9mjTlrwkiW3vJyids477Ux1G0SjMXmRdpf20n+YwsA508dy4px04gc3JOoGy7C5XThdBSy8p+jGD0n3449wJe+//cQULRfPbRlT3U83FIJm974mk1vfA3A+a/fzfaPfiY3NaPEtrn+5bkM+PIpCvMLyM/IZtO0ouX7z52IxQJ5h7JY9VjRttO4ezvC+3Yt9ePCJ9q+/91utv3fj/SaOpao6y/C5uPNmmc+BrTdiAhYXC6jB+vLiXzT5z4yYhOq5bq7P3MzG1//iqMnGV5RnepFhTNs+eum3b4ck73/IF90Kxoec/Xa6dRtGmxyopOrzteHJzLz9eTp+6qWV/Qi/3AOCYvWVtttHM9d931b0uHGfw4UftgLOtQ3N09VqM5ts9PYy4n/ZW25Q/6rirtuM1XJk/bpteH5EHPoiFgtsfqJmWZHEBE5KSP2VSebPVGkLDHTTjzph4jIqdA5YiIiIiIiIgZTISYiIiIiImIwDU10IwGRoWZHqFY1/f5J9dL2U5KZj4e7PRdORyGHdxXN0hrYsglWm5fJiUpyt8erJqspj3VNuR8iUj4VYm6k34fjzY4g4rb0+nAf7vZcHD/5zIAvnvKIyWekerjbtikiUh4NTRQRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmM3sAHJqFt/4Ill7ks2OQUBkKP0+HG92jApxPPsSrqQUs2NgaRKCbcLDZseole5fBYk5ZqeAMD+Y0sPsFCK1j7vsA0D7ATGGu3xedBfu9rlVhZiHytqTTEZsgtkxPIorKQXizX/MXGYHqMUSc2BXltkpRMQs2gdIbaPPi+5NQxNFREREREQMpkJMRERERETEYCrEREREREREDKZCTERERERExGCarENERETkP/a8cRMHl3xYdMFqxV6/CQGd+hI26gW8g8PMDSciNYKOiImIiIiUwf+MXnSelUSn9/fR4oHPyNm9nl2TrzY7lojUEDoiJiIiIlIGi80be/1QALyDw2jU/3biZ4yjMOcwXn6BJqeT81+/m9YjLgTAWVhIbkoGSb9vZt3zn5KTfMjkdCInp0KslrHabYzaN/uU15/V5KoqTCMiIuIZ8g/uJ/2PL8HqVfRP3ELyn1tZfvtrWLysBESGcM7zt3LBew/ww5DHzY4mclIqxGqZ0HM7MK/PfWTqx/1ERETKlbV5GetH+ONyOnHl5wIQMuwBvHzqApC+ch5Jc54usU5e/FYibn2DRgPvMjxvbeTMd5CblgFATvIhtn+yiHOeuwW7vy8FR3LNDSdyEh59jtjGjRsZOnQoQUFBBAYGMmzYMJKSkggICOCaa64xO55bCmoTpiJMpIrF3BZpdgQRqQZ1o3rQ/vUNtH9lNU2GP0Hdtj1pev2zxf31e17OGa9vKP7X9JqnqBPamuC+N5qYuvbyDalP5OBzcDoKcRU6zY4jclIeW4gtXryYc845h+3btzNhwgSef/55EhISGDhwIEeOHKFLly5mR5Qa4pb1q7lk5bIy+7y/m8unCXuNDSQiIoawevvi06Q1vs070vT6SdQJaUH8e2PLXDb/QAL7pt9Ni4dmY63jZ3DS2iv03A5cH/cxN+z6lBEbZhDaswNbZ3yPI/coAH6hDbjqr3fwCS46p8/L15srfp9GvXbNyu2rDULOaU/fmY9w1Zp3uCnpSzrfd6XZkWodjyzE0tLSGDFiBNHR0axfv56HHnqIe+65h8WLF7Nv3z4AFWJlCGrdlMy4RLNjiNQY8e/fz9b7ulBwaD9b7+vCrpdGmB1JRKpRk2uf4sDimWTv+KtEu8vpZPeUGwi9cjx+kZ1NSlc7pa3bwbcXPcSCgePZ8NoXpK7ZzvrJnxf35yQfYuv0BZz99E0AdHlgOHt/XEXG3/vK7asNbH4+ZOyI569nPiYnJd3sOLWSR54jNnnyZNLT05k5cya+vr7F7UFBQURHR7N48WIVYmUI6dmBuDlLzY4h4vbWDrWU2+/duDmdZuwh4tYpQNHQxDNe32BAMhExk0/TNtQ7+zL2f/I4bZ7+qbg9ae6zePkG0nhw2UfLpPoU5uWTtScZgA0vzyEgMpQez93CHw++W7zMtv/7kcELJ9P+1ktpfmkPvu33YIX6arrEJetJXLIegLMm3GBymtrJIwux2bNn06tXL6KiosrsDwkJITQ0tERbbm4unTp1Ijk5mSNHjhgR0+141bHjzHcUX+4/dyJWuxcLr5gILldxe9+Zj+DXpAHfD34Ml6PQjKgipuo8K6n47yN//8GuF6+k/ZR12Os3KWrUjGkitVbI5Q+xffx5ZMUsI6DTBRzZ9jsHF/0f7V9bZ3Y0ATa8MofLf32D7R//wsGNO4GiI5ZrJs7ikq+fZsnol4qHLZ6sT6S6eVwhlpycTGJiIiNGlB4C5HQ6iYmJoWvXrqX6nnzySZo3b05ycnKlbs/hcFR6HSMUFDhOuoyXrzeFufkA2P19yc/MLtG/4t5pDF38Kp3uGUbMtHkARI28mKZ9OvNd/4cqVIQVFDhISPCMyT+CHQWnvMEvP5hG/R++rpIcDkcBKSY/ZnkpGcV/JyUl4eOsHTNLFRSEAPaTLvfv7wYB2PwbFP0f2KhE++nlKCAhIaVKrktq7/Z8ulKy7UBI0d+pKQRlF5gbyAAV3QcARN47q8x2//bn0m1+0ZeXjiMZ7J4ykshxs7AFBlcyS+3eD1Tkc8ypyNqdTPwvfxE9/lp+ufbYxCph/bqSk3yI+u2ase/H1SXWKa/v36ye8lnnv6rrcfZU1flchoaGYrNV7pOmxxVi2dlFxYTFUnro0Pz580lNTS01LHHt2rUsXLiQV199lSuuuKJSt5ecnExERMQp560uzwZfTJi97B+TtHhZ6fbY9RTmF7B+ctFvhjXtcyb7f91UYrmcpEOsHD+DXtPGkrh0A47co5z91I38NeljMuP2VyhHbGwsw93w8SnLhgsGcEZA0Cmt271eA/6va/dS7Wcs+bHS1xUbG0sXkx+z+lZfXmt8KQDdu3cnvZZ8cD1j2mZ8m3UwOwaxsbFEDOhodowao7Zuz6fLr/VZtH91DQCXDR5MTtxfJ1nD81X1PiBt4TsUpCcR/8H9JdqDL7yRkKH3n2CtIrV9P1De55jTtfntbxn03XOE9uxA8sot1GvXjGaXdGfBwPFc+t1z7PzqV47sSwUot+9fnvRZ57+q83H2RNX5XMbHxxMeHl6pdTyuEIuIiMDLy4vly5eXaN+7dy9jxxaNzT6+EHM4HNx222289dZbOJ21YypTV6GT9a/MYcCciaynqBDzC21AbhknYu759g8i+p9F77fG4cjNJ+XPbfw9a6HRkd2er5cXresGmB1DRETcSJOrHqXJVY+aHaPWWnHfW2W2p/21nVlNriq+3HPy7ayZOIuc5EOsf2k2PZ67hcUjXzhpn0h187hCzNvbm1GjRjFz5kyGDh3KoEGDiI+PZ8aMGYSEhJCYmFiiEHv55Zfp2rUrvXv3ZtmyZZW+vdDQUOLj46vuDlSRlcNfJHv3iYdMFubmk3cwk7phDclOPICrnCJ01WPvc/X698DpqvTOJyoqivi5H1RqHbMEP/MSJJk/DCQqKor4j983NUNeSgYrBj8FwOrVq/EJqWdqHqOM3RpCfF7VX69PxBmVWj4qKoqf3HC/4qlq6/Z8umKz7Ty8vejv7xYsIKpuzR+aWF37gFNR2/cDJ/scU1XaXH8ReQcySVhcdA7fzi+W0+bavjS7tAd16gecsG/fD6uKr8OTPuv8l1GPs6eozufyv/NTVITHFWIAU6dOxW63M3/+fJYsWULPnj2ZN28ekyZNIi4urngSj7i4ON59913Wr19/yrdls9kqfZjRCHb7yZ+6+F/WEn5RNw5u2sWBDTtPuFzLK3tjsViw+toJ7tyyeIdU0Rzu+PiUpcBWsfMCqpvNZjf9Mcu2HptttEmTJtRtWrlzGzyVfQdQDR/C2jz5Q+Vy2M3fBmqS2ro9n67MdOCfQiykcQjh9U2NY4jq2gecitq+H6jI55iqsOPTRez4dFGJtoVXTCzRf6K+f3nSZ53/Ku9xtvn5ENiiqHiw2m34NqpHgw6RFGTnFc9EWdO423PpkYWYv78/06dPZ/r06SXaN2/eTKdOnbBai34ebcWKFaSkpBQXZgUFBWRnZ9OwYUO+/vprevfubXh2IyUsWst5r43BYrXw98yyhxsGtQnjrCdGsuqJmdSLCufcV+9ift//cfRQlsFpRURERMQoDc9sxSVfP118uf3ogbQfPZDkP7aw8MrSBalUPY8sxMqSkZFBQkICgwYNKm4bPnw4F110UfHllStXctNNN7FhwwYaNWpkRkxD5aZmYPf3xeZbp8x+i82LXm+OY/+vm9jx6SK86thp2rszPV+6g2W3vmJwWvdV1iQd/8q/bLiBSURERESqRvLKLSXOpRPjWc0OUFViYmKAkhN1+Pn5ER4eXvyvUaNGWCwWwsPDqVOn7OKkptm/fCNZe8s+L6rrwyOo2ySYPx54B4DCowX8ds9UIi7uRqur+xgZU0RERESkVqkxR8TKKsT+64ILLqh1P+Yc+9liCrJKT+XcuHs7Ot41lCWjXyLv4OHi9kNb9rDhlbn0eGY0yX9sITvxgJFxRdxOQKcLin8zSERqvqMpe9j96nVYbHZchQ6a3fUOfpGdi/udR3PY99448lN343IW0vqJ7/Hyqcu+6feQs3MtLmchTa+bRFD0JSbeCxHxBDWmEBszZgxjxowxO4bbKWvKeoDU1X/zUUTpH8UGiJk2r/gHnkVERGoT74bhtH1xBRarlcOblpD8xfO0fGh2cf/+2U/ToM91BHbuW9yWG7+NvIRttHtpJQXpycQ9M0iFmIicVI0ZmigiIiJyuixeNiz/TPrlzDmMb4szS/RnxSwlc/W3bH/8ApLmPguAvX4TLHYfXIUOCrMzsAU0NDy3iHgeFWIiIiIix8nZtYG/H+7JvvfuIbBzvxJ9ubs3Ehh9CVHPLCFn5zqyYpbhVTeIOiEt2HxXFNsfv4DQK8ebE1xEPEqNGZooIiIiUhX8Wnah3Usrydm5jr3v3En7V1YX99kCGxLYpT8Wq5XALv3J3bMJlyOfgvRkOr4bR2F2BrGPX0D7KeuweOljloicmI6IiYiIiPzDWXC0+G8vvyCsdfxK9Pt36E3OznUAZMf9RZ0mrXG5XNgCGmCxWvHyDcBZcBRXocPQ3CLiefRVjYiIiMg/jmz7naTPnwKrF+AiYvRrZK5bSGHWIRr0uY6wUS+y981bcRXk4RPRgcBuA8HpJP23z9n+aC+c+Xk0HjwOq7eP2XdFRNycCjERERGRfwR27ltiRsT/qtO4OVGTfinZ6OVF5L2zqjeYiNQ4GpooIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjCdI+ahAiJDT3ldp6OQw7uSAAhs2QSrzcuUHEazNAnBZXYIinKIOcL8Tr6MEdwlh0ht406vPXfKIiLmUCHmofp9eOo/Fpm9/yBfdLsDgAFfPEXdpsFVFcut2SY8bHYEMdmUHmYnEBEzaR8gIu5EQxNFREREREQMpiNiIiIiIuKxbtj1KQfWxwGw9f3v2ffj6uK+Lg8Mp/U1F5K5I4FfrnsOAC9fbwbMnUi9NuGsfOQ9ds//3ZTcIirERERERMRjZSceYOGVE8vs2/7xz8R9sYyeL95W3OY86mDp6JdpO6q/URFFyqShiSIiIiLisXxD6nPJ10/T55378QkOLNGXm5oBzpJTdbmcTnLTMowLKHICKsRERERExGN9dc7dLLxiIvt+XsPZT91odhyRClMhJiIiIiIe6+ihLAD2fPsHDTq2MDmNSMWpEBMRERERj2TzrYPFWvRxNuScM8jak2xyIpGK02QdIiIiIuKRgtqEce4rd1KQnYezoJCVD08n7MIueNfzZ/e8FUTdcBGtru5DUOsw+s95kt/GTSM3JZ0L3n+Q4I4tcOTk0TC6DWsmzjL7rkgtpEJMRERERDzSwU27+K7/wyXajj8qFvvJImI/WVRqvWW3vlLt2URORkMTRUREREREDKZCTERERERExGAqxERERERERAymQkxERERERMRgKsREREREREQMpkJMRERERETEYJq+XmqNxTe+6BY/9BgQGUq/D8ebHUNEpNYZMvYXdiYcNjsGAK3CA/l22sVmxxARE6kQk1oja08yGbEJZscQERGT7Ew4zNadGWbHEBEBNDRRRERERETEcCrEREREREREDKZCTERERERExGAqxERERERERAymQkxERERERMRgKsREREREREQMpunrRU7Carcxat/sU15/VpOrqjCNiIiIiNQEKsRETiL03A7M63MfmfoNMhERERGpIhqaKHISQW3CVISJiIiISJXy6EJs48aNDB06lKCgIAIDAxk2bBhJSUkEBARwzTXXmB3PbTkLCov/ztqTbGISEZHT53Qc26cd3p2My+UyMY2IiEjFeOzQxMWLFzN48GCaN2/OhAkT8PX1ZdasWQwcOJAjR47QpUsXsyO6HUfuUTa/PZ+/Z/1U3LbwyokEd2lFxzuH0GLoeSamc09BrZuSGZdodgwRKUPh0QI2v/Mtf3/wY3HbT1dNpEGnFnS44zJaXtELi8ViYkKpKRbNGIjdZuWC0d9zfJ3/zRsXEdbYj54jv8Ph0BcAVSHknPZ0uGMIDTpG4h/eiHWTP2fT61+ZHUtOUf85T5KTdJAV971ldhS35JGFWFpaGiNGjCA6OppFixbh6+sLwMiRI2nRogWACrH/KMjJ45drniF1zXb4z+eSgxt3svzOKWRsj6frwzqSeLyQnh2Im7PU7Bgi8h+O3KMsuuF5kv/YUmqfdmjzbn67Zyrp2/Zy1oSR5gSUGuXGCcvZ9OUVPDK6My/+3yYAbr+qLRefE0b0iG9UhFUhm58PGTvi2TXvN7pPutnsOOIBrHYbzgKH2TFOiUcWYpMnTyY9PZ2ZM2cWF2EAQUFBREdHs3jxYhVi/7H6iZlFRRjAf98v/rm8ccqXNOjYguaX9jA0mzvzqmPHmX/sxd1/7kSsdi8WXjGR478W7TvzEfyaNOD7wY/hOm6YlIhUj78mfVRUhMEJ92mb35pPcKeWOtovpy0xJYe7nv2dj5/vw8LfE8nJc/DaQz146LXVbN+TaXa8GiVxyXoSl6wH4KwJN5icRgDa3XQJ7W4eQEDzUPKzckhZtY1lt77CVavfJvazxSWOWJ77yp0EtmjCwisncv7rd9O0d2cAWo+4EICFV0wkeeWWcm/P4mWl871X0urqPtRtEkzeocPs+2EVqyZ8AMBNSV+yasIHNIpuQ/hF0SQu3YBvo3pk7trPyoeml7iuK1a+SdzcZWya8mVVPiRVxiMLsdmzZ9OrVy+ioqLK7A8JCSE0NBSAm266ic8++wxvb+/i/i+//JJLLrnEkKzuIO9AJju/WFahZbfOWFCrCzEvX28Kc/MBsPv7kp+ZXaJ/xb3TGLr4VTrdM4yYafMAiBp5MU37dOa7/g+pCBMxwNGMI+z4fMnJF7TA1vcWqBCTKjH3p91c1qcZn77Qh5w8B7+uTebtOdvMjiVSrbo8OJwOd17G2uc+Zf/yjdjq+hDet2uF1l31xEz8m4eQm5LO6idmAkX775M577UxhPXtypqnPyRtzXZ8ggNpdFbbEsuc+b+r2fDKHNa/NBusFhqe2YpzX76TNRM/xJGTB0CT8zvhH96IHZ8truS9No7HFWLJyckkJiYyYsSIUn1Op5OYmBi6di25gdx+++28+eabp3R7DoeD5GTPntAi4avfS0zQUZ6UP7cRt3YzPiH1qjeUCQrKOWxt8bLS7bHrKcwvYP3kot8Ma9rnTPb/uqnEcjlJh1g5fga9po0lcekGHLlHOfupG/lr0sdkxu2vcI6EBHNnYcxLySj+OykpCR9nrnlhRCpp/7erKDxacPIFXZC2bgexf27AL7xh9QfzMCnZdiCk6O/UFIKyK/CYejhHwendx3teWEniomtwOl0MvueX085i9nuBmcp7T3Y37vC+fapO53G2+dah45ihrH9pDn/PXFjcfihmd8VuOysHZ76Dwrx8ctMyKrROQGQorYdfwNJbX2Hv938CkLU3hbR1O0ost2/h6hKZshMP0OPZ0bQYdl5x4dXmun4kLFpHbkr6sUzV+FyGhoZis1WutPK4Qiw7u+gIRVknYM+fP5/U1NQqHZaYnJxMRERElV2fGS6r244rAjpUePmLzunFXkdG9QUyybPBFxNmDyyzz1XoZP0rcxgwZyLrKSrE/EIblHjx/mvPt38Q0f8ser81DkduPil/buPvWQtLLXcisbGxDDd5m6pv9eW1xpcC0L17d9JViIkHGVg3iuEBnSq+fO9+7Co4VI2JPJNf67No/+oaAC4bPJicuL9MTmSANk+DT9gpr37DoFZYsODn40W3Mxryw2/xp3xdsbGxRERce8rre7ry3pPdjTu8b5+q03mc67WNwOZbh/3LN1ZxqhML7lQ018PJbvPAhrgSl535DuLmLCPq+ovY8dli6tT3p/nA7iy97dUSy1XncxkfH094eHil1vG46esjIiLw8vJi+fLlJdr37t3L2LFjgdITdXz66ac0aNCA9u3b89xzz+FweM63MFUhz1W5+5vrqvnfipalMDefvIOZ1A0r+ubc5XSecNlVj71P3fBGBLVqyu+aCUjEUHnOyu3T8mrpPk2qVrsWQbx0f3fufelPpn62lfefOp/genXMjiViGpfTBf85MGK1G3OM59/hh8fb/vEvNOzSivrtm9Pqqj7kHTxcfL6hu/K4I2Le3t6MGjWKmTNnMnToUAYNGkR8fDwzZswgJCSExMTEEoXYuHHjeOmll2jYsCHr1q3j2muvJS8vj2eeeaZCtxcaGkp8/Kl/4+UOchIO8Mflz558QQvUbRHKX6u31cgpn1cOf5Hs3eUPM43/ZS3hF3Xj4KZdHNiw84TLtbyyNxaLBauvneDOLUlYvK7COaKiooif+0GFl68OeSkZrBj8FACrV6+ukUNRpebKS05nxZBJJSbMKZMFfMMa8ueqzVisHve9Y7WLzbbz8D9zOH23YAFRdWt+wdrvzhXE7ss++YL/YbNZ+OSFC1i0KpH3v9pOHW8vLu4ZxvQnz+Oq/1XgfMUyREVFsXiJZ3++OB0VeU92F+7wvn2qTudxzohNwJF7lKZ9ziR9295S/XkHMvELqV+irUHHFuQfdx6Ys8CBxavi+9+D/wx7bNrnzOKhiRWVtSeZpBWbibq+H6HndWTH7CWlvlSvzufy3/kpKsPjCjGAqVOnYrfbmT9/PkuWLKFnz57MmzePSZMmERcXV2ISj+jo6OK/zzrrLJ5++mkmTpxY4ULMZrNV+jCj2wkPZ1+/6JMXCy7odNtgjx+KeSL2CnxLk7BoLee9NgaL1VJi7PHxgtqEcdYTI1n1xEzqRYVz7qt3Mb/v/zh6KKvCOczeprKtx2YbbdKkCXWbBpuYRqSSwsPZd8nZ7PtxdfnLuaDjbYOJaNbMmFweJjMd+KcQC2kcQnj9chevEWx2+ymtN2lMN8JD6jJwTNHvcB7NL+SGR5ex+rMhjLysNR9/F3eSayg7i9nvBWY60Xuyzc+HwBZFH2itdhu+jerRoEMkBdl5ZO0xp3Bzh/ftU1WRzz4n4sjJY8v07+jy4NUU5uWz/9eNePl4E94vmphp89j/2yba3TiAfT+u5khCGm1H9cc/vCGHjivEsval0uS8DgQ0DyE/K4f8wznlTmyWtSeZnV/9yjkv3oaXj520v2LxrudP47Pbsu39H06aefvHv9D7zXFYbFZiy5ikw92eS48sxPz9/Zk+fTrTp5econLz5s106tQJaznffFqtVlwn+xa1Bur50h18f9lj5Ow/eMJlmg3sTtTIiw1M5X5yUzOw+/ti8y17uInF5kWvN8ex/9dN7Ph0EV517DTt3ZmeL93BsltfMTitSO11zou3cWjzbo7Ep51wmfCLomk/eqCBqaQmOq9rCA/d1InL719E2qFjw6E2bj/ExLfXMfWRc1i2Jon45MofaZPSGp7Ziku+frr4cvvRA2k/eiDJf2xh4ZUTTUxWO62fPJu8g4dpf8tAzn76RvIzs0n5s2i20Jg3v8E/vBF93r0fp6OQ7bN+Ys93Kwls0aR4/S3vfkv99s0YsvgV7HV9KzR9/Yr73qLL/64m+pFr8Q2pT96Bw+z9fmWF8u5buJr8rBwObIgr9zOvu/DIQqwsGRkZJCQkMGjQoBLtc+bM4ZJLLiEwMJCYmBiefvpprr76apNSmqdu02AGLXieVY//H/t+WgPOY8WoPcCPdjcNoOvD12D18jIxpXvYv3wjWXtTyuzr+vAI6jYJZtF1zwFQeLSA3+6ZyqAfXqDV1X3Y+cXyMtcTkarl17g+ly54ntUTPmDv96tKDD+x+/vSdlR/uj5yDVab9mlyen5fn4I9emaZfS/+36biH3iWqpG8cguzmlxldgw5zrb3fyjzaJQjO4/fxk4rd90j+1JZePmTlbo9l6OQ9S/NLpqavgzlbR/eAb7Y6/oQ+8miSt2mWWpMIRYTEwOUnqjj7bff5s4776SgoIAmTZowcuRIHn30URMSmq9uk2D6fvAw2YkHSFy2AUfOUXxD6hNxUTdsfjrh+F+xny2mIKv0LIKNu7ej411DWTL6JfIOHi5uP7RlDxtemUuPZ0aT/McWshMPGBlXpNbya1yfC957gOykg0U/J5Gdh0+jICL6n4Xdz8fseCIiYhCLzQuf+gF0eXA4OcmHiP/ZM2aBrfGF2H9nVxSoG9aQqOsvMjuG2yprynqA1NV/81FE6d+vA4iZNq/4B55FxFh1mwQTdV0/s2OIiMhJdBp3BZ3HXX7C/k9bjzyl6w05ux2XfP00WXtT+G3s1JNP5uQmakwhNmbMGMaMGWN2DBERERERKcP2j35mz7d/VPn1euqQ1hpTiImIiIiIiPvKzzhSYnr72k4/rCIiIiIiImIwFWIiIiIiIiIGUyEmIiIiIiJiMBViIiIiIiIiBlMhJiIiIiIiYjAVYiIiIiIiIgZTISYiIiIiImIw/Y6Y1BoBkaFmRwDcJ4eISG3TKjzQ7AjF3CmLGTzpvdCTsopnUSEmtUa/D8ebHUFEREz07bSLzY4g/9B7soiGJoqIiIiIiBhOhZiIiIiIiIjBVIiJiIiIiIgYTIWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMhZiIiIiIiIjBVIiJiIiIiIgYTIWYiIiIiIiIwVSIiYiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMhZiIiIiIiIjBVIiJiIiIiIgYzGZ2ADk1i298kaw9yWbHICAylH4fjjc7Rq1zus+/01FY/PdPVz+F1eZ1ytelbUBEPMX9qyAxx+wURcL8YEoPs1OIiJlUiHmorD3JZMQmmB1DTFKVz//hXUlVcj0iIu4uMQd2ZZmdQkSkiIYmioiIiIiIGEyFmIiIiIiIiMFUiImIiIiIiBhMhZiIiIiIiIjBNFlHDXf+63fTesSFADgLC8lNySDp982se/5TcpIPmZxOjKBtQERERMT96IhYLZD851bmdL6VL8+6i1/vfp3gjpFc8N4DZscSA2kbEBEREXEvKsRqAWe+g9y0DHKSD5Hy5za2f7KIxme3xe7va3Y0MYi2ARERERH3okKslvENqU/k4HNwOgpxFTrNjiMm0DYgIiIiYj6dI1YLhJ7bgevjPsZitWLzrQPA5ne+xZF7FAC/0AZcuuA5Fgx4hLyDh/Hy9WbooldZcsvLZPy9z8zoUkVOtg00G9idLv+7usQ6QVHhrH5iJts/+tnwvCIiIiI1nUcXYhs3buTJJ59k2bJluFwu+vbtyzvvvENUVBSDBg1i9uzZZkd0C2nrdrDi3jfxqmMncsi5NO3VmfWTPy/uz0k+xNbpCzj76Zv47Z6pdHlgOHt/XKUirAY52Taw78fV7PtxdfHlZpecTfSj1xH3xTIT0oqIiIjUfB5biC1evJjBgwfTvHlzJkyYgK+vL7NmzWLgwIEcOXKELl26mB3RbRTm5ZO1JxmADS/PISAylB7P3cIfD75bvMy2//uRwQsn0/7WS2l+aQ++7fegWXGlGlRkG/iXX5MG9Hj+VhZd/zyFuflGRxWRalbogpWp8PmuY21Lk6BFAPh57KeC6rN2qKXcfu/Gzek0Y48xYUSqUFjfrnR79DqC2oSTm5rO1v/7ga3TF5gdq1bxyF1uWloaI0aMIDo6mkWLFuHrWzThwMiRI2nRogWACrFybHhlDpf/+gbbP/6Fgxt3AuByOlkzcRaXfP00S0a/VDxkTWqmsrYBACwWer95LzFvfkP6tr3mBRSRapGQDfevgt1HSrbPioMv9sAz0dA71JRobqvzrKTiv4/8/Qe7XryS9lPWYa/fpKjR6mVSMpFTF3xmK/rNeoTN737L8jGv06hrG3pOvp3C3HydkmAgj5ysY/LkyaSnpzNz5sziIgwgKCiI6OhoQIVYebJ2JxP/y19Ej7+2RHtYv67kJB+ifrtmJiUTo5xoGzjzvivJz8rh7w9+NCmZiFSXA3lw+++li7B/5TjgoTXwZ6qxudydvX5o8T+bfwMAbIGNjrUHNTI5oUjldbh9MAc27GTd85+RuSORuLnL2PbBj3S6Z5jZ0WoVjyzEZs+eTa9evYiKiiqzPyQkhNDQY1/pff/990RHR1O3bl1CQ0N5+eWXjYrqtja//S1hF3QhtGcHAOq1a0azS7qzYOB42lzXD/9mjU1OKNXtv9tA47Pb0ua6fvx+/1smJxOR6vBhHKTmnbjfBThd8NoWcLkMiyUiJmjcvR2JS9eXaEtcugH/iMb4NWlgUqrax+OGJiYnJ5OYmMiIESNK9TmdTmJiYujatWtx288//8ztt9/ORx99RJ8+fcjJyWHfvopPQuFwOEhOTq6S7FWpoMBRoeVW3Ff2h+q0v7Yzq8lVxZd7Tr6dNRNnkZN8iPUvzabHc7eweOQLFcqRkJBQsdBSZSr6/EPFtgHvQD96TRvHinvf5Gj6Cb4uLyeLtgER93bUaWH+niaA5Z9/ZXMBu7Lg579T6RBQ884RLSgIAexmxwCgoKCAhIQUs2NIDXeizwu+jeuRm5ZRoi03Nf2fvvrkJB2q7mimqM7PLKGhodhslSutPK4Qy87OBsBiKf1GMn/+fFJTU0sMS3ziiSd44okn6NevHwCBgYF07NixwreXnJxMRETE6YWuBs8GX0yYPbBKrqvN9ReRdyCThMXrANj5xXLaXNuXZpf2YN8Pq8pdNzY2luFu+PjUdFX5/AO0vXEAvo3r0f3pm0q0x32xnK3vlX/irrYBEffnG9mZM97YWOHlb3zsJVK+ebUaE5njjGmb8W3WwewYQNG+M2JAxT+PiJyKqv684Omq8zNLfHw84eHhlVrH4wqxiIgIvLy8WL58eYn2vXv3MnbsWODY+WHZ2dmsWbOGgQMH0q5dO9LT0+nRowdvvPFG8aQeAjs+XcSOTxeVaFt4xUST0ogZYqbNI2baPLNjiEh1qeyEEpqAQqRGy03NwLdRvRJtPv9c/vfImFQ/jyvEvL29GTVqFDNnzmTo0KEMGjSI+Ph4ZsyYQUhICImJicWFWHp6Oi6Xi6+++oqFCxfSuHFj7rvvPq644grWrVtX5lG1/woNDSU+Pr6a71XlrRz+Itm7zR8yGRUVRfzcD8yOUeu4y/MP2gZEPMERh4WbYlw4XCd/3wN46+mH6PHG2GpOZbyxW0OIL+c8OSNFRUXxkxt+vpCa5USfF1JX/03TC7qwccqXxW1hF3bhSHxqjR2WCNX7meX4+SkqyuMKMYCpU6dit9uZP38+S5YsoWfPnsybN49JkyYRFxdXPIlHQEAAAPfeey+RkZEAPP/88zRq1Ij4+HiaNTv57IA2m63ShxmNYLe7x1Nnt7vn41PTucvzD9oGRDzFxYfgx5OcGmEBguvA0DMaYvPI6bzKZ98BuEkhZrfbte+Uaneizwtb3lvAoO+eo+v4a9n15XIadm1D+9EDWfPUhwYnNJa7fWZxn09zleDv78/06dOZPn16ifbNmzfTqVMnrNaid4+goCCaN29eoSNfIiIiNdmNrWHJfsh3Fk3KURYXcEc7amQRJiLHHNy4kyU3v0T0o9fR8c4h5KZlsG7y5/oNMYN5ZCFWloyMDBISEhg0aFCJ9jvvvJM33niD/v3706hRI5544gm6detWoaNhIiIiNUXrQHi9B/xvNeQWFh39+m9Bdnd7uLy5Gek8Q0CnC+g2X3P7S82QsHhd8URtYo4aU4jFxMQApX/I+eGHHyY9PZ3o6GicTifnn38+X3/9tQkJRUREzHV2I/imH8zfBwvi4eBR8LNB7xC4KhLaBJmdUESk9qjxhZjVamXy5MlMnjzZhFTmqRcVTs+X78DldOFyFPL7A+9wZF9qcf/5r99N/TOaU5CVS+bORFY+/B7+4Y3o/fZ9OB0OLF5e/Dl+Bunb9pp4L+R0ePl6M2DuROq1CWflI++xe/7vJfoj+p9F53FXUFjgIPbjX9j19W807NKas54YCYDN3weLxcJ3/R82I76IVJNgHxgdVfRPRETMU2MKsTFjxjBmzBizY7iNvIOHWXTDCxRk5RB2YRfOvP8qfr//7RLL/Dl+BmnrdhRfzk46yA9DJ4DLReh5Hek87gqW3zXF6OhSRZxHHSwd/TJtR/Uv3Wmx0O3x61kw8FEKj+ZzyddPE//LWg5siGPhlUU/XXDGbYPw8vE2OLWIiIhI7aDTcWuovIOHKcjKAcBZUIir0Flqme7PjOaSr58m7MIuAEXLuIrGvnsH+HJo6x6j4ko1cDmd5KZllNnn0yCAvAOHceTk4Sp0khm3n0bRbUos0+Ly89k9b4UBSUVERERqnxpzREzK5uXjTZeHhrPykRkl2tdM+oijh7LwaRjEJV89RdraWPIP59CgQyTnvHgbdZs2ZOktL5uUWqpb3sHD+DQMxLdxPQqy8wjp0Z6kXzcV9we2bIKzwMGRhDQTU4qIiIjUXCrEajCLl5Xeb9/Llne+JePvfSX6jh7KAiDvQCYHNu4ioEUTDm7cyaEte/jhssdp0KkFPSffzveXPmpGdDHAykfeo/db9+LIzSdjezw5Kcd+wLHlFb3Y9bWOhomIiIhUFw1NrMHOe/Uu9i/byL6Fa0r12QP8gKIjZg06RJKdkIbV+1hdXnA4h8LcfMOyivFS/tzGT1c/zfI7p2Dzq0Pa2mPnC0YOOZc93/1hYjoRERGRmk1HxGqosAu7EDnkXPwjGtNi6Hkc2rKbxKUb8K7nz+55K+jzzn3YA/yw2r3Y8u635B08TOh5Heny4HBchU4sFgurn5pl9t2Q03TB+w8S3LEFjpw8Gka3Yf+yY9vAWRNHEdypJU5HIete+AxngQOAhl3bkLU3pfioqYiIiIhUPRViNVTi0g180vL6E/YvuuH5Um3Jv29m4e+bqzOWGGzZra+csO+vpz8qs/3A+h0sHvlCdUUSERERETQ0UURERERExHAqxERERERERAymQkxERERERMRgOkfMQwVEhpodAXCfHLWNOz3u7pRFRKQ8YX5mJzjGnbJIzaX36JLc7fGwuFwul9khREREREREahMNTRQRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg6kQExERERERMZgKMREREREREYOpEBMRERERETGYCjERERERERGDqRATERERERExmAoxERERERERg/0/GRQvNAUeqHYAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "execution_count": 3, @@ -126,7 +126,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 3329.001832079775\n" + "Sampling overhead: 24.653128718190246\n" ] } ], @@ -147,8 +147,7 @@ { "data": { "text/plain": [ - "{0: PauliList(['ZIII', 'IIZI', 'IIIZ']),\n", - " 1: PauliList(['IIII', 'IIII', 'IIII'])}" + "{0: PauliList(['ZIII', 'IIII', 'IIIZ']), 1: PauliList(['III', 'IIZ', 'III'])}" ] }, "execution_count": 5, @@ -167,7 +166,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -188,9 +187,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 7, @@ -218,7 +217,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "17280 total subexperiments to run on backend.\n" + "72 total subexperiments to run on backend.\n" ] } ], From 4b75973115cc29361895299f99feb553a3d0364f Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 15:55:00 -0600 Subject: [PATCH 051/128] clean up notebook --- .../tutorials/04_automatic_cut_finding.ipynb | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index b83d11745..cf1734592 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,7 +21,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -36,7 +36,7 @@ "from qiskit.circuit.random import random_circuit\n", "from qiskit.quantum_info import PauliList\n", "\n", - "circuit = random_circuit(7, 5, max_operands=2)\n", + "circuit = random_circuit(7, 6, max_operands=2)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\", fold=-1)" ] @@ -55,7 +55,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -92,7 +92,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -126,7 +126,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 24.653128718190246\n" + "Sampling overhead: 80.73369279941987\n" ] } ], @@ -147,7 +147,7 @@ { "data": { "text/plain": [ - "{0: PauliList(['ZIII', 'IIII', 'IIIZ']), 1: PauliList(['III', 'IIZ', 'III'])}" + "{0: PauliList(['III', 'III', 'IIZ']), 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" ] }, "execution_count": 5, @@ -166,9 +166,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 6, @@ -187,9 +187,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 7, @@ -224,7 +224,7 @@ "source": [ "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", - "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=np.inf)\n", + "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=10_000)\n", "print(f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\")" ] } From 6ed452877d2d865f1408971ef73c480d2cf8dc3f Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 16:02:31 -0600 Subject: [PATCH 052/128] clean up tutorial --- .../tutorials/04_automatic_cut_finding.ipynb | 35 +++++++++++-------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index cf1734592..c8d9b26ce 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,9 +21,9 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvsAAAGRCAYAAAD7BnzvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACFbklEQVR4nO3dd1hV9R8H8PddwEWWInAVUFDBrYgT98hBmjttqJktc/srU0tTLM1VmlqmVlpqqTlypKbiVpwI4kScgFxBENlw1+8P8toNkHk5917er+fxebzfs95n3MOHw/ecI9LpdDoQEREREZHFEQsdgIiIiIiIjIPFPhERERGRhWKxT0RERERkoVjsExERERFZKBb7REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVkoFvtERERERBaKxT4RERERkYVisU9EREREZKFY7BMRERERWSgW+0REREREForFPhERERGRhWKxT0RERERkoVjsExERERFZKBb7REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVkoFvtERERERBaKxT4RERERkYVisU9EREREZKFY7BMRERERWSgW+0REREREForFPhERERGRhWKxT0RERERkoVjsExERERFZKBb7REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVkoqdABLF3wW/ORek8pdAyzYu+lQLdfpgkdg4zE3L4Tpno8mtJ2NNVtJBTuGyLT0Xf8QdyOSRE6RqFqezhg1/LuRpk3i30jS72nRHJkjNAxiEwGvxNlg9vRdHHfEJmO2zEpuHY7WegYgmI3HiIiIiIiC8Vin4iIiIjIQrHYJyIiIiKyUCz2iYiIiIgsFG/QtXC9tgUh5W4cTn/8g0G7nYcLBp9fib39ZiD+3A2B0hGRsbVfOhZ1hnYBAGg1GmQ+SkbcqSsInbcRGcokgdMR9w8RGRuv7BMRWTjlmWvY3ORdbG3xIY6PXQrnRl7ovPojoWPRP7h/iMiYWOwTEVk4bY4amQnJyFAm4dGZ67i54RBcW9aFzE4udDQC9w8RGReLfSKiCkTuVhlefdpAq9ZAp9EKHYf+g/uHiMoa++wTAKDXjjmwspNDJJMi/ux1nJn+I3Ra/qAhsgSKtg3xZtR6iMRiSOXWAIArK3dBnZkNALBVVMHLe+ZiT8+pyEpMgURuhX6HvsbhdxYh+cYDIaNXCIXtn85rPsLDY+GI3HAIAFClkTc6fj8Ru7tPgSZbJVhuIjIPZn1lPzw8HP369YOjoyMcHBzQv39/xMXFwd7eHq+99prQ8cxK8PCvsKv7FOzsPBnWzg7weiVA6EhEVEYSQm9h10tTsCdwGsK++QPx52/i0oLf9cMzlEm4tmoPWgaNBAD4fTQE9/edZaFfTgrbP+dmrkXj8QNgXcUeEIkQMP89nP30Jxb6RFQkZntlPzg4GH369EHNmjUxY8YMyOVyrFu3DoGBgUhLS4Ofn5/QEU1CTkoGrBwq5Wm3csxte/bDQpWWCQAQSSWQyKTQ6XTlF9LEaVVqPPj7PO5sO4GsxKeQ2trAs2cL1B7cCVb2tkLHsyjuXZuh+fQ34Ojjgcz4J7j2015cW7VH6FhmT5OVg9R7SgBA2KLNsPdSoPXcdwye0nX9p33os38B6r/7Mmq+3Bq7un0sVNwKp7D9k6FMwtVVe9Bi5nA8vhSFp3fiEHcyQsjIRBYhsL0H5k1ogfq1nBCXkIFlv13DkvVXhI5V5syy2E9ISMDQoUPh7++PQ4cOQS7PvYlp+PDh8Pb2BgAW+/94GhULr1cCIBKLDbrlVG1WB1q1Bql34/RtPbfOhnMjb8QEh+L+njNCxDU5yTejcWj4PKRFJ+Q2iEQAdHh4LBwX525Ex+8mokbPloJmtBTOTWuj27qpuPLDLhwbsxQuzXwQsOB9aDJzcPPXA0LHsyhhizdjwPFvcXP9QSSG3wYA6LRanJ+1Dr22B+HwqIX6LiRU/vLbPzfW7kfvv+ahWrtG2B04TeCEROaveYOq2Pltdyz+JQKvTz2C1o1d8cPMtsjIUmPVH5b1SHKz7MazYMECPHnyBGvXrtUX+gDg6OgIf39/ACz2n7nxy37YuDii3dKxcG5SC/Y13eDdvx2affIaojYfQU5Khn7cvwfPxma/9yCRW0HRvpGAqU1DWnQC9g+a9bzQBwCdDvjnjx7qjGwceWcRHp64LExAC9Pw/T54HHYbofN+w9NbsYjachTXf96HxuP6Cx3N4qTeVSL64AX4T3vdoN29WzNkKJNQuV4NgZIRUMD+0elw89eDiAkORXZiinDhiCzE/0Y0wvmrCfh02QXcuPsUv+y6heW/X8O0UU2EjlbmzLLY37RpEzp06ABfX998h7u5uUGhUAAA1Go1Jk6ciCpVqsDJyQnvvPMOsrKyyjOuoNJjHmPvK5/B2rESuv0yDX0Pf40mEwbiyve7EDJtTZ7xNVk5eLDvHK9WA7i8fDuyXvRDVafLvRoa9Cu7PZUB11b1EHvkkkFb7JEw2Hm6wrZaFYFSWa4r3++Ce2c/KAIaAgCc6tVAjV6tsCdwGnze6Aa7Gq4CJ6zY/rt/AABaLXRanmuIykI7PzfsPxVj0Lb/VAy83O3h7mZZXXTNrhuPUqlEbGwshg4dmmeYVqtFREQEmjVrpm+bN28ejhw5goiICFhZWaFv37745JNPsGzZsiItT61WQ6lUljivSqUu8bRl5cm1+wh+a36Bw2X2thBbSZGdmAKRRAzP7i2gPH21HBMaUqnUiImJKXxEI1KnZSHqj6OFj6gDnly9h6v7TsKpibfRc1mCgr4TclcnZCYkG7Rlxj/5Z1hlZMQJ8zZRUzge81PUc8vJSd/l255w4SbWVRus/xyw4H2cn7UOGcokXFq4Ca3nvoPg4V8VOYspbiOhFOe8X9T9U5os3DdUkalV+d/IXs1FDuXjTIO2Z5+rVbVF7KOM/CYzGrVKVeh3VaFQQCotfuludsV+eno6AEAkEuUZtnPnTsTHxxt04fnxxx+xcOFCuLu7AwBmz56NV199FUuWLIFEIil0eUqlEp6eniXO+6Vzd7jLHEo8fXmwcrRFlx+nQCyTQiQRI+54OG6uF66PdGRkJIaUYpuXBW9ZZXzu3LXI40969W0EZ9w2YiLLYQ7fiX8zheMxP2W5HX3efAlZj58iJjgUAHD7j2Pweb0rarzcGg/2ni10elPdRkIxpWOc+4YqPJ8gwMZd6BSFioyMhKfn6y8cJzo6Gh4eHsWet9kV+56enpBIJDh27JhB+/379zF+/HgAz/vrJycnIzo62qD49/f3R2pqKu7du4fatWuXV2yTlh7zGHt6TRU6hkkRIe8vky8iLub4lFdmfDLkLk4GbTb/fH52hZ+M49bGQ7i18ZBB2/6BswRKQwWJ2nIUUVuOCh2DyCLEJWRCUdXwLdVuzrmf4x6X71V9YzO7Yt/KygojRozA2rVr0a9fP/Tu3RvR0dFYs2YN3NzcEBsbqy/uU1NTAQBOTk766Z/9/9mwwigUCkRHR5c4b8iQ+Ui/W/JuQBWRr68vorf8LGiGnCdpOBH4eZHfYLnol5VwblPPyKksQ0HfifhzN1C9sx/Cl2zVt7l38UNadLxgXXgA0zge82NK5xZT3UZC4b4hMh3dRp9E5IP0PO2nwh6hZ1sPfLEqTN/Wq50H7sWmlnsXHiD3uxp8+MX15rP7UYvL7Ip9AFi2bBlkMhl27tyJw4cPIyAgADt27MCcOXMQFRWlv3HX3t4eAPD06VP9BkpOTjYYVhipVFqiP5k8I5OZ5SYWlExWum1eJjyA6FcCcPfPUy8eTwTYebqiycCuEInN8n73clfQd+Lq6j3ovXsumk17HXe2HkPVZj6oPyoQ52f/Us4JDZnE8ZgPUzq3mOo2Egr3DZHpkMpk+bYvWX8Fp399BV+Ob471u6PQuokLxr/eAJMXFd510RikMpnRvqumc0YqBjs7O6xatQqrVq0yaL9y5QoaN24M8T9Fl5OTEzw9PREWFoa6desCAC5dugR7e3t4eXmVd2wyM43HD8CD/edzXzyW39N2ch+5D/+pr7PQLwOJ4bdx+O2F8J/+BhqN7ovMhGSELvidz9gnIqIyd+HqY/SfdAjzJjTHx281hvJxJj5bftHinrEPmGmxn5/k5GTExMSgd+/eBu3vvvsuvvrqK3To0AEymQyzZ8/GyJEji3RzLlVsVRp44aX103H47QVQpWXpi/vnRGj95duoNbCDQAktT0xwqP4mUSIiImPaeyIae0+UvKu2ubCYYj8iIvfV4f99mdann36Kx48fo2HDhtBqtRg8eDAWLFggQEIyR9XaN8agkO9wa9Nh3Np8BClRDwEAPm92Q6MP+8GxdnWBExIREREVzOKLfalUimXLlhX5ufrGJpFboeeWWXDy8UDI1NW4u7PgPuG9tgXhaVQsQqauBgAMu7MRjy9FAQCu/fgXHuw7V+C0L234FFJba0jl1rj6w+48y6n3di9492sHiERIvf8IpyZ/B5FYjB6bZurHcWnhi81N3kXO07w3tgBA8xnDoGjTAADwYP85RKz402C4S3NftJz1FrQqNXQ6HU6MX4aMuCT4fTQEXn0DkPU4BTkpGTj8tmn/8mVT1RGNxw1ArYEd8UfzDwAAfv8bgkrVnQVORlS4F503JHIrtP5iFOxquEEsEePQsHnQQVfkcxSVXGE/C9p9Mwb2Xm6Q2trgzrbjuLbmL9h5uKDj95OgVashkkhwZtoaPLl+X6A1ICJzYTHF/pgxYzBmzBihYxRKm63GkVGLUHdEjxeO5/FSc6jSDF/2kB77GPsHFe1xeIffXgitSg2ZnRyv/L0wzw+SyA2HcGPtfgBA+2XjUb1jE8QeCdPPv0pDLzSfMazAQh8AIjcewsUvNwAiEV7e+SXu/nkKaTEJ+uGJl+9gb9/PAAB1XuuK+m8H4uK8jQCA8G+2soggKgcvOm/4/W8I7uw4CeWpK/o2kVhcpHMUlU5hPwtCpq6GVqWGSCLGgOPf4uaGg0iPS8TefjMAnQ6Kdo3QZMJAHPtwSTknJyJzw7sKy5lOq83zltA8RCLUe7sXbqzbb9Asd6uMXtuD0GnlZNg4v/iFLdp/3uAotbVGcmTe/mjaf73hUSQCUv7zmLhaAzvgzvYTL1xG6rNpdDpoNRpoNZoCl2FlL0fStXv6z43H9Ufgzi9Q+9VOL1wGEZXOi84binYNUaNnC/TaFoQmkwYBKOI5ikqtsO387PwpsbZCanQ8NFmq3EcB//OwgP+eU4mICsJi3wTVGdIZ9/eehSbL8BXP29qMxf6Bs/DgwHm0nP1WofPptT0I/Q5/jeiDF/Md3nhcfww4uQxWTnbIePSv55iLRKjRqxXuF+HNmQDg1bct0mMf5/ssdPcufuizbz7qjuiBx2G5b5i9/vNe7Oo+BYfenId6I3vBoVa1Ii2HiIrvReeNKg28cv+iN3g2nBvXgiKgoUApKT+dVk7GoJDlSDh/U1/kV2nohZd3z0Xrue8i7kSEwAmJyByw2DcxEmsZag3sgKhNh/MMy07KfRHYvV2nUaWRd6Hz2j9wFra3m4DG4/pDZm+bZ3jEij+xo/0EpN5Tos6QLvp2RUADJF65C3V6VqHLcGtTH75vvoTTH/+Q7/DYI2HYEzgNF7/6Df7T38hdjydpAABVWiZij4ahcgOvQpdDRCXzovNGVlIKYo+GAzodHh4LR+UGNYWISAU49uESbG09Fu5dm8HRN/f520lX72HvK58heOR8tJ73jsAJicgcWEyffUthV8MVVo6V8NL66bBysoPc1Qm1X+2E+3vOQJOtgk6rhVubBki9l9uFRlrJBmKJGDkpz9/2JhKLARGg02ihzsyGJlsFTXaOwXLEVlJoc3L/TJyTkgFN1vPh/+3CI5KIYePsgMz4ZIN5VGnoheafDcOh4V8ZTJ/vMp6m68eR2dtClZoBkVgM15b18KCIf0Egeqb90rGoMzT3F1StRoPMR8mIO3UFofM2IkMp3Nt2TY1Ubp3veeOZR2euw7lJLSSG34Zzk1pF/mseGd+z86cmKyf3PJ6ZY3BOVaVkQJOZ97xLRPRfLPYF0PnHj+HcyBvqjCxU9ffB+Vnr4N7FD1ZOdri74yT29JoKAFAENIR3/3a4/ccxODephbaLR0OVngWtSoOQT3JfKObdvz2kNla4/tNe/fytHG3R5acpgA4Qy6SIWL4D2hw15C5OaPBBH1z8cgP8p72Bqk1rA2IR0h7E4/LSbQByf8BUa98YZ6b/qJ+fXQ1XtJgxHEfeWWSwHgEL3ofMXo6uP00BAJz7fC2Srt5D+2XjcXLCcnj1CYDvsJeg0+qgVWsQ8s/V/5azRsDJ1xMiqRgP9p5F0tV7RtvWZLmUZ67h2PvfQCQRw97LDW3mvYvOqz/S3xROgKOPe57zxr/PNRfnbUC7xR9CYmOF5JvRiD18CUD+5ygqe//dzg+Phun3zUvrP4VYKoHYSop7e0KQFh0PRbtG8Pt4CHQaLUQiEc7NXif0KhCRGRDpdPm9GpTKyp+dJiE5MsZo82/1xdsIX7oN2YkpRltGrYEdkJOSgZhD+ff9L2tOvh7of2xpuSyrONIfJuofvfnqxVV89GYJlcV3ov3SsbCt5owDQ+fo2+qNCkSbue9go8/wPE+yKg1TPR6NfW4pDlPdRkLhviEyHQ0HbMO128lCxyhUg9pOuLpjkFHmzSv7Zu7czLVGX0ZhT+UhEprcrTK8+rSBVq3JfWIJERERAWCxT0RmStG2Id6MWg+RWAyp3BoAcGXlLqgzswEANQJbwe9/rxpM4+jrgXMz1yL6wAW8vGcu9vSciqzEFEjkVuh36GscfmcRkm88KPd1ISIiMhYW+0RklhJCb+HkxBWQWMvg1bctqndogksLftcPf7DvnMHbYmv0agn/6W8g6o+j0GTm4NqqPWgZNBInxi2D30dDcH/fWRb6RERkcVjsG5m9l0LoCGaH24yKQpOVo3+6TNiizbD3UqD13HfyfQysbbUqaD3vXRx6c57+CSbXf9qHPvsXoP67L6Pmy62xq9vH5Zq/tEzpe2JKWUyBKW0PU8pCRMJgsW9k3X6ZJnQEogohbPFmDDj+LW6uP4jE8NvPB4hE6LhiIiJW/Ikn1+/rm3VaLc7PWode24NweNRCffcfc8Fzi+niviEiU8KXahGRRUi9q0T0wQvwn/a6QXvTSYOQk5qBGz/vyzONe7dmyFAmoXK9GuUVk4iIqFyx2Ccii3Hl+11w7+wHRUBDAIBry7rweaMbTk3+Ls+4TvVqoEavVtgTOA0+b3SDXQ3X8o5LRERkdOzGQ0Rm5+SkvMU7ACRcuIl11QYDAKwcbNFh+QScnLgC2U/S8owbsOB9nJ+1DhnKJFxauAmt576D4OFfGTU3ERFReWOxT0QWqe5bPSF3dUKroJEG7VF/HIMqPQtZj58iJjgUAHD7j2Pweb0rarzcGg/2nhUgLRERkXGw2CciixSxfAcilu8ocPitjYcMPu8fOMvYkYiIiMod++wTEREREVkoFvtERERERBaKxT4RERERkYVisU9EREREZKFY7BMRERERWSgW+0REREREFoqP3iQisyWRW6Hnlllw8vFAyNTVuLvzlMFwzx4t0GTCQGhUakSuP4g7208AANouHg2H2tWhycrBqY9WIuNhohDxiYiIjI7FPhGZLW22GkdGLULdET3yDhSJ0PyzN7EncDo02TnotT0I0Qcvolq7htBkq7B/wOdwblILzT8bhhNjvy3/8EREROWAxT4RmS2dVovMhOR8h9lUsUfW4xSoM7IAAE+jHsLF3wcOtaojMfw2ACDx8h24ta5XXnGJiIjKHfvsE5FFykpMgU1VB8hdnSCtZAO31vVh7WSHJzceoHpnPwCAexc/yJ0dhQ1KRERkRLyyb6YmnwViM4ROAbjbAktaC52i4jGV/Q+Y9jEQMnU1On43EerMHCTfjEbGoyQ8OnMdLv4+6LUtCEnX7iHp+n2hYxZJ8FvzkXpPKXSMIrH3UqDbL9OEjkFmxJSOb2Mcv6a0fuaC55Gyw2LfTMVmAHdShU5BQuH+L5pHZ67j71eDILW1QZefPkbCxVsAgLDFWwAA1do3hiZbJWTEIku9p0RyZIzQMYiMwtKPb0tfPzJtLPaJyKx1/vFjODfyhjojC1X9ffDwaBisnOxwd8dJtJg1As6Na0Gr1iD0q9+gValhXcUeXdZ8DK1ag/TYxzj72U9CrwIREZHRsNgnIrN29N3FBQ67EPRrnrbspFTsHzTLmJGIiIhMBm/QJSIiIiKyUCz2iYiIiIgsFLvxEFm4e9+OROLhX3I/iMWQVa4G+8Zd4T7iK1g5uwsbjoiIiIyKxT5RBWDXoANqfbIFOq0G2crbeLBqLO4seBX1Fp4WOhqVs/ZLx6LO0C4AAK1Gg8xHyYg7dQWh8zYiQ5kkcDoiMrZe24KQcjcOpz/+waDdzsMFg8+vxN5+MxB/7oZA6cgY2I2HqAIQSa0gq6yAlbM77Bt2hEuP95F+MwSajBSho5EAlGeuYXOTd7G1xYc4PnYpnBt5ofPqj4SORURERsBin6iCyUl8iCentwJiSe4/qnC0OWpkJiQjQ5n7krGbGw7BtWVdyOzkQkcjIqIyxm48RBVA6pWjuDTUDjqtFrqcTACAW/+PILGpBAB4ErIDcZuDDKbJir4Gz3e/hUvgh+Wel8qP3K0yvPq0gVatgU6jFToOERGVMbMu9sPDw/H555/j6NGj0Ol06Nq1K1auXAlfX1/07t0bmzZtEjoikUmo5NsaXpN+gS4nC09ObkFK+CFUf/NL/fDKAQNQOWCA/nPymT8Ru/5TOHd9S4i4ZGSKtg3xZtR6iMRiSOXWAIArK3dBnZktcDIiIiprZlvsBwcHo0+fPqhZsyZmzJgBuVyOdevWITAwEGlpafDz8xM6oknSZmcibus8PDmxCTmJMRBbyWGtqA3nzsPh+soEoeORkYit5LCpVgcAIK/ZCNnK24hePR41x63JM27O4xg8WDUWdWbtg9jattwyurWpj4Yf9EWVRl6w83BB6ILfcXnptnJbfkWSEHoLJyeugMRaBq++bVG9QxNcWvC70LGIiq390rGwreaMA0Pn5Bk2Mm4rjo/7Fne2nRAgGZHpMMtiPyEhAUOHDoW/vz8OHToEuTy3n+nw4cPh7e0NACz2C/Dghw+RGnEEnu9+C7l3U2gyUpBx5xJyEh4IHY3KUbXXZ+Pq2Pqo2vMDVPJpoW/XabW4u2QYFIOmwdarSblmktraIPlWNO7sOIFWc94u12VXNJqsHKTeUwIAwhZthr2XAq3nvpPn6RxEZHlyUjJg5VApT7uVY26bJltV3pHIyMzyBt0FCxbgyZMnWLt2rb7QBwBHR0f4+/sDYLFfkOSzf8JtwBQ4tekPazdv2Ho3RdVuI1H9tc+FjkblyKa6D5xavoKHGz4zaI/b8iUkcge49hlf7pliD19C6LzfcG/XaWhz+MOmPIUt3ow6Q7vAuWltoaMQkZE9jYqFc5NaEIkNS8CqzepAq9Yg9W6cQMnIWMyy2N+0aRM6dOgAX1/ffIe7ublBoVAAALZs2YL27dvDzs4OXl5e5ZjSNMkqV0NK6H6oU/k87YrObcAUpIQdQGrEUQBA2vVTSDz0E7wmrBU0F5W/1LtKRB+8AP9prwsdhYiM7MYv+2Hj4oh2S8fCuUkt2Nd0g3f/dmj2yWuI2nwEOSkZQkekMmZ23XiUSiViY2MxdOjQPMO0Wi0iIiLQrFkzfVvlypUxbtw4PHr0CEuWLCn28tRqNZRKZakyG4NK5QZAVuzpao77EXe/fgPhI1wg92yISnXbwLH5y3Bs3Q8ikagEOVSIiXlU7OnMUdajZP3/4+LiYKPNFCxLcfa/18R1+bbb1W+L5jt1AAB1WjLuLhkOrwnrIHVwLmaW4h0DKpW6WPMXmkqlRkxMjNAxjL7drny/C713z4UioCGUIVdLNS9T2WZkPkpzfD+74bwss5T18WtK5730mMfY+8pn8J/6Orr9Mg0yB1uk3X+EK9/vwrUf/xI6nl5Z7Qe1yjz+UqxWqQpdX4VCAam0+KW72RX76enpAJBvYbpz507Ex8cbdOHp3r07AODPP/8s0fKUSiU8PT1LNK0xNVh+BfIaDYs9nV39dmi06jbSI88h/WYIUq8ex+0Fg+HYPBC1P9tV7II/MjISnj0bFTuHOaosluMb15cBAK1atcITAYv9ku7/giTsXwnVkzhE/zzZoN25y1tw6ze5gKlyFfcY+NK5O9xlDiXKKYTIyEgMMYFzQFltt5OTvsu3PeHCTayrNrjU8wdMZ5uR+SjN8f3shvP/GhSSt60ojHH8mtp578m1+wh+a77QMV6ozPaDTxBg4176+RhZZGQkPD1f/NfV6OhoeHh4FHveZlfse3p6QiKR4NixYwbt9+/fx/jxuf2M2V//xUQSKezqt4Vd/bZw6/8REo9uwL0lw5F29TjsG3USOh4JoNrg6ag2eLrQMYiIiu3fN5wTUV5mV+xbWVlhxIgRWLt2Lfr164fevXsjOjoaa9asgZubG2JjY8u02FcoFIiOji6z+ZWV8dfcEJ1VNvOy8agPAFA/jS/2tL6+vvjbBLePMWQ9SsbJPrMBAOfOnYONm5NgWcpy/5dWcY+BkCHzkX7XfH4w+/r6InrLz0LHMKvtZirbjMyHKR3fxjh+TWn9zEVZ7Yduo08i8kF6GSQyLl9fXwQffvHP0mf3oxaX2RX7ALBs2TLIZDLs3LkThw8fRkBAAHbs2IE5c+YgKiqqwBt3S0IqlZboTybGJrsFoATF3s1PO6FKh9dhW6cFpI4uyI6LQuz6TyGp5AT7xl2Kn0MmM8ntYwzp4udPfqpWrRoqVS9e3/ayVNL9bwzFPQZksvxPO1JbGzh4557IxDIp5C5OqNLQC6r0LEGv2slkpnEOKGi7mSJT2WZkPkzp+DbG8WtK62cuymo/SGXFv79RCFIj1lNmefTZ2dlh1apVWLVqlUH7lStX0LhxY4jFZvmQoXLh6B+IpOMb8fD3z6HJSIHU0RX2DTvCa8JaSB2qCh2PKrCqTWuj1/Yg/ef6owJRf1QglKevYv+gWQImIyIiMl9mWeznJzk5GTExMejdu7dBu0ajgUqlgkqlgk6nQ1ZWFkQiEaytrQVKKizF4GlQDJ4mdAyiPJQhV8vsBlEiqhgKuuEcAM8nRP+wmGI/IiICQN6bc9evX4+3337+Nk65XI6aNWvi3r175ZiOSFja7AxEzuyGrJjrqDH6B1Tp+JrB8HvLRiFbeRvarHRU6TwMbn0nCROUimTYnY14fCkKAHDtx7/wYN85g+HtvhkDey83SG1tcGfbcVxbU/jj9Pw+HgLvfu2wo8NEg3aJ3Ao9t8yCk48HQqauxt2dp/TDGo/rj2odmkAslSB0we+IP3ejDNaOyPK96Hv1jGePFmgyYSA0KjUi1x/Ene0nijTdv/XaFgSxTAqtSg1lyFWELd5iMLzBe73hPaA9tCoNkiLu4OyM3D7y1s4OaDP3Hdg4O0CdmYPgEV8VuIzmM4ZB0aYBAODB/nOIWPFnvuMp2jZEr21B2NzkXWQmJMOluS9afD4COo0G0Qcv4urKXS9cFyo5iy/2R44ciZEjR5Z/ICITIpJao/b0HUjY/0O+w2t8+APEMivoNGpcHVsfLj3fh9jatpxTUlGlxz5+YdemkKmroVWpIZKIMeD4t7i54SA0mTkFjm9T1REOtarnO0ybrcaRUYtQd0QPg3b3rs0gkVvjwNA5JVsJogqsoO+VnkiE5p+9iT2B06HJzkGv7UGIPngR6vSsF0+XjyPvLEJmQnK+w6IPXtRfDOi0cjLcAhrgUcg1tJz1FsIWb8bTqIeFzj9y4yFc/HIDIBLh5Z1f4u6fp5AWk5BnvIYfvILHYVH6z62+eBtHRi1ChjIJXddORfTf55Fyh2/vNQaL6dw+ZswY6HQ6tGnTRugoRCZHJJFAVrngu/jFMisAgDYnC1Zu3hDJbMorGpWA3K0yem0PQqeVk2HjnPfZ3dp/XuAjsbZCanQ8NFkvfqlM08mDEbF8R77DdFptvoWC1ysBkNpao8eWWWi/dCyklXjMEBVVQd+rZ2yq2CPrcQrUGVnQabR4GvUQLv4+hU6XZzk6HTqv+Qg9Ns2Ec9PaeYb/++EHWrUaOo0WIrEYTnU90HjcAPTaHgSfN7q9cBmpz54ypNNBq9FAq9HkGcfrlQDEHg2DOiNb3yarZIMMZRIA4PHl21C0Lbt3x5Ahiyn2iah07ix6DVdG14FdvbYQ8SZ3k7atzVjsHzgLDw6cR8vZb+U7TqeVkzEoZDkSzt8EdLoC52XvrYCskg2eXL9frAy2iirQqTQ4MCQISVfvodHovsWanogKlpWYApuqDpC7OkFayQZurevD2smu2PM5+v7X2Nd/Js589hM6LBtX4HiurerBVlEF8eduwKaqA6o08MKVlbtw4LUv4PNaV9jXdCt0WV592yI99jEy4pIM2kVSCXzefAmRGw4ZtGcnp8OpridEUgmqd2xSovWjouFPdCICANSasgmNV9/F04v7kPngmtBx6AWyk1IBAPd2nUaVRt75jnPswyXY2nos3Ls2g6NvwY9z8/t4KMKXbC1+hidpiD0SBgCIPXIJlRvULPY8iKhgIVNXo+N3E9Fp5WQk34xGxqOkwif6j2fnipTbD5GVlArrfP4S6OjjjhYzhuPoB98AAHKepiP94WMk34yGNkeNR2euwanui99k69amPnzffAmnP87bVbTusO64s+24/i+O+vWb8gNazhqBl36dhrToBGQ8elLs9aOiYbFPRNCqcv+0KrKygdjaFmJreSFTkFCkcmv9X17c2jTI9x0EYqvc27E0WTlQZ2br++tXcs/7eF37Gq5o89W76P7bZ7CtVgUtPh9RpBzKkKv6bgHOTWsj5S772hKVpUdnruPvV4NwbPQSSG2tkXDxVoHjSivZwMoh731WMrvcc7m1swPkLk764v+ZSu5V0f7bcTg+9lv9ME22Cukxj2GrqAIAqNKkFlLuKSGSiCF3dcqzjCoNvdD8s2E4+sE30GTlvTfIqZ4nag3qiO6/fYbK9Wug4/cTAZEIyZExOPjGXBwaMR9WDraIOXypyNuGisdibtAlohe7PX8QMu5cgtimEtIjz8LBvyc0qUmo0ukNRM3pDZ1WDZ0qG5XbvQprt/yvFpPwHH3c0XbxaKjSs6BVaRDySe77Rty7+MHKyQ53d5zES+s/hVgqgdhKint7QpAWHQ+RVIKuaz/B7h6fGMxv7yuf6f8/4MS3uDDnVwBAqzkjEfbNVuQkp6Hzjx/DuZE31BlZqOrvg/Oz1iFq8xG0+/pD9Nw6G5psFU5MWF5+G4HIAuT3vfr397jFrBFwblwLWrUGoV/9pr8ynt903v3bQ2pjhes/7X2+AJEIPbfNhiYrB2KpFOc+XwvodJC7OKHBB31w8csNaDFjOGyqOKD90rEAgIgVOxB7JAznZq1Dx+8nQiyVIubIJTyNjIG9twItZgzHkXcWGaxHwIL3IbOXo+tPUwAA5z5fi6Sr99B+2XicnLAcZ6at0Y/ba1sQjo/5FtDp0PDDvvDo5g+dVoerP+xCdmKKkbd4xSXS6V7QmZNM1pAjwJ3Uwscztlr2wJbiv3jXLKU/TMQfzT8AALx6cZWgb9A1lf0PFP8Y+LPTJCRHxhgvUBlz8vVA/2NLhY5R6u3m2rIuqjTyxo21+8swVf5MZZuR+TCl84Ixjl9jr1+rL95G+NJtRi2Yaw3sgJyUDMQcumi0ZfxbWe2HhgO24drt5FLPx9ga1HbC1R2DjDJvXtknIqoA4s/fRPz5m0LHICIjODdzrdGXcWf7CaMvg4yDffaJiIiIiCwUi30iIiIiIgvFbjxmyt1EXm5qKjkqGlPa7sXNYu9V8Mu9TJGp5DWVHEVhTlnJNJT2mNGqNfq3rzrUqgaxVCJYlvKap6XjNis7vEGXqIhM6QZdIiJ6judnKghv0GU3HiIiIiIii8Vin4iIiIjIQrHYJyIiIiKyUCz2iYiIiIgsFIt9IiIiIiILxWKfiIiIiMhCsdgnIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFYp+IiIiIyEKx2CciIiIislAs9omIiIiILBSLfSIiIiIiC8Vin4iIiIjIQrHYJyIiIiKyUFKhA9CLBb81H6n3lELHKBZ7LwW6/TJN6BgWyxSPidLsc1NbH3M5fk1pu5nLNsuPKW1Hc2HO+9vSTD4LxGYInQJwtwWWtBY6BRWExb6JS72nRHJkjNAxyIRY2jFhaetTXrjdyga3I5mz2AzgTqrQKcjUsRsPEREREZGFYrFPRERERGShWOwTEREREVkoFvtERERERBaKN+gSEVm49kvHos7QLgAArUaDzEfJiDt1BaHzNiJDmSRwOiIiMiZe2SciqgCUZ65hc5N3sbXFhzg+dimcG3mh8+qPhI5FRERGxmKfiKgC0OaokZmQjAxlEh6duY6bGw7BtWVdyOzkQkcjIiIjYrFPRFTByN0qw6tPG2jVGug0WqHjEBGREbHPPhFRBaBo2xBvRq2HSCyGVG4NALiychfUmdkAgM5rPsLDY+GI3HAIAFClkTc6fj8Ru7tPgSZbJVhuIiIqHbO+sh8eHo5+/frB0dERDg4O6N+/P+Li4mBvb4/XXntN6HhERCYjIfQWdr00BXsCpyHsmz8Qf/4mLi34XT/83My1aDx+AKyr2AMiEQLmv4ezn/7EQp+oAop4z0voCFSGzPbKfnBwMPr06YOaNWtixowZkMvlWLduHQIDA5GWlgY/Pz+hIxqVW5v6aPhBX1Rp5AU7DxeELvgdl5duEzoWCcy9azM0n/4GHH08kBn/BNd+2otrq/YIHavELG19hKTJykHqPSUAIGzRZth7KdB67js4/fEPAIAMZRKurtqDFjOH4/GlKDy9E4e4kxFCRhYUz7FEtPaLDhjZzxcAoFJp8TQtBzfuJmPXsQf4btN1ZGSqBU5YNGZZ7CckJGDo0KHw9/fHoUOHIJfn3mA2fPhweHt7A4DFF/tSWxsk34rGnR0n0GrO20LHIRPg3LQ2uq2biis/7MKxMUvh0swHAQvehyYzBzd/PSB0vGKztPUxNWGLN2PA8W9xc/1BJIbfBgDcWLsfvf+ah2rtGmF34DSBEwqL51iqiKJ/nIzUK0egSnqIa5P8YFO9Lmp9slnoWII6flGJIR8fhlgsgrOTNdo3c8P0d5rinQG+6DjyL8QnZQkdsVBmWewvWLAAT548wdq1a/WFPgA4OjrC398fwcHBFl/sxx6+hNjDlwAALWYMEzgNmYKG7/fB47DbCJ33GwDg6a1YONX1RONx/c2yOLa09TE1qXeViD54Af7TXsfB17/MbdTpcPPXg6jatBayE1OEDSgwnmPJklzsJ3rhcCvXmmi85h48310CILcbT4OlYeWQzPTlqDR4lJgJAIhLyMCVW0+w6+gDRGwbiPmTWmLU5ycAAGOG1sfY1+qjtqcDnqbl4ESoEoP/dxi1Pe0Rurk/Zn0fiqUbrgIA6nk74sKmfpi88CzWbLtp9HUwyz77mzZtQocOHeDr65vvcDc3NygUCmRnZ+O9995DrVq1YG9vD19fXyxfvryc0xKVD9dW9RB75JJBW+yRMNh5usK2WhWBUpWcpa2PKbry/S64d/aDIqDh80atFjqtTrhQRFTmmqyL0/+rNS23O1r9JaH6tnqLzwuc0Lw8jM/Axr+iMLCbF0QiYPaYZlgwuSW+33wdjQdtR68P/0bo9UQAwO3oVHz45WnMn9QSzeo7w9pKgs2LuuKv49HlUugDZnhlX6lUIjY2FkOHDs0zTKvVIiIiAs2aNQMAqNVqKBQKHDhwALVq1cLly5fRs2dPuLm5YciQIUVanlqthlKpLNN1KA6Vyjz6g/2bSqVGTEyM0DHKXNajZP3/4+LiYKPNFCRHQceE3NUJmQnJBm2Z8U/+GVYZGXHGe1Nqafa5qa2PuRy/xTk3nJz0Xb7tCRduYl21wWWSxRy2WX7M8RwrNFPc36Zyfi5vKpUbAFmh48kqK/T/l9rlXiyROrgYtJcuhwoxMY/KZF5lTa0yzkMGrt5OhqO9FTwVdvhkZBPM/O4ivtt0XT/80j/FPgD8tvc2XmpTHZsWdMGpsEewryTDe0En8+Qs7HulUCgglRa/dDe7Yj89PR0AIBLl/ZPUzp07ER8fr+/CU6lSJXzxxRf64X5+fujbty9OnjxZ5GJfqVTC09Oz9MFL6Evn7nCXOQi2/JKIjIzEEAG3mbFUFsvxjevLAIBWrVrhiUA/TEzxmCjNPje19TGX49eUtpu5bLP8mNJ2NBemuL9N5fxc3hosvwJ5jYaFj2hkkZGR8OzZSOgY+fMJAmzcy3y2z8pQRVU55DZSHDgd+8Lxx30VgohtAzDilTpo/9ZfSEkz/CUkMjISnp6vv3Ae0dHR8PDwKHZWs+vG4+npCYlEgmPHjhm0379/H+PHjwdQ8M25KpUKJ06cQJMmTYwdk6jcZcYnQ+7iZNBm88/nZ1fEzYmlrY+5iNpyFGc/+0noGEREJq1h7cpITsmGTle0bo91PB1Q3cUWOh1Qp0b5XmAwuyv7VlZWGDFiBNauXYt+/fqhd+/eiI6Oxpo1a+Dm5obY2NgCi/1x48bB3t4eI0aMKPLyFAoFoqOjyyh98YUMmY/0u8J1IyoJX19fRG/5WegYZS7rUTJO9pkNADh37hxs3JwEyVHQMRF/7gaqd/ZD+JKt+jb3Ln5Ii443ahceoHT73NTWx1yOX1M6N5jLNsuPKW1Hc2GK+9tUzs/lbfw1N0Qb4WEwNp4NijW+r68v/hawVnqRbqNPIvJBepnOs7qrLd7sXRvbg+/j2u1kZGap0aOtOyJu5X8hylYuxaaFXbBp/x2E3UzCd58GICT8EW5Hp+rH8fX1RfDhF29DhaJk3a7MrtgHgGXLlkEmk2Hnzp04fPgwAgICsGPHDsyZMwdRUVH53rj7v//9DyEhITh8+DCsrKyKvCypVFqiP5mUFZks/10ktbWBg3fuThfLpJC7OKFKQy+o0rP0z9IWikwm7DYzlnTx8yc/VatWDZWqOwuSo6Bj4urqPei9ey6aTXsdd7YeQ9VmPqg/KhDnZ/9SLplKus9NbX3M5fgtaLsJwVy2WX7M8RwrNFPc36Zyfi5vslsAjFDs+3y+t3g5ZDKTOyaekcoKv6fhRaxkErg5y/M8ejM+KRPTvz2P9Ew1vv71CmZ/6I/MLA0OnomF3FqKlzt4YP5PlwEAy6a2gUQswrh5IUjPVOOl1tXx+4IuaDtiN9RqnT6nsbah6fy0KAY7OzusWrUKq1atMmi/cuUKGjduDLHYsHfSpEmTEBwcjMOHD6Nq1arlGdVoqjatjV7bg/Sf648KRP1RgVCevor9g2YJmIyEkhh+G4ffXgj/6W+g0ei+yExIRuiC3832MZWWtj5kXniOJSIA6NhcAeWRN6BW575U6/qdZKzYdM3gpVozV1xEwpMsTHizAZZ80hpPUnJw/GLuRYFXe3hjWJ86CBi+G+n/jD9y5nGE/zEA8ya0wCffGP9JSGZZ7OcnOTkZMTEx6N27t0H7hAkTcPjwYRw5cgQuLi4CpSt7ypCrZfIUDbIsMcGhiAkOFTpGmbG09SHzwXMsEb098wTennmiSOMu23gVyzZezdP+x4G7+OPAXYO2xORseHTfVCYZi8LsbtAtSERE7mvd/91f//79+1i+fDmioqLg7e0NOzs72NnZITAwUKCURERERETlx2Ku7OdX7NesWbPId0kTEVkKnze6wee1rtDptAiZugbJNx7kGafXtiA8jYpFyNTVAIDWc9+Bc5NaEEnECFu0GbFHwgAAtV/thNqvdoZILMKNtftx/68z5bkqRFTG7Bt3RvOdrI0qEosp9seMGYMxY8YIHYOISFBWTnao+1YP/NX7U9jXdEPA/Pfw96tBBuN4vNQcqrTnzyF39HGHo48H9r7yGeQuTui2YTpij4TBydcDirYNcWBI0H8XQ0REZsJiuvEQERHg0qwOlKevQqfWIOX2Q1hXcXj+9hcAEIlQ7+1euLFuv74p89ETaLJzIJKIYeVoi+yk3MfB1ewTAE22Cj02f47OP36c570HRERk+ljsExFZECsnO+Q8ff5MaVVaJqwcbPWf6wzpjPt7z0KT9fztjTkpGUh7EI+Bp5aj17YgRCzfAQCwVVSGlUMlHBg6B3e2HkPzz94svxUhIqIywWKfiMiC5DxNh5VDJf1nmZ0cOSkZAACJtQy1BnZA1KbDBtNU79QUclcnbAsYhx2dJqPVF6MgkoiRnZyGh0fDAACxR8JQuUHNclsPIiIqGxbTZ59erP3SsagztAsAQKvRIPNRMuJOXUHovI3IUBr37apEVH4SQm/B7+MhEEnEsPN0RXZSCvDPgwrsarjCyrESXlo/HVZOdpC7OqH2q52QmZCM7OQ0QKeDKi0TEispxFIJlKevwrN7C0RtOQrnprWRwjfNEhGZHRb7FYjyzDUce/8biCRi2Hu5oc28d9F59UfY2/czoaMRURnJSU7Drd+CEbjjC+h0WpyZ/iPcu/jByskOd3ecxJ5eUwEAioCG8O7fDrf/OAaRWIxa/dsj8M8vILGW4fpP+6DJVuHh0XB4dG2GXttyb9A99dFKIVeNiIhKgMV+BaLNUSMzIRkAkKFMws0Nh9Bm7juQ2ckNnsxBROYtcsMhRG44pP/85Nr9POMoQ65CGZL7AhidVouTk77Ld17nPl9nlIxERFQ+2Ge/gpK7VYZXnzbQqjXQabRCxyEiIiIiI+CV/QpE0bYh3oxaD5FYDKncGgBwZeUuqDOzAQA1AlvB73+vGkzj6OuBczPXIvrABby8Zy729JyKrMQUSORW6Hfoaxx+Z1G+L+whIiIiIuGx2K9AEkJv4eTEFZBYy+DVty2qd2iCSwt+1w9/sO8cHuw7p/9co1dL+E9/A1F/HIUmMwfXVu1By6CRODFuGfw+GoL7+86y0CciIiIyYSz2KxBNVg5S7+U+TSNs0WbYeynQeu47OP3xD3nGta1WBa3nvYtDb86DJjMHAHD9p33os38B6r/7Mmq+3Bq7un1crvmJ6Dl7L0WppteqNUi5EwcAcKhVDWKpRLAsRFQy7raFj1MeTCUH5Y/FfgUWtngzBhz/FjfXH0Ri+O3nA0QidFwxEREr/sST689v7NNptTg/ax16bQ/C4VEL9d1/iKj8dftlWqmmT3+YiD+afwAA6PnHbFSq7lwWsYioHC1pLXQCMge8QbcCS72rRPTBC/Cf9rpBe9NJg5CTmoEbP+/LM417t2bIUCahcr0a5RWTiIiIiEqIV/YruCvf70Lv3XOhCGgIZchVuLasC583umF3jyl5xnWqVwM1erXCnsBpeHn3XNzedhxpD+IFSE0l9e+Xq/2bKj0TG+sMFyBRyVnSuhARERkLi/0KoqBnaCdcuIl11QYDAKwcbNFh+QScnLgC2U/S8owbsOB9nJ+1DhnKJFxauAmt576D4OFfGTU3lb1nL1f7N522ZI9fFcuk0KrUZRGrRCxpXYiIiIyBxT7p1X2rJ+SuTmgVNNKgPeqPY1ClZyHr8VPEBIcCAG7/cQw+r3dFjZdb48HeswKkpZL698vV8lNvZC/Ue7sn7GsqkJOagUdnr+Pou4sBAIPPfY/b247D2skOXn3bIfWeEn/1nl5OyfOypHUhIiIyBhb7pBexfAcilu8ocPitjYcMPu8fOMvYkaic+X08BA1Hv4KLczfi4bFwSCvZwKNrM4Nx6r/zMq6t2oO9r3wKUSme4GJslrQuREREJcVin6iCefZytX9TnrqKY6OXoNGYfri0cDNurN2vH5YUcddg3MdhtxH29ZZyyVoYS1oXIiIiY2CxT1TBPHu52r+pM7PhVNcTUrk1Hh4Lf+H0j8NuGTNesVjSuhARERkDi32iCubfL1f7t0rVivacdXWG6bxfwZLWhYiIyBj4nH0iAgAkR8ZAnZmN6p2aCh2l1CxpXYiIiEqDV/aJKhixlRRyF6c87ZkJybi6ajf8Pn4VmqwcPDweDomNFTy6+b/wxm0hWdK6EBERGQOLfaIKRtGmAYZe/jFP++8N38alBZuQlZiC+u8EomXQW8h5mo5HZ64LkLJoLGldiIiIjIHFvgXzeaMbfF7rCp1Oi5Cpa5B844F+mF0NV7T7ZgzEMike7DuHqz/sAgAMu7MRjy9FAQCu/fgXHuw7h6aTB6Na+8YAAHtvBa58txPXf9oLABBJJRhwbClu/R6MiBV/lu8KUrGdnPRdgS9Ye+b6j3tx/ce9+Q7b2mqMMWKViCWtCxERkbGw2LdQVk52qPtWD/zV+1PY13RDwPz38PerQfrhLWYMR+hXvyHhYiR6bQ/C/b/OIC06Humxj7F/kOHz88OXbEX4kq0AgFcOLMT9v87oh9Ud3h1Po2LLZ6WIiIiIqFh4g66FcmlWB8rTV6FTa5By+yGsqzgAIpF+uKOPOxIuRgIAYg6Fwq1NfQCA3K0yem0PQqeVk2Hj7GAwTydfD+Q8TUeGMgkAILW1gXvXZgbFPxERERGZDhb7FsrKyQ45T9P1n1VpmbBysNV/FomfF/7ZT9NhXdkeALCtzVjsHzgLDw6cR8vZbxnMs9agjriz46T+c6MxfXFtzV/GWgUiIiIiKiV247FQOU/TYeVQSf9ZZidHTkqG/rNO93xcKwdbZD1+CgDITkoFANzbdRpNJgw0mGfNl1vjr97TAQA2VR1RpZE3whZvQZ0hnY20FkRERAQAwW/Nz/e9IqbK3kuBbr9MEzoGgcW+xUoIvQW/j4dAJBHDztMV2UkpBhX+08gYVPWrg8dhUfDo5o9T//seUrk1NNkq6LRauLVpYHBScW1VD8m3YvS/MFSuXwM2zg7o/ttnsFVUgVgmReKVu3h49MVvLCUiIqLiS72nRHJkjNAxyAyx2LdQOclpuPVbMAJ3fAGdTosz03+Eexc/WDnZ4e6Ok7g4byPaff0hRFIJov8+j7QH8XBuUgttF4+GKj0LWpUGIZ+s0s+v1sAOuLP9eReeuBMRiDsRAQCoM6Qz5K5OLPSJiIiITAyLfQsWueEQIjcc0n9+cu2+/v+p95R5nrqTePkOdvf4JN95nZm2psDlRG05WrqgRERERGQUvEGXiIiIiMhCsdgnIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFYp+IiIiIyEKx2CciIiIislAs9omIiIiILJRZF/vh4eHo168fHB0d4eDggP79+yMuLg729vZ47bXXhI5HRGSyMpRJ+v+rUjMFTEJUeqq058fwv49tIjLjl2oFBwejT58+qFmzJmbMmAG5XI5169YhMDAQaWlp8PPzEzqi0bl3bYbm09+Ao48HMuOf4NpPe3Ft1R6hY5GA3NrUR8MP+qJKIy/YebggdMHvuLx0m9CxSsSS1sWUxJ+/gcvLtiMmOFTftrvnFNR+tTOaThqESu5VBUxHVDzpDxMRvnQrbv9xTN/2V5/pcO/SDE0mDoJbq3oCpisfPFdSYcyy2E9ISMDQoUPh7++PQ4cOQS6XAwCGDx8Ob29vALD4Yt+5aW10WzcVV37YhWNjlsKlmQ8CFrwPTWYObv56QOh4JBCprQ2Sb0Xjzo4TaDXnbaHjlIolrYupuL/3LI5+8A10ao1BuyZbhcgNBxH993kE/vkFHGpVEyghUdGl3FNiX/+ZyHz0xHCADog9fAkPj4Wj0w+T4dUnQJiA5YTnSiqMWXbjWbBgAZ48eYK1a9fqC30AcHR0hL+/PwDLL/Ybvt8Hj8NuI3Teb3h6KxZRW47i+s/70Hhcf6GjkYBiD19C6LzfcG/XaWhzVELHKRVLWhdTkBodj2MfLoFOoy1wnMyEZASPnA+dtuBxiEyBTqvF4bcX5C30DcbR4fiYpUi5pyzHZOWP50oqjFkW+5s2bUKHDh3g6+ub73A3NzcoFAoAwJgxY+Dp6QkHBwe4u7tj0qRJyMnJKc+4RuHaqh5ij1wyaIs9EgY7T1fYVqsiUCoiMlU3fz0AbY4a0OleON7TW7F4eOxyOaUiKpm4k1eQfCP6xSPpdNCqNPxrN1V4ZteNR6lUIjY2FkOHDs0zTKvVIiIiAs2aNdO3jRs3DosWLUKlSpXw+PFjvPrqq5g3bx5mz55dpOWp1WoolcJdFVCp1Pm2y12dkJmQbNCWGf/kn2GVkREn3A1KKpUaMTExgi3fWLIeJev/HxcXBxutMDc1FnRMCKk0+9zU1sdSj99bW44UedyIDfuh86kYffdN7fgzB6bwHbm6YX+Rx7215QiqjepqxDTlw9yOVVM4TgBArTKPv3aoVapCt5dCoYBUWvzS3eyK/fT0dACASCTKM2znzp2Ij4836MLToEED/f91Oh3EYjFu3bpV5OUplUp4enqWPHApfencHe4yB8GWXxKRkZEYIuA2M5bKYjm+cX0ZANCqVSs8EajYN8VjojT73NTWx1KP39Vu/SETSQodT6fT4cCOPQj8eXo5pBKeqR1/5sAUviMTndqiqbUi31rgvzIfPxX053hZMbdj1RSOEwCATxBg4y50ikJFRkbC0/P1F44THR0NDw+PYs/b7LrxeHp6QiKR4NixYwbt9+/fx/jx4wHk7a8/f/582NnZwdXVFeHh4Zg0aVI5pTWezPhkyF2cDNps/vn87Ao/EdEzWTo1dIV04QFyL6Rkac3rCiJVPFk6VZEKfZ1Ohywdj2eq2Mzuyr6VlRVGjBiBtWvXol+/fujduzeio6OxZs0auLm5ITY2Nk+xP23aNEybNg3Xr1/Hxo0bUa1a0Z80oVAoEB1dSL9AIwoZMh/pd/N2I4o/dwPVO/shfMlWfZt7Fz+kRccL2oUHAHx9fRG95WdBMxhD1qNknOwzGwBw7tw52Lg5CZKjoGNCSKXZ56a2PpZ6/F6fuxmxf4YUadxRX0/Hpz2bGzmRaTC1488cmMJ35NHBS4j49JdCxxOJRPDp1wHRM78vh1TGZW7HqikcJwDQbfRJRD5IFzpGoXx9fRF8+MX15rP7UYvL7Ip9AFi2bBlkMhl27tyJw4cPIyAgADt27MCcOXMQFRVV4I279evXR9OmTTF8+HAcOVK0/qtSqbREfzIpKzJZ/rvo6uo96L17LppNex13th5D1WY+qD8qEOdnF37yMzaZTNhtZizp4udPfqpWrRoqVXcWJEdBxwSQ+wg2B+/ck4FYJoXcxQlVGnpBlZ6FVCM+kaI0+7yg9THHdTFl8rEDc4t9EYCCLvCLRLBxdkCzYS9DYi0rz3iCedH3ifJnCt+Ram+6IWrpTmQmPC30pnP/MQNR1QK+06Z2riyMKRwnACCVmce5TCqTGW17meVZzs7ODqtWrcKqVasM2q9cuYLGjRtDLC64d5JKpUJkZKSxIxpdYvhtHH57Ifynv4FGo/siMyEZoQt+51MHKriqTWuj1/Yg/ef6owJRf1QglKevYv+gWQImKz5LWhdT4NzIGy1mDseFL9bnX/CLAImVFJ1Xf1RhCn0yXxIrGTqv/ggHhs6BJjufGzBFIkCng/+nb6Jq09rlH7Ac8VxJhTHLYj8/ycnJiImJQe/evfVtT58+xY4dO9C/f384OjoiIiICX375JXr27Clg0rITExxq8BZMImXIVayrNljoGGXCktbFVDQa0w82VR0R9vUWpD2INxjm2rIeWs4aARf//P8ySmRq3FrXR+CfX+Dc7F8Qf/a6wTA7j6po+tEQ+AztIlC68sNzJRXGYor9iIgIAIY354pEImzYsAH/+9//kJOTA1dXVwwcOBBBQUEFzIWIyLLVGdIZtQd3RNyJCDy98xBiqRQu/j6o0tBL6GhExVbVrw5e/vMLPLl+H/EXIqFVq+HgXQ3VOjSGWFL406eIKgKLLvYdHBxw6NAhgRIREZkmkViM6p2aonqnpkJHISoTlevXROX6NYWOQWSSzO7RmwUZM2YMdDod2rRpI3QUIiIiIiKTYDHFPhERERERGWKxT0RERERkoVjsExERERFZKBb7REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVkoFvtERERERBbKYt6ga6nsvRRCRyg2c8xsTkxx+5Ymk6mtj6nlISIiKg0W+yau2y/ThI5AJsbSjglLWx8iIiJTwm48REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVkoFvtERERERBaKxT4RERERkYVisU9EREREZKFY7BMRERERWSgW+0REREREForFPhERERGRhWKxT0RERERkoVjsExERERFZKBb7REREREQWisU+EREREZGFYrFPRERERGShpEIHoJLpO/4gbsekCB0DtT0csGt5d6FjFEnwW/ORek9Z4um1ao3+/3+/OhtiqaRE87H3UqDbL9OKNU1ps5e34q6jqaxfSfZNUZjK+pkTY+0LIqKKhsW+mbodk4Jrt5OFjmFWUu8pkRwZUybzSrkTVybzKaqyzG6KuH5ERETGwW48REREREQWisU+EREREZGFYrFPRERERGShWOwTEREREVko3qBL9B/tl45FnaFdAABajQaZj5IRd+oKQudtRIYySeB0FRv3Tcn02haElLtxOP3xDwbtdh4uGHx+Jfb2m4H4czcESkdERMbEK/tE+VCeuYbNTd7F1hYf4vjYpXBu5IXOqz8SOhaB+4aIiKg4WOwT5UObo0ZmQjIylEl4dOY6bm44BNeWdSGzkwsdrcLjviEiIio6FvtEhZC7VYZXnzbQqjXQabRCx6F/4b4hIiJ6MfbZJ8qHom1DvBm1HiKxGFK5NQDgyspdUGdmAwBqBLaC3/9eNZjG0dcD52auxc1fD5R73oqksH3Tec1HeHgsHJEbDgEAqjTyRsfvJ2J39ynQZKsEy20Oeu2YAys7OUQyKeLPXseZ6T9Cp+UvUURE5sysi/3w8HB8/vnnOHr0KHQ6Hbp27YqVK1fC19cXvXv3xqZNm4SOSGYqIfQWTk5cAYm1DF5926J6hya4tOB3/fAH+87hwb5z+s81erWE//Q3EPXHUQHSViyF7ZtzM9cicOcXuL/3LLKfpCFg/ns4++lPLPSLIHj4V1ClZQIAOv/4MbxeCcDdnacETkVERKVhtt14goOD0aZNG9y8eRMzZszAvHnzEBMTg8DAQKSlpcHPz0/oiCbp0JpAHFvbGyKRYfuf376E87/3hVQqyn/CCkaTlYPUe0ok34xG2KLNSI2OR+u57+Q7rm21Kmg9710cG70Umsyccs3p3rUZ+h5chOH3fsfgc9+jwQd9ynX5Qihs32Qok3B11R60mDkcdYd3x9M7cYg7GSFgYuHlpGTAyqFSnnYrx9y2Z78IPSv0RVIJJDIpdDpd+YUkIipnHZor8Oe3L+He/qHQXX4Hn73nJ3QkozDLYj8hIQFDhw6Fv78/Ll26hClTpmDcuHEIDg7GgwcPAIDFfgHemnEMjepUxtRRTfRt7w+ui+5t3DFs+jGo1fzhnp+wxZtRZ2gXODetbThAJELHFRMRseJPPLl+v1wzOTetjW7rpiLmyCXs6v4xwhZvQfNpb6DuiB7lmkNo+e2bG2v3w6muJxqP64/zQb8ImM40PI2KhXOTWhCJDU/5VZvVgVatQerdOH1bz62z8fqVn6FKy8T9PWfKOyoRUbmxk0tx7XYyPllyDnEJGULHMRqzLPYXLFiAJ0+eYO3atZDLnz+Bw9HREf7+/gBY7Bck9lEGPvzyFILG+MOvnjN8vRzxzZTWmPLNOdy891ToeCYr9a4S0QcvwH/a6wbtTScNQk5qBm78vK/cMzV8vw8eh91G6Lzf8PRWLKK2HMX1n/eh8bj+5Z5FSPnuG50ON389iJjgUGQnpggXzkTc+GU/bFwc0W7pWDg3qQX7mm7w7t8OzT55DVGbjyAn5fkPub8Hz8Zmv/cgkVtB0b6RgKmJiIxr38kYfLrsArb8fRfZORqh4xiNWRb7mzZtQocOHeDr65vvcDc3NygUCoO2zMxM1KlTB3Z2duUR0aRt+fsutvx9Fxu/6oSNX3XC8YtKfL/5utCxTN6V73fBvbMfFAENAQCuLevC541uODX5O0HyuLaqh9gjlwzaYo+Ewc7TFbbVqgiSSSj/3TcAAK0WOi3/UgUA6TGPsfeVz2DtWAndfpmGvoe/RpMJA3Hl+10ImbYmz/iarBw82HcONXq2FCAtERGVJbO7QVepVCI2NhZDhw7NM0yr1SIiIgLNmjXLM+zzzz9HzZo1oVQqi7U8tVpd7GnKg1pVupsNx30VgthDr0Gr1aHPuIOlyhETE1OqLOVFpVIXabyTk/Iv3hMu3MS6aoMBAFYOtuiwfAJOTlyB7Cdpxc5R3G2WX3a5qxMyE5IN2jLjn/wzrDIy4oR7o2xx17Es901plGTfFHW+Qnty7T6C35pf4HCZvS3EVlJkJ6ZAJBHDs3sLKE9fLceEhoy1L/JbDhVPee0bMmRux6qpHCelrZfKS1HqKYVCAam0+KW72RX76enpAADRf+8wBbBz507Ex8fn6cJz8eJF7N+/H19//TUGDhxYrOUplUp4enqWOK/R+AQBNu4lnnxY79oQQQRbGwmaN6iKvSeiSzSfyMhIeHq+XviIJuBL5+5wlzmUybzqvtUTclcntAoaadAe9ccxXFu954XTRkZGYkgxj6myzF4eiruOprJ+Jdk3RWEq6/ciVo626PLjFIhlUogkYsQdD8fN9cI9RtZY++K/zGHfmJry2jdkyNyOVZM5TkpZL5WXotRT0dHR8PDwKPa8za7Y9/T0hEQiwbFjxwza79+/j/HjxwMw7K+vVqvx3nvv4bvvvoOWz4sGANTzdsTCya0wceEZNKjlhB9nt0fjQduRmJwtdDSzEbF8ByKW7xA0Q2Z8MuQuTgZtNv98fnaFvyKL2nIUUVuOCh3DbKTHPMaeXlOFjkFERGXM7Ip9KysrjBgxAmvXrkW/fv3Qu3dvREdHY82aNXBzc0NsbKxBsb9o0SI0a9YMHTt2xNGjR4u9PIVCgejokl31NqZuo08i8kF6saeTSkXY8FVnHDobix+33YS1lQTdA9yx6vN2GPy/w8Wen6+vL4IPm972yU/IkPlIvyt8lyxfX19Eb/m5WNPklz3+3A1U7+yH8CVb9W3uXfyQFh0vaBceoPjraM77pihMZf3MibH2xX+Vxb6R2tpgwMlvcfjthUgMv11GyYQjrWSDQaeX48DrX+LJtbxPGSuvfUOGzO08YirHSUnrpfJWlHrqv/ejFpXZFfsAsGzZMshkMuzcuROHDx9GQEAAduzYgTlz5iAqKkp/425UVBR++OEHXLp0qZA5FkwqlZboTybGJpXJSjTdnDHN4eFWCYFj/gYAZOdoMGz6UZz7rS+Gv1IH63dHFTuHKW6f/MhkpnG4y2TFP6byy3519R703j0Xzaa9jjtbj6FqMx/UHxWI87OFf9RkcdfRnPdNUedLxWOsfZHfckqr8bj+SAy/g8Tw23CsUx2vHFiEszPX4tbGQ/px7Dxc0Dd4McK++QPXVu2BIqAhemz5HIeGzcPDY+H68ar61cHLu77E0dFL8GDv2WLl8O7fDu2XjsOel6cZFOkiiRgv75qLrKQUiCViyOxssa//TIO3I1dp7I3ee+bh+NhluL8nBFdX7UHLWW/hwNA5eZZTXvuGDJnbecRUjpMX1UuV5FLUqZHbNcpKJoaiqhxN61ZBWoYKt6NTyysiAOPWU2b5NB47OzusWrUKSqUSqampOHDgAAICAnDlyhU0btwY4n+eJX3y5Ek8evQIvr6+qFq1Kvr164f09HRUrVoVx48fF3gtyl+7Zm6YMrIx3p19AglJWfr28JtJmPV9KJZNbQNPRd4X75BpSgy/jcNvL4TnS83R99DXaPbJawhd8Dtu/ipcP2uiikZiLUPdt3ro7294GvUQF+asR6ugt2DvlXsVTiQWo8N3E/A4/A6urcq9p0cZchXXVu9BuyVjYF059ylxUrk1On43Ebe3Hi+w0FcENMTgc9/nO+zun6dwb08IOn43ERLr5wVO00mDYefpglOTvsPJSd/BoZYCjScMeL4ONlbouGIC7mw/gft7QgAAUZuPQBHQAE51TaDPNZGRtGhYFWF/DEDYHwNQ3bUSxr3eAGF/DMCPszsIHa1MmdeviS+QnJyMmJgY9O7dW982ZMgQvPTSS/rPISEhGDlyJMLCwuDi4iJETEGduvQIMv+1+Q6b/9NlzP/pcjknotKKCQ5FTHCo0DGIKiz3Ln6Q2FgZXJ2/sW4/PF7yR8cVE7C33ww0Hj8ATr6e2Nn1fwbThs7/HdU7NUXAwg9w9L2v0eqLtyGSiHF2Zsm7PpyZ/iP6BS+G/6dv4vysdajqVweNJwzAkVGLkPXPOydOf/wDOq36H2KPhCEx/DaafzYMYisZzs54vtysxBTEX7iJ2oM64uK8jSXOQ2TKjl1QQtTkJ6FjGJ1ZXtnPT0REBADDm3NtbW3h4eGh/+fi4gKRSAQPDw9YW1sLlJSIiCyFW0BDJF25C53G8AEQpyZ/D3svN3RYPgF+/3sVZ6atyXMvjValxvGx38Kjmz86LB+POkO74MT4ZVCnZ6GkVKkZOD5+Oeq/3QuePVqgw/LxiNwYbHBR4MH+84jachQdV0yAZ48WqDuiO06My7vchNBbULTji9WIzJ3FXNnPr9j/r86dOyMtrXjPRKeKa9idjXh8Kfcehms//oUH+87ph7l3bYZmU4ZCq9IgMeIOzn5m+VcGhOLzRjf4vNYVOp0WIVPXIPnGA/0widwKrb8YBbsabhBLxDg0bB7UmdlwblIL/p++CbFUgvjzN3BpwSZ49miB5jOGoVJ1Z2ysM1zANcrN3XPLLDj5eCBk6mrc3XkqzzhdfpoCa6fc7h3OfrWxt89neHL9PtouHg2H2tWhycrBqY9WIuNhYoHLeWnDp5DaWkMqt8bVH3bnWY6dpyvaLxsHaHXQ5Khw7INvkJOSgXbfjIG9lxuktja4s+04rq35q8Bl1BnSGU3/9yrSYx8DAA6+ORearJxC19WhVjW0XTQaOp0OSVfumsS9JiVhX8M13xviMxOScfGr39Fu8Wjc2xOS7z4GgOSb0bi6eg+aThyEKyt3If78zVJnij97HRHf70SXn6cg5U4cLsz5Nc845z9fh1cOLkKXn6fg8pJtSLgYmWecjLgk2Nd0LXUeIhKWxRT7Y8aMwZgxY4SOQRYkPfYx9g+ale8wv4+G4PA7i5DxMBEvbfwMlevXxJPreZ9aQaVj5WSHum/1wF+9P4V9TTcEzH8Pf78apB/u978huLPjJJSnrujbxDIp/Ke9jiOjFkGd8fxKZfz5G9jdfQr6HlpcruuQH222GkdGLULdET0KHOfIO4sAANbODui1dTaeXL+PGr1aQpOtwv4Bn8O5SS00/2wYToz9tsB5HH57IbQqNWR2crzy98I8BWfdET0QufEQ7mw9jkZj+6P2q51x/ae9CJm6GlqVGiKJGAOOf4ubGw5Ck5lTwFKAyA0HEbHiz2Kta4uZw3F+zq9IDL+N1l+OQrWOTRB33Py6EkpsrJCTkpGnXSQRw+e1LlClZ8K5cS1IK9nke8VeWskGtfq3hyo9E64t60IkFhvcOFvJvSr6H1vyfL5iMSTWMrwZtV7flhbzGDs7TzaYb9jiLbm/QKz40+CXr2fUmdm4snIXAua/h/ClW/MMBwBNdg4kNlaFbwQiMmkWU+wTlTW5W2X02h6EzEfJODvjJ31/VwB4cuMBrBwqIVP5BFIbK2Q/5V+MjMGlWR0oT1+FTq1Byu2HsK7iAIhEgE4HAFC0awiJtRR+/3sVD09cxuWl2+DSwheqjGx0+mEyJDZWuLTgdyRcjCz2m46NSafV5nn7cUG8X2mLe7tzb5p0qFVd/2jHxMt34Na63gun1f7zxk2prTWSI/M+0u3JzdzjGMh9qdaT2ASD6STWVkiNjocm68VvoKwztAs8ujfHg/3ncXXlLoNhBa2rvZcCiZfvAAASwqJQrV0jsyz2sxJT9H+B+bemkwbDoVY17O45FT1+n4FWQSNx+uMf8ozXZu470Ko12BM4Db13z0PjCQNweek2/fAMZRJ2vTRF/9nF3wfNPxtmcCFCq877ZlWdWpM7TKMpMLvun/383y5Iz1g72Rmc94jIPFlMn32isratzVjsHzgLDw6cR8vZbxkMu7vjJHr8PgMDTnyLp7djX9iVgkrOyskOOU+fPx9ZlZYJKwdb/ecqDbwQeyQM+wfPhnPjWlAENIStW2VUqV8Txz5cgpOTVqDtog+EiF5mag3sgDvbTwDI/SWzemc/ALk3hsqdHQudvtf2IPQ7/DWiD17MM0x5+irqjuiBfoe/hntnPzzYf14/rNPKyRgUshwJ52/qf7nKz4P95/Bnp8n4e3AQFAENUa194yKtV/LNaLh3bgoA8OjSLN+C2RwkRtzJ88Saqs180GTiQJyesgoptx/ixMQVqPNa7i9E/1azd2vUGtgBJ8Ytw9NbsTgz4yc0nTwYVRp768fRabRIvafU/8uIS4JOozFoS495bJR1c6pfE4nhd4wybyIqPyz2iQqQnZT7jN17u06jSiNvg2FtvnoXewKnYXu78YAOqNGrpRARLV7O03T9lWcAkNnJDbpMZCWlIPZoOKDT4eGxcFRuUBPZyWmIP38D6vQsZDxMhDojGzI7uRDxS82uhitEEjFS7+W+SCf28CWk3HmIXtuC4N61GZKK0HVs/8BZ2N5uAhqP6w+Zva3BsBafDUPovI3Y2fUjXPl+J5p/+oZ+2LEPl2Br67Fw79oMjr4FP/s5JyUDOq0WWpUa9/eeNShUX+R80C/wHd4dPTbNRE5qBjKUwr4IrqRiD1+CfU032FZ3BvDP4zNXTMDtbc8fn/ko5BqurdqDdotHw9o595neclcnBCz8AOFLt+FxWO69QXe2Hkf03xfQYfkEg0dnCkXRuj5iDuX9JZGIzAuLfaJ8SOXWEP3zvga3Ng30xdYzOq1Wf8U5KzEF1pXtyz1jRZAQegtubepDJBHD3kuB7KQUg6vMj85ch3OTWgAA5ya1kHI3Do9Db8GhVnWIJGLI7G0hs5dDlZYp1CqUSq2BHXBnxwmDtrDFW7B/0CxE/30BytNXAeT2+/73XzyA3L7dIknuMazOzIYmWwVN9n/6botEyPrnl9qsx8+PY7FVbg9PTVZO7rT/9Nev5F41T8Z//wKhCGiA1LtxRVq3jLgkHBm1CAde+wISaxnuF/MFUqbi6a1YxJ26gtqDOwEAWs4ZCZFUbPAYSwAIXfA7Mh+n6P/S1P7bcUi99wiXv91mMN7pT1bB2rES/D99s3xWoACKtg0hrWSDu7tPC5qDiEqPffaJ8uHo4462i0dDlZ4FrUqDkE9Wwb2LH6yc7HB3x0lcWrQFPbfOhiZHhZzkdFxevl3oyBYpJzkNt34LRuCOL6DTaXFm+o8G++HivA1ot/hDSGyskHwzGrGHc9+WfXP9AfTaHgSxVIoLc3JvZKzazAf+016HbXVn9Nj8Oa6u2q0fXwidf/wYzo28oc7IQlV/H5yftc5g3QDAu29bHBj6hX4a6yr26LLmY2jVGqTHPtY/Bcq7f3tIbaxw/ae9+nGtHG3R5acpgC73puWI5TugzVFD7uKEBh/0wcUvN+Dy0q0IWPgBdBotRFIxTk9ZBQB4af2nEEslEFtJcW9PCNKi4yGSStB17SfY3eMTg/VoOPoVuHf2g06rxeOw2/quQK3mjETYN1uRk5yW77rWGtwx9ylLWh3ubDuO5Jsvfk28Kbu0aDM6rZyEa6v3IOSfbfhf2hw1dnX7SP/54Otf5jteTnIatjR7v8BlKUOuYmuroj2MYl21wS8cHrXlKKK2HM13WKMx/RCx4s8X3phNROZBpNO9oDMmmayGA7bh2u1koWOgQW0nXN0xSOgYRfJnp0lIjowROgacfD3Q/9jSYk1jKtmLqrjraCrrV5J9UxTGXr9WX7yN8KXbkG3EmyldW9ZFlUbeuLF2v9GW8W/G2hf/VVb7xnfYS4g/d8MkjuPSklayQYP3++DKij/1N2v/W3ntGzJkKufJojKV48RU6qXCGLOe4pV9IiIzd25m/m/GLkvx52+WyTPgLVXkhkNCRygz6vQsXF6S/+M4icj8sM8+EREREZGFYrFPRERERGSh2I3HTNX2cBA6AgDTyVEU9l4KoSMAMJ0cpsRUtomxcpjK+pkTbjMiKgvmUqcYMyeLfTO1a3l3oSOYnW6/TBM6AhXA0veNpa8fEZGpYr3EbjxERERERBaLxT4RERERkYViNx4iIiKiCqD90rGoM7QLAECr0SDzUTLiTl1B6LyNyFAmCZyOjIVX9omIiIgqCOWZa9jc5F1sbfEhjo9dCudGXui8+qPCJySzxWKfiIiIqILQ5qiRmZCMDGUSHp25jpsbDsG1ZV3I7ORCRyMjYbFPREREVAHJ3SrDq08baNUa6DRaoeOQkbDPPhEREVEFoWjbEG9GrYdILIZUbg0AuLJyF9SZ2QCAGoGt4Pe/Vw2mcfT1wLmZaxF94AJe3jMXe3pORVZiCiRyK/Q79DUOv7MIyTcelPu6UNGw2CciIiKqIBJCb+HkxBWQWMvg1bctqndogksLftcPf7DvHB7sO6f/XKNXS/hPfwNRfxyFJjMH11btQcugkTgxbhn8PhqC+/vOstA3cezGQ0RERFRBaLJykHpPieSb0QhbtBmp0fFoPfedfMe1rVYFree9i2Ojl0KTmQMAuP7TPjj5eqL+uy+j5sutEf71H+UZn0qAxT4RERFRBRW2eDPqDO0C56a1DQeIROi4YiIiVvyJJ9fv65t1Wi3Oz1qH1l+MwoUv1uu7/5DpYrFPREREVEGl3lUi+uAF+E973aC96aRByEnNwI2f9+WZxr1bM2Qok1C5Xo3yikmlwGKfiIiIqAK78v0uuHf2gyKgIQDAtWVd+LzRDacmf5dnXKd6NVCjVyvsCZwGnze6wa6Ga3nHpWLiDbpEREREFcDJSXmLdwBIuHAT66oNBgBYOdiiw/IJODlxBbKfpOUZN2DB+zg/ax0ylEm4tHATWs99B8HDvzJqbiodFvtEREREBACo+1ZPyF2d0CpopEF71B/HoErPQtbjp4gJDgUA3P7jGHxe74oaL7fGg71nBUhLRcFin4iIiIgAABHLdyBi+Y4Ch9/aeMjg8/6Bs4wdiUqJxb6RBb81H6n3lELHMCv2Xgp0+2Vamc938lkgNqPMZ1ts7rbAktZCpzAt3DfFZ0rnFmN9Z6ni6Dv+IG7HpAgdAwBQ28MBu5Z3FzoGGYmpnDvL87zJYt/IUu8pkRwZI3QMQm4xeSdV6BSUH+6b4uO5hSzJ7ZgUXLudLHQMqgAq4rmTT+MhIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFYp+IiIiIyELxBl0iIiIion9pv3Qs6gztAgDQajTIfJSMuFNXEDpvIzKUSQKnKx4W+0RFcO/bkUg8/EvuB7EEVs7ucPAPhPuwuZA6OAsbjoiIiMqc8sw1HHv/G4gkYth7uaHNvHfRefVH2Nv3M6GjFQuLfaIismvQAbU+2QKdRo2M2xdxf8W7yHkcDZ/P/xI6WpFY0lUKIiIiY9PmqJGZkAwAyFAm4eaGQ2gz9x3I7ORQpWUKG64YWOwTFZFIagVZZQUAwKqqBzLvX8HD3z+HNjsTYmu5wOmKxlKuUhAREZUnuVtlePVpA61aA51GK3ScYuENukQlJLaWA1otdBq10FGK7NlVigxlEh6duY6bGw7BtWVdyOzM45cVIiKi8qJo2xBvRq3HsDsbMTRsDRQBDXFtzV9QZ2YDAGwVVTD4wkrYODsAACRyKww8tRxO9WoIGTsPsy72w8PD0a9fPzg6OsLBwQH9+/dHXFwc7O3t8dprrwkdjyxY5oNriN/7HSr5tobE1l7oOCVizlcpiIiIjC0h9BZ2vTQFewKnIeybPxB//iYuLfhdPzxDmYRrq/agZdBIAIDfR0Nwf99ZJN94IFDi/JltsR8cHIw2bdrg5s2bmDFjBubNm4eYmBgEBgYiLS0Nfn5+QkcslFub+ui6dioGn1+JkXFb0WTSIKEj0QukXjmKS0PtEPqqHNcmNIK1Wy14f/Sb0LGKpTRXKUztCsbFfqIX/ot4z0uQXKau+2+f4eVdcyESG57+qzT2xvD7v6NmnwCBkhGV3tovOuDg6l5CxyALocnKQeo9JZJvRiNs0WakRsej9dx3DMa5/tM+OPl6ov67L6Pmy60R/vUfAqUtmFn22U9ISMDQoUPh7++PQ4cOQS7P7YIwfPhweHt7A4BZFPtSWxsk34rGnR0n0GrO20LHoUJU8m0Nr0m/QCSWQlalOsQyK6EjFVtC6C2cnLgCEmsZvPq2RfUOTQq8SnFi3LI8VyleNKy8NVkXp/9/2o3TuDN/EOovCYWscrXcRrFEkFym7uSk79Dv8NdoPGEALi/dBgCQ2Fih44oJuLP9BO7vCRE4IRGRaQpbvBkDjn+Lm+sPIjH8NgBAp9Xi/Kx16LU9CIdHLdRfPDMlZnllf8GCBXjy5AnWrl2rL/QBwNHREf7+/gDMo9iPPXwJofN+w71dp6HNUQkdhwohtpLDplodWLt5mWWhD5T+KoUpXcGQVVbo/0ntqgAApA4uz9sdXQTLZsoy45Nx+uMf0HTyYDg3rQ0AaP7ZMIitZDg742eB0xERma7Uu0pEH7wA/2mvG7S7d2uGDGUSKptYX/1nzLLY37RpEzp06ABfX998h7u5uUGhyH1qysiRI2FlZQU7Ozv9v/3795dnXCKTFbZ4M+oM7aIv+oDnVylafzEKF75Yb3CV4kXDyHw82H8eUVuOouOKCfDs0QJ1R3THiXHLoE7PEjoaEZFJu/L9Lrh39oMioCEAwKleDdTo1Qp7AqfB541usKvhKnDCvMyuG49SqURsbCyGDh2aZ5hWq0VERASaNWtm0P7+++9jxYoVJVqeWq2GUqks0bQAoFKZz5NaTIVKpUZMTIwR5usGQFbm8y1+DhViYh4VcxrjHEf/vkpx8PUv9e3/vkrxYN85g2leNOzfeYuzD8153wiltMfE+c/X4ZWDi9Dl5ym4vGQbEi5GliqLMb6z5YHn6OIzxv5Wq0znr9tqlcokj2dzO1ZN9bxQ1O14ctJ3+bYnXLiJddUG6z8HLHgf52etQ4YyCZcWbkLrue8gePhXRcpR3O2jUCgglRa/dDe7Yj89PR0AIBKJ8gzbuXMn4uPjy7QLj1KphKenZ4mn/9K5O9xlDmWWpyKIjIzEkFJs84I0WH4F8hoNSzSt18R1ZZYjMjISnj0bFWsaYx5HV77fhd6750IR0BDKkKsGVyle3j0Xt7cdR9qDeAB44bB/K+4+LM2+KUsl2TdCKe0xoc7MxpWVuxAw/z2EL91aqizG+s6Wh7L8bknkVui5ZRacfDwQMnU17u48lWcczx4t0GTCQGhUakSuP4g720+gql8dtJg5HAAgtbOBSCTC7h6fFLgc56a10WrO2xCJRbj+8z7c3XHSYHjTyYNRrX1jAIC9twJXvtuJ6z/tRdvFo+HxUnNE/30eIVNXG0yjaNsQvbYFYXOTd/UvESqIUfa3TxBg41628yyhyMhIeHq+XviI5czc6glTPS+U5Xb0efMlZD1+ipjgUADA7T+Owef1rqjxcms82Hv2hdOWZPtER0fDw8Oj2DnNrtj39PSERCLBsWPHDNrv37+P8ePHA8jbX3/jxo347bff4ObmhmHDhmHq1Kkl+s2IyJyVxVWKkl7BINOk++cKFx+9Wja02WocGbUIdUf0yH8EkQjNP3sTewKnQ5Odg17bgxB98CIeh0Vh/6BZAIAG7/WGxObF9wS1/mIUjn24BFmPn6L3nnmI/vsC1BnPu2CFL9mK8CW5v8C9cmAh7v91BgAQtngL7mw7Ae/+7fLMs+EHr+BxWFRJVpuowrq18RBubTxk0LZ/4CyB0hTM7CpeKysrjBgxAmvXrkW/fv3Qu3dvREdHY82aNXBzc0NsbKxBsT9hwgQsXLgQVatWRWhoKF5//XVkZWXhiy++KNLyFAoFoqOjS5w3ZMh8pN8teTegisjX1xfRW8r+RsHx19wQbQJdkn19ffF3MY+p8jqOXnSVwrqyfZGvYBR3H5rzvhGKKZ1bjPWdLQ9luR11Wu0Lr4rbVLFH1uMUfWH+NOohXPx98PBYuH4c7wHtcez9bwqch8RaBrGVFOmxjwEA8RduwrlpLTwKuZZnXCdfD+Q8TUeGMglA7tO2HLyr5RnP65UAxB4Ng1cRH7tqjP3dbfRJRD5IL9N5lpSvry+CD5veecCUvvNFYarnBVPZjiXZPs/uRy0usyv2AWDZsmWQyWTYuXMnDh8+jICAAOzYsQNz5sxBVFSUwY27z57OAwAtWrRAUFAQZs2aVeRiXyqVluhPJs/IZAVvYqmtDRy8c3ecWCaF3MUJVRp6QZWehdR7wh+IQpHJSrfNC5zvLQAmUFDKZLJir9+LjqOyVNhViqJewSjuPjTnfSOU8jomisJY39nyUJ7bMSsxBTZVHSB3dYIqPQturesj7vhl/XCHWtWgVamRFpNQ4DysnOyQ8/R5UZz9NB3WTnb5jltrUEfc+U8Xn/8SSSXwefMlBA//qsjFvjH2t1Qm/D07z0hN9DxgSt/5ojDV84KpbMfy3D6mscbFZGdnh1WrVmHVqlUG7VeuXEHjxo0hFhf8kCGxWAydTmfsiEVStWlt9NoepP9cf1Qg6o8KhPL0Vf2fdImIyHKETF2Njt9NhDozB8k3o5HxKEk/rNbADriz/cXFec7TdFg5VtJ/tnKohOzktHzHrflya/zVe/oL51d3WHfc2XYcWjO7+ZOIis4si/38JCcnIyYmBr179zZo37x5M3r16gUHBwdEREQgKCgIr776qkApDSlDrhr0lSaikrFv3BnNd5rGL/HmJGrLUURtOSp0jArl0Znr+PvVIEhtbdDlp4+RcPGWfphX37bY13+m/rO0kg3EEjFyUjL0bZqsHGhz1LBVVEFWUgpcW/ji4twNeZbj2qoekm/FGEybH6d6nrD3UqDWgPaoXL8GOn4/EX8PmQOYyEWx4np75gmhIxCZHIsp9iMiIgDkvTn3+++/x+jRo6FSqVCtWjUMHz4c06e/+EoHVVzpURcRu346dGoV7Oq3g/uw54+jfPj7bCQGr4WNR334zM59V4NOp8OD795HVuxNiK3kqDnuR1i5mN7TB4iofHT+8WM4N/KGOiMLVf19cH7WOrh38YOVkx3u7jiJFrNGwLlxLWjVGoR+9Zv+inrVZj5Ivf8I2Ump+nl5928PqY0Vrv+012AZ5z5fi06r/geRWISrq3ZDnZ4FuYsTGnzQBxe/zC388/srQdPJg+HZqyXkVZ3QY/PnOPDaFzgzbY1+eK9tQTg+5luzLfSJjMWhVjX0P7oE+/rPRELorTzDe20LwtOo2DxPuTIVFl/s//epPUQF0apy8HDDZ6g9bTsk8rx9YF16fgDnLiPw4Icx+ranZ3dCJLNG3a+O5/6i8Os0eH+0sTxjE5EJOfru4jxtsUfC9P+/EPRrvtM9vnQrz5OtKtfzRPjSbXnHDYvCvn4zDNoyE5L1hT4AgyL+mX8/pSc/7D5KlL+mkwdDmc9N8ADg8VJzqNIyyzlR8ZjlG3TzM2bMGOh0OrRp00boKGSm0m+GQGxTCXcXv4bImd2QdiPEYLisSjVAZPiVyXoYCds6LQAAtrX9kXqNf0ImorJxbuZaZCemCB2DqEKr2swHmfHJyIhLzDtQJEK9t3vhxrr95R+sGCym2CcqLVXSQ2Teuwzvj36H14R1uP/9+4VOI6/ZGCmX/oZOp0PKpb+hfpr3BVNERERknppMHIiIFTvyHVZnSGfc33sWmizTeQN0fiymGw9RaUnsqsCufjtIbO1z/1lXgiYjBRLbgt+059g8EOk3zyByRhfYejWF3KtJOSYmIiIqPidfDwQs+gA6rQ46tQanPlpp8Db0/N70DACt574D5ya1IJKIEbZos0EXNUvk0c0fieG3kf0k7xOvJNYy1BrYAQff+BJureoLkK7oWOwT/aOSb2vEbQqCTqOGNiu90EL/mepv5D4+NSU8GCKZtbFjEhERlUpWYgoODfsKqtQMuHfxQ9PJg3Fq8ve5Awt407OtojIcfTyw95XPIHdxQrcN0y2+2K/SyAuKtg3h2rIunOrVgEPt6jjyziJkxifDroYrrBwr4aX102HlZAe5qxNqv9oJt/8wvXtFWeybAamtDQac/BaH316IxPDbQscpNWklGww6vRwHXv8ST67dFzqOntTOCS69RuPmZ52hU6vg8fYiPA3dD01qEqp0egMJf69G4pFfkRVzA5EzX4LXpF8hllnh9oLBEImlsHKpAc/3lwu9GkRERC+U9a97QbQqDXQarf5zQW96fnzpFjTZORBJxLBytDV4cpSluvztdlz+djsAoP3Ssbj56wFUaegFq3a5T9fa02sqAEAR0BDe/duZZKEPsNg3C43H9Udi+B0kht+GY53qeOXAIpydudbgbaZ2Hi7oG7wYYd/8gWur9kAR0BA9tnyOQ8PmGbyKvapfHby860scHb0ED/aeLVYO7/7t0H7pOOx5eZpBkS6SiPHyrrnISkqBWCKGzM4W+/rPhE77/ORRpbE3eu+Zh+Njl+H+nhBcXbUHLWe9hQND55Riy5Q9564j4Nx1RL7DXHq+D5eeefvx15171MipiIiIyp7Exgp+U4YgZOrzpzcV9KbnnJQMpD2Ix8BTyyGVW+HYh0uFCy6Ak5O+K3CYMuQqlCFXyzFN8fAGXRMnsZah7ls9cHP9AQC5v2FfmLMerYLegr2XAgAgEovR4bsJeBx+B9dW7QGQe+BdW70H7ZaMgXXl3MdISuXW6PjdRNzeerzAQl8R0BCDz32f77C7f57CvT0h6PjdREisn7/avOmkwbDzdMGpSd/h5KTv4FBLgcYTBjxfBxsrdFwxAXe2n8D9PblPuInafASKgAZwqstn0hMREZU3kUSMjt9PxNWVu5B844HBsGdveu60crL+Tc/VOzWF3NUJ2wLGYUenyWj1xSiIJCwjzQH3kolz7+IHiY2VwdX5G+v249GZ6+i4YgJEEjEaTxgAJ19PnJxo2IUkdP7vyE5KRcDCDwAArb54GyKJGGdn/lziPGem/whZJRv4f/omgNy/FDSeMACnJn+PrMQUZMYn4/THP6Dp5MFwblobAND8s2EQW8lwdsbz5WYlpiD+wk3UHtSxxFmIiIioZNp9/SEeHg3Hg/3n8wx79qbnY6OXQGprnfumZxGQnZwG6HRQpWVCYiWFWCoRIDkVF7vxmDi3gIZIunLXoD8dAJya/D36HfkaHZZPgFefNjgxfjky4pIMxtGq1Dg+9lv02TcfHZaPh3f/9tg/8HOo07NKnEeVmoHj45ej1x+zoDx1BS1mDkfkxmDEBIfqx3mw/zyithxFxxUTcOGL9ag7ojv2D5yVZ7kJobegaNeoxFmIiIio+Ny7+MGrb1vYebrCu187JF29i9gjYS9803Pc8QjU6t8egX9+AYm1DNd/2gdNtmk/cpJysdg3cfY1XPMU8cA/b0v86ne0Wzwa9/aE4O7OU/lOn3wzGldX70HTiYNwZeUuxJ+/WepM8WevI+L7nejy8xSk3InDhTl53wh5/vN1eOXgInT5eQouL9mGhIuRecbJiEuCfU3XUucpKnfbclvUC5lKDlNiKtvEVHIUxbNufKbAlLKQeartUfiTz8qLKWUxltgjYdhQ680Ch+f3pmedVvvCfuvmwlTOV+WZg8W+iZPYWCEnJSNPu0gihs9rXaBKz4Rz41qQVrLJ94q9tJINavVvD1V6Jlxb1oVILDa4cbaSe1X0P7bk+XzFYkisZXgzar2+LS3mMXZ2nmww37DFW3J/gVjxJzRZOXmWq87MxpWVuxAw/z2EL83/9eya7BxIbKwK3whlZEnrclsUFRP3TfF1+2Wa0BGIysyu5d2FjkAVREU8d7LYN3FZiSmwdrLL09500mA41KqG3T2nosfvM9AqaCROf/xDnvHazH0HWrUGewKnoffueWg8YQAuL92mH56hTMKul6boP7v4+6D5Z8Owf9AsfZtWrc4zX51akztMoykwu06VO91/uyA9Y+1kZ/D4LyIiIiIqW7xB18QlRtzJ88Saqs180GTiQJyesgoptx/ixMQVqPNaF3h0b24wXs3erVFrYAecGLcMT2/F4syMn9B08mBUaeytH0en0SL1nlL/LyMuCTqNxqAtPeaxUdbNqX5NJIbfMcq8qWgkciu8vHsu3rjxC7z7tcszvP3SsXjlwEL02haEgIV5HztKREREpo3FvomLPXwJ9jXdYFvdGcA/j89cMQG3tz1/fOajkGu4tmoP2i0eDWvn3L6GclcnBCz8AOFLt+FxWBQA4M7W44j++wI6LJ9g8OhMoSha10fMoYtCx6jQtNlqHBm1CNfW/FXgOGemrcH+QbMQ8snqckxGREREZYHFvol7eisWcaeuoPbgTgCAlnNGQiQVGzzGEgBCF/yOzMcpaLso9zGb7b8dh9R7j3D5220G453+ZBWsHSvpH50pFEXbhpBWssHd3acFzVHR6bRaZCYkv3CcVl+MQq/tQXDv4lcumYiIiKjssM++Gbi0aDM6rZyEa6v3IGTKqnzH0eaosavbR/rPB1//Mt/xcpLTsKVZwd0xlCFXsbXVmCLlWldt8AuHR205iqgtR/Md1mhMP0Ss+BOazLw395LpOD/nV2QnpcKmqiN6bZuNhIuR+d4wTkRERKaJV/bNQPzZ6wj/5g/Y1yi/x1Qak7SSDeIvRuLa6j1CR6FCZCelAgCyHj/F4/A7sPeuJnAiIiIiKg5e2TcTkRsOCR2hzKjTs3B5Sf6P4yTTIrO3hSo1AxIbK1Rp6IX0mAShIxEREVExsNgnquA6//gxnBt5Q52Rhar+Pnh49PlbFDutnASZvS3EMgmu/rCLj0olIiIyMyz2iSq4o+8uLnDYoWHzyjEJERERlTX22SciIiIislAs9omIiIiILBSLfSIiIiIiC8U++2Zu2J2NeHwp9w251378Cw/2nTMY3n7pWFRuUBOq1Ew8vR2LkE9Ww87DBR2/nwStWg2RRIIz09bgyfX7BS7jpQ2fQmprDancGld/2I27O08ZDJfYWKHdN2NQqbozUu8/wumPf4BWpS50OiIiIiIyLhb7Zi499jH2D5r1wnHOTFuDhNBbz6eJS8TefjMAnQ6Kdo3QZMJAHPtwSYHTH357IbQqNWR2crzy98I8RbvPa13x5Pp9HB+zFM2mvY5aA9ojasvRQqcjIiIiIuNiNx4zJ3erjF7bg9Bp5WTYODvkO06rL0ah1/YguHfxAwDoNFpApwMAWNnLkXTt3guXoVWpAQBSW2skR0bnGe7Wuj6iD14EAETvPw+3gAZFmo6IiIiIjItX9s3ctjZjkZ2UCu8B7dFy9ls4MX65wfDzc35FdlIqbKo6ote22Ui4GImclAxUaeiFNvPfQ6XqVXHknUWFLqfX9iA4+Xrg4rzf8gyzqmyHnKdpAIDsp2mwdrIv0nTlbfJZIDZD6BSAuy2wpLXQKYQX/NZ8pN5TCh2jQPZeCnT7ZZrQMYiIiEqFxb6Zy05KBQDc23UaTSYMLHB41uOneBx+B/be1ZAYfhtJV+9h7yufoUpjbwQseB9/vTz9hcvZP3AWrBwroc+++bi3OwSq1OdVc05yGqwcKiEjLglWDpWQnZxapOnKW2wGcCe18PGofKTeUyI5MkboGERERBaN3XjMmFRuDZE4dxe6tWmQ71VSmb0tgNybaKs09EJ6TALEVs9/x1OlZECTmZM7v0o2sHKwNZheJBZDJMldhjozG5psFTTZOQbjPDpzHR7d/AEAnj1a4FHItSJNR0RERETGxSv7ZszRxx1tF4+GKj0LWpUGIZ+sAgC4d/GDlZMd7u44iU4rJ0FmbwuxTIKrP+xCVmIKFO0awe/jIdBptBCJRDg3ex0AwLt/e0htrHD9p736ZVg52qLLT1MAHSCWSRGxfAe0OWrIXZzQ4IM+uPjlBtzafBjtl4xFrx1zkB6TgMtLtxU4HRERERGVHxb7Zizx8h3s7vFJnvbYI2H6/x8aNi/PcOWpK9h/6kqe9sr1PBG+dJtBW/aTNOwfmPdpP5kJybj45QYAgCYzB8dGLynSdERERERUfljsk965mWuFjkBEREREZYh99onycfOzzri3/N087dmP7uFiPxHSrp0UIBURERFR8bDYJyIiIiKyUCz2iYiIiIgsFPvsE5HZEMukGPFgU4mnX1dtcBmmISIiMn0s9olK4e7St5ASug9SR1c0XJ73CUdUthRtG2JHp0l4ypdxERERFYlZd+MJDw9Hv3794OjoCAcHB/Tv3x9xcXGwt7fHa6+9JnQ8qgCqvjQKPrP2Cx2jwnD0cWehT0REVAxme2U/ODgYffr0Qc2aNTFjxgzI5XKsW7cOgYGBSEtLg5+fn9ARC+XetRmaT38Djj4eyIx/gms/7cW1VXuEjkUAJLaO0GQ8zdOuSU8GAIhkNgAA+0adkP3oXjkmM+TWpj4aftAXVRp5wc7DBaELfsfl/7wrgfIafO57bG01RugYZOJ4jiZzwWOVXsQsi/2EhAQMHToU/v7+OHToEORyOQBg+PDh8Pb2BgCTL/adm9ZGt3VTceWHXTg2ZilcmvkgYMH70GTm4OavB4SOV+HZeNTDk1N/QKfRQCSR6NvTb50DxBJYV6sjYLrnpLY2SL4VjTs7TqDVnLeFjmNUjnWq42lUrNAxqILgOZrMBY9VKoxZduNZsGABnjx5grVr1+oLfQBwdHSEv78/ANMv9hu+3wePw24jdN5veHorFlFbjuL6z/vQeFx/oaMRAJfAMVAnP8K9ZW8jPeoisuNuI+n473i4cSaqdnsbUjsnoSMCAGIPX0LovN9wb9dpaHNUQscxKreAhlCevlqqebQMGom+BxdB7lYZfQ8uQqcfJpdROrI0PEeTueCxSoUxy2J/06ZN6NChA3x9ffMd7ubmBoVCof/8119/wd/fH5UqVYJCocCiRYvKK2qBXFvVQ+yRSwZtsUfCYOfpCttqVQRKRc9Yu9ZE3QWnoUl/gttfvoJrE5sgbus8uA2Yghqjvxc6XoUksZZBm6PWf+6xZRZ67ZgDiEQG43VdOxV99i+ASCr57yxwftY67Oo+BZmPnmBX9yk4NnqJ0XOTeeI5mswFj1UqjNl141EqlYiNjcXQoUPzDNNqtYiIiECzZs30bQcOHMD777+PX3/9FZ06dUJGRgYePHhQ5OWp1WoolcoS51Wp1Pm2y12dkJmQbNCWGf/kn2GVkRGXVOJlmjuVSo2YmLK/CVOlcgMgK/L4tt5NUWfGbiPkUCEm5lExp8n/ODJVRdmHha2TRG4FTWYOAEBmJ0fO03SD4ScnLke/4K/ReFx/RCzfAQDwHd4d1Ts1we4eU6BTa0qxBsY7Dsm08BxdfPxuCMPcjlUeJ2VPoVBAKi1+6W52xX56eu4PfNF/ruYBwM6dOxEfH2/QhWfmzJmYOXMmunXrBgBwcHBAo0aNirw8pVIJT0/PEuf90rk73GUOJZ6+IoqMjMSQUmzzgjRYfgXyGg3LdJ63F7yKtOsnoU55jMujPKAY/ClcX37xjZ+RkZHw7Fn0YxAwv+OoKPuwoHUSScRo/umb0OSocGlB7jP1q3dqiofHLxuMlxGXhJBpa9Bh+XjEHgmDOjMbLWe/hQtz1uNp1MNyWQcyf+b23TIF/G4Iw9yOVR4nZS86OhoeHh7Fns7sin1PT09IJBIcO3bMoP3+/fsYP348gOf99dPT03H+/HkEBgaiXr16ePLkCVq3bo1vv/1WfyOvUDLjkyF3cTJos/nn87PfyMn01Z76h9ARLI5Oo8WlxZvRc/MsXEJusW+rqILMR3m/F/d2nYZnjxbo+N0EqDNz8OjMddxYx0ehUunxHE3mgscqFcbsin0rKyuMGDECa9euRb9+/dC7d29ER0djzZo1cHNzQ2xsrL7Yf/LkCXQ6HbZt24b9+/fD1dUVkyZNwsCBAxEaGprvXwf+S6FQIDo6usR5Q4bMR/rdvN2A4s/dQPXOfghfslXf5t7FD2nR8RX6z8MA4Ovri+gtP5f5fMdfc0N0VpnPtth8fX3xdzGPqYKOI1NVlH34onXSZOYgK/EpKrlXRXrsY+i02gLnc/bTH/HqpdWAVofg4V+VKve/Ges4JNPCc3Tx8bshDHM7VnmclL1/349aHGZX7APAsmXLIJPJsHPnThw+fBgBAQHYsWMH5syZg6ioKP2Nu/b29gCAiRMnwsvLCwAwb948uLi4IDo6GjVq1Ch0WVKptER/MnlGJst/E19dvQe9d89Fs2mv487WY6jazAf1RwXi/OxfSrwsSyGTlW6bFzjfWwBMoNiXyWTFXr+CjiOprQ0cvHO//GKZFHIXJ1Rp6AVVehZS7wn3y0FR9mFB6/RM9MGL8HipORIv38HjsNsFjldrUEeIRCKI5TI4N6mFmODQQvMlF+HFXMY6Dsm08BxdfPxuCMPcjlUeJ6bDLIt9Ozs7rFq1CqtWrTJov3LlCho3bgyxOPchQ46OjqhZs2aRruCXt8Tw2zj89kL4T38DjUb3RWZCMkIX/M5n4lKxVG1aG722B+k/1x8ViPqjAqE8fRX7B80SMFnpxRy6iHbfjIFILMKNtfl3zXH0cUeLmcNxduZaOPl6oO3XH2Jn1/8hOyn1hfM+NGyeMSKTBeE5mswFj1UqjFkW+/lJTk5GTEwMevfubdA+evRofPvtt+jRowdcXFwwc+ZMNG/evEhX9Y0tJji0SFchiQqiDLmKddUGCx3DKDLjkyGzk0Mqt853uEgqQYcVE/Dw+GXc2ngIEmsZqndsgoCFH+Dou4vLOS1ZIp6jyVzwWKUXMcvn7OcnIiICQN6XaX3yyScIDAyEv78/3N3d8fDhQ2zfvl2AhERUXA+PhSP1fv6PKW32yVBUquaM0x+tBABoslU4MW4ZPLs3R+1XO5VnTCIiIpNl8cW+WCzGggULkJCQgMTEROzcudMkruqT6dNmZ+DGJwEIe8MJScc35Rn+8PfZiHi3Jm7N7iVAuooh8rdgxB4Jy9Pu2qoeGn3YD6c+WomsxBR9e9LVewhbvAWtvxiFSu5VyzEpERGRabKYYn/MmDHQ6XRo06aN0FHIQoik1qg9fQdcX5mU73CXnh/A98sj5Ruqgsl89ATqjLx3Vcefu4FfPYci5uDFPMMilu/Ab/XeQnrs4/KISEREZNIsptgnKmsiiQSyygU/5kpWpRog4leIiIiITBcrFSIiIiIiC8Vin4iIiIjIQrHYJyIiIiKyUBbznH0iY7g9fxAy7lyC2KYS0iPPwsG/JzSpSajS6Q0k/L0aiUd+RVbMDUTOfAlek36FlXN1oSMTERER6bHYJ3qB2tO2FTjMpef7cOn5fjmmISIiIioeduMhIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFPvtGZu9V8EuZKH/G2mbutkaZbbGVJIe5HUdFyWvq62Tq+ahscD8XH7eZMMxtu5tbXksm0ul0OqFDEBERERFR2WM3HiIiIiIiC8Vin4iIiIjIQrHYJyIiIiKyUCz2iYiIiIgsFIt9IiIiIiILxWKfiIiIiMhCsdgnIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFYp+IiIiIyEKx2CciIiIislAs9omIiIiILBSLfSIiIiIiC8Vin4iIiIjIQrHYJyIiIiKyUCz2iYiIiIgsFIt9IiIiIiILxWKfiIiIiMhCsdgnIiIiIrJQLPaJiIiIiCwUi30iIiIiIgvFYp+IiIiIyEL9H6qE7UDbyJXrAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 1, @@ -36,9 +36,9 @@ "from qiskit.circuit.random import random_circuit\n", "from qiskit.quantum_info import PauliList\n", "\n", - "circuit = random_circuit(7, 6, max_operands=2)\n", + "circuit = random_circuit(7, 6, max_operands=2, seed=54)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", - "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\", fold=-1)" + "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")" ] }, { @@ -53,11 +53,18 @@ "execution_count": 2, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CircuitElement(name='xx_plus_yy', params=[0.6672202688920147, 0.5661694284168217], qubits=[4, 1], gamma=2.524280188101553) 2\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 2, @@ -92,9 +99,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 3, @@ -126,7 +133,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 80.73369279941987\n" + "Sampling overhead: 42953.992531378535\n" ] } ], @@ -147,7 +154,7 @@ { "data": { "text/plain": [ - "{0: PauliList(['III', 'III', 'IIZ']), 1: PauliList(['ZIII', 'IIZI', 'IIII'])}" + "{0: PauliList(['III', 'IZI', 'IIZ']), 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, "execution_count": 5, @@ -166,9 +173,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAADDCAYAAABKxGT4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMz0lEQVR4nO3deVhU1RsH8O8MM8Cwi+xIggv+REnEFRUXVMw0d8G0jBKtXFCjRU1TcUlNU3Apl9LUXDOzTM0Ad80lwXBJxAWRxR1l32Z+f5CjI+AMCNyZ4ft5Hp4H7j137nvvHc6dd86554gUCoUCREREREREekQsdABERERERESVjYkOERERERHpHSY6RERERESkd5joEBERERGR3mGiQ0REREREeoeJDhERERER6R0mOkREREREpHeY6BARERERkd5hokNERERERHqHiQ4REREREekdJjpERERERKR3mOgQEREREZHeYaJDRERERER6h4kOERERERHpHSY6RERERESkd5joEBERERGR3mGiQ0REREREeoeJDhERERER6R0mOkREREREpHeY6BARERERkd5hokNERERERHqHiQ4REREREekdJjpERERERKR3mOgQEREREZHeYaJDRERERER6h4kOERERERHpHSY6RERERESkd5joEBERERGR3mGiQ0REREREeoeJDhFRDdGtWzcEBQUJHcYLHTlyBAMHDkSdOnUgk8nQsGFDzJgxA3l5eUKHRkREOkYidABERKQ/8vPzYWhoWOHtjx07hvr162P8+PFwcXFBTEwMPvjgA9y+fRvffPNNJUZKRET6ji06REQ6ZPny5fDw8ICRkRHs7OwwcOBAAICrqytmz56tUjY4OBidO3cGAAQFBSEqKgo//PADRCIRRCIRDh48qHZ/hYWFmDlzJurXrw8jIyM4Oztj3LhxyvUikQgREREYOnQoLC0t8fbbbyMoKEi5j2d/ZsyYoXZ/kyZNwoIFC9CxY0e4ublhwIABmDRpErZt26bxOSIiIgLYokNVKOqdeci4kSZ0GDrF3NUBXX+YJHQYpKWmT5+ORYsWYd68efD390dmZib27t2r0bbh4eG4du0aHB0dER4eDgCwtrZWu92IESOwd+9eLFq0CO3atcPdu3dx4sQJlTIzZ87EzJkzMWvWLMjlctjZ2WHevHnK9b/++itGjx4NX1/fchztU+np6TA1Na3QtkRUbOJJIDlb6CgAZxNgcRuho9CMvp0zfTseTTDRoSqTcSMN6fG3hA6DSC9kZWVhwYIFmDVrFsaOHatc7u3trdH2lpaWMDQ0hEwmg4ODg0bbJCQkYP369di+fTsGDRoEAKhfvz7atm2rUq5fv34qMT3ZHwDExsbio48+QkREBLp27arRfp916dIlLFmyBHPnzi33tkT0VHI2cC1D6Ch0i76dM307Hk2w6xoRkQ64cOECcnNz4e/vX237PHv2LACo3Wfr1q1LXZ6amoo33ngDwcHBGD16dLn3f+XKFfj7+2PIkCElEikiIiJ1mOgQEekBsVgMhUKhsqygoKBa9l1at7Ls7Gz06dMHzZs3x9dff13u1zx//jw6duyIXr16YeXKlZURJhER1TBMdIiIdICHhweMjY2xf//+Utfb2dkhJSVFZVlMTIzK34aGhigqKtJ4n0+6xZW1z7IoFAoMHz4chYWF2Lx5M8Ti8t1qTp8+jU6dOiEgIADffPMNRCJRubYnIiIC+IwOEZFOMDMzQ2hoKGbMmAGZTIbu3bsjJycHe/bsweTJk9GtWzesWLEC/fv3R926dfHtt98iMTFRZcABNzc3HDhwAFevXoWlpSUsLS0hlUrL3GeDBg0wbNgwjB49Grm5ufDx8cGDBw9w/PhxjB8/vsztZs6ciejoaPz555/IyMhARkaG8hjMzMxeeJyHDx9G7969MWjQIEyePBm3b99WrtP02SIiIiKALTpERDpj1qxZmDNnDiIiItC0aVP4+/srn6P57LPP0KtXLwQGBsLX1xeWlpYYPHiwyvahoaGwsbFBs2bNYGtri2PHjqnd59q1a/H+++9j6tSpaNy4Mfr374/r16+/cJuDBw/i4cOHaNmyJRwdHZU/CxcuVLu/77//HhkZGVi7dq3Kto6Ojmq3JSIiepZI8XynbqJK8kunCRx1rZys3Oug36ElQodBRER6JuCAdoy4Vc8c2NZF6Cg0o2/nTN+ORxNs0SEiIiIiIr3DRIeIqIaaO3eu8rmZ0n6qwov2x7lyiIioMun9YARyuRzh4eFYuXIlbty4AVtbWwQEBCAsLIwzbRNRjfbBBx8gICAA//zzT6nrT58+rfw9Pz8f69atQ1BQEAwNDV/4uq1atSpzXWxsbJnrnh04gYiI6GXpfaIzceJEREREoH///ggNDcWlS5cQERGBmJgYREZGlnvYUyIifWFtbQ1ra2s8fPhQbdn8/HysWbMGQ4cOVZvovEiDBg0qvC0RaZ+4ka7wXH1D6DB0ir6dM20+Hr1OdC5cuIClS5diwIAB2LFjh3K5m5sbQkJCsGXLFgwdOlTACGsm+7aN0eT9PrBu6gqzOrY4O38z/lmyQ/2GRC9BoVAg9WgcErYcQFbKfRgYG8Kp06toGNgFRrXMhQ6PqNzSryTj8vr9eHgpESIRUMvDFY2G+8OyvpPQoWmt3PuPcWVLNFKPxKEovwBmzjZo8KYfHHyacL4mIj2ks4nOuXPn8MUXX+DgwYNQKBTw8/PDN998A3d3d/Tq1QtbtmzB5s2boVAoMGHCBJVtR44ciUmTJmHjxo1MdAQgMTFG+pUkXNt5BK3D3hU6HKoBstMeIOqdebj/z7XiBSIRoFAg5WAszs7bDJ95I9FwiJ+wQRJpqCi/AH9NWo0rm6OLF/z3+Tz16HlcXLUb7m93R9s5IyCW6uwtvkpcXr8fJ6d9D3l+4X/nTITbCgWu/nQYti3c4bf2U8hsrQSOUnckrZmIjPMHUPAgBRcneMHYqRHqfbpV6LC0mr6dM104Hp2sBaOiotC7d2/UrVsXU6dOhUwmw7p169CzZ09kZmbCy8sLQHH/crFYjNatW6tsb2xsDC8vL5X+51R9kqNjkBxdPGN7y6lvCRwN6bu8R1nYN2gGHl9NebrwmVH15fkFODZxBQwMpag3wFeACHWDRCJBnz59IJHo5G1DbygUChwP/QZXfzr8zELVMvEb/oSiSI72iz6s3uC02JUt0Tjx2SplUlh8zp6euLt/x+OPgDD0+m0OpGYyIULUGn/3fXHLlqFdXXiuvgGX4MUAirsteSyJrYbItJe+nTN5Xg5Sf5qLh0e2IP/+LYgNZTByqI/and+G3RshynK6cDw6d8e6e/cuAgMD4e3tjcjISMhkxRXS22+/DTc3NwBQJjopKSmwsbGBkZFRiddxdnbG8ePHkZ+f/1L9zYlIu11et081yXmeAoAIODVjHVzf8OG34GUwNjbG1KlThQ6jxrsXm6Ca5JThyqYo/O/d11C7qVs1RKXdCnPycHrGD8VJzgtmDkz/9ybif4xEk/ffqLbYtNGr61KVv2f+exzX5g1E48VnIa3136S9YgOBItNe+nbObn77ITLiDsAlOBwyt2Yoyn6M7GsxyL97U+jQyk3n7ujz58/Hw4cPsXbtWmWSAwCWlpbw9vZGVFSUMtHJzs4uNckBim/aT8pUVqJTWFiItLS0SnktfVBQUCh0CDqnoKAQt25xktXKoiiS48LavWo/4EAB5N59hJgf98G+m1c1Rac9srKy1JbJy8tDREQEQkJCyqxXn+B7uOpcWP6zxmXPrvgZjacEVmE0uiHl91PIf6T+PQ4RcH7N77B43Usvn9cpKLAHIFVbTlrLQfm7xKx4JESJha3K8peLowC3bt2ulNeqavp2zjQ9nvSTv8Bp2GxYte2nXGbi1uyl9/80jvIfj4ODQ4V6FOhcorNlyxb4+vrC3d291PX29vZwcCh+Y5mYmODOnTullsvNzVWWeaKwsBChoaHYsGED5HI5Bg4ciOXLlyuTInXS0tLg4uJSnsPRa7Nrd4ez1ELoMHRKfHw8AvgeqjSWYmMsseulcfn54yZje+b5KoxIOwUHB6stk5+fjz179sDGxkbtl0Nr1qyprNDoObNrd4eTxFztB3GFQoHj2/bA/5uPqyky7TXMvBm6mWow2p8CyLl1D43q1keOoqDqA6tmHkvPQ/ZKE6HDQHx8PFx6NBU6DI3o2znT9HiktRzx+Ow+WHccCol55Q/7X5HjSUpKQp06dcq9L50aWzktLQ3Jyclo0aJFiXVyuRxxcXHK1hwAcHJywr1795CXl1eifHJycokb9ty5c3HgwAHExcXhypUruHjxIj799NMqORYiqnpilO9bWQORTlWJVAOJy9HSINatW3yVKc85A8pfbxDpm7pj1yAnMQ7nhtviYsirSFw+Cul//QKF4kVdI7STTrXoPOleUdo3Wbt27cKdO3dUEp1WrVph//79OHXqFHx9nz5knJubi9jYWHTs2FHlNdasWYMFCxbA2dkZADBjxgwMHjwYixcvhoGB+v6VDg4OSEpKqsih6aUTAfOQdZ1d+crD3d0dSdu+FzoMvSEvKMThHtNQmJGjUfkJc6biq/4+VRyV9klISFBbJisrC+vXr0dAQIDayZanT59eWaHRc8598h3uHoxTW04kEqFlz05I+nJtNUSl3W5uPYz4hZp1+ZPWMsOlv65AZKB/SeK4i/ZIyq381zV28ShXeXd3d/yhI5+V9O2caXo8Zo3bo+nKq8iKP4WsyyeQceEwrs4fBMsWPVH/819LfA6vjuN50lurvHQq0XFxcYGBgQEOHTqksjwxMRHjxo0DAJVEJzAwEHPnzsWSJUtUEp3Vq1cjOzsbw4YNUy5LT09HUlKSyvbe3t7IyMjAjRs3UL9+fbXxSSSSCjWr6StpGQ91S0yMYeFW/IYVSyWQ2VrBuokrCrJykXGjZidGUinfQ5Wt0bBuuPDtb2rLSUyN4f1u7xo54lJqaqraMlKpFMHBwbCyslLbdY3v4So0sg8iNUh0AMDr/b5w5LWA7Yg+uLr0NxTlqe+O1vidHnCp+0o1RFX9pFcAVMGH9oZf7ClfHFKpztQR+nbOynM8IgMJzBq3g1njdrDvF4r7BzfixuK3kXnhMMybdlIpq83vAZ36ysLQ0BDDhw/HmTNn0LdvX6xatQrTpk1DmzZtULt2bQCqiY6npyfGjBmDn3/+GQMGDMCaNWsQGhqKjz76CJ06dVKZQycjIwMAYGVlpVz25Pcn66hy2DSrjz6RC9EnciFMHKzR+L2e6BO5kEOhUpXwCO4Fo1pmUNcbxXNs/xqZ5GjK0NAQo0aN4iiVAnPu3Ax2rf+ntpxD+yZwaK8bz0FUNSMrMzQd3ffFhUSAsY0l/hf0WvUERaRjjOs0BgAUPir92XdtpVMtOgAQEREBqVSKXbt2ITo6Gj4+Pti5cyfCwsKQkJBQYpCCJUuWwNXVFatWrcLvv/8OGxsbjBs3DmFhYRCLn+Z55ubFM6M/evRI2TyWnp6uso4qR9qJC1jnOEjoMKiGMHW2QffN0/DnsDnIu/+41BHYmrz/Bl4dP0CQ+HRFTk4OPv30UyxYsEBlxEuqXiKxGF3XfYbI4fNw98zlUsvYt22MLt99qpcjh1WU18cByEvPxL9r96mu+K8+kNlaofvmqTCxryVIfETa5PKUTrD2fRMmDVpCYmmLvNQEJG+YAgNTK5h7dhE6vHLRuUTHzMwMK1euxMqVK1WWnz9/Hp6enirJCwAYGBggNDQUoaGhL3xdKysruLi4IDY2Fo0aNQIAxMTEwNzcHK6urpV6DERUvWya1ceAY0txddtBXN7wJx5dKR7+2PUNHzT5sA9smzcUOELtV1RUhJMnT6KoqEjoUGo8o1rm6PnzTNz84wwurt6NO6f+BQDYt2kMj1G94eLfEmKJbs3bUdVEYjHazBmBegM74sI3vyLx978AAFYN66DROz1Qf1BHGFq8+NkzoprC0rsnHhz+ESmbv0BR9mNILO1g3qQjXEPWQmJhI3R45aJziU5p0tPTcevWLfTqpfkwsqUJDg7Gl19+CV9fX0ilUsyYMQNBQUEaDURARNrNyNIUHiN7oW6vttje4n0AQKsZQTB1qi1wZETlJ5ZK4Nq7LWy9Gyrfzx1XTOD7+QVEIhHsWrjDNOxdZaLTffM0nrMXMPfsjBa7dG+kLSHpwzlzGDQJDoMmCR1GpdCLRCcurvjBzGefz6mIKVOm4N69e2jSpAnkcjkGDRqE+fPnV0KERERERERUnZjoPEMikSAiIgIRERGVEBURkf4wMjLClClTYGRkJHQoREREGtGpUdfKMnr0aCgUCrRt21boUIiI9JJUKkW/fv0glUqFDoWIiEgjepHoEBFR1crOzkZgYCCys7OFDoWIiEgjTHSIiEgtuVyO69evQy6XCx0KERGRRpjoEBERERGR3mGiQ0REREREeoeJDhERqWVsbIzw8HAYGxsLHQoREZFG9GJ4aSIiqloSiQQ+Pj5Ch0FERKQxtugQEZFamZmZ6NKlCzIzM4UOhYiISCNs0SEiIo1kZWUJHQIRVZCzidARFNOWODShLbFWVhz6djyaYKJDREREpOcWtxE6At2jb+dM345HE+y6RkREREREeoeJDhERqSWTybB582bIZDKhQyEiItIIEx0iIlJLLBbD3t4eYjFvG0REpBt4xyIiIrWysrLg5+fHAQmIiEhnMNEhIiIiIiK9w0SHiIiIiIj0DhMdIiIiIiLSO5xHh4iohmvVqpXaMgqFAo8ePYK5uTlEIlE1REVERPRymOgQEZFaIpEIFhYWQodBRESkMXZdIyIiIiIivcNEh4iIiIiI9A4THSIiIiJ6aSKRCBs3bhQ6DCIlJjpERDVMt27dEBQUJHQYKg4fPoy+ffuibt26EIlEmD17ttAhEek1bawHnnXx4kWYmppCIuHj5FRxTHSIiEhwmZmZ8PDwwIIFC+Dg4CB0OEQkoOzsbAQEBMDPz0/oUEjHMdEhItJBy5cvh4eHB4yMjGBnZ4eBAwcCAFxdXUu0hgQHB6Nz584AgKCgIERFReGHH36ASCSCSCTCwYMH1e6vsLAQM2fORP369WFkZARnZ2eMGzdOuV4kEiE8PBwDBw6EqakpnJ2dER4ervHxvP766/jyyy8RGBgIIyMjjbcjqsm0rR4AgMePH+Ptt9+Gubk56tSpgy+//LLcxzVmzBh06NBBeTxEFcX2QAFFvTMPGTfShA4D5q4O6PrDJKHDoCoy8SSQnC10FMWcTYDFbYSOQvdNnz4dixYtwrx58+Dv74/MzEzs3btXo23Dw8Nx7do1ODo6KhMRa2trtduNGDECe/fuxaJFi9CuXTvcvXsXJ06cUCkzc+ZMzJw5E19++SX27t2L0NBQuLq6om/fvuU/yBriZe8D8sIi5e9/DJ4BscSgwq+lS/eClzlv+nLOtLkemD17NmbMmIF9+/Zh7NixaN26Nbp27apRbOvXr8fp06dx+vRpbN26VaNtSDM18XMnEx0BZdxIQ3r8LaHDID2XnA1cyxA6CqosWVlZWLBgAWbNmoWxY8cql3t7e2u0vaWlJQwNDSGTyTTuIpaQkID169dj+/btGDRoEACgfv36aNu2rUq5Xr16Kb/ddXd3x8mTJ7Fw4UImOi9QmfeBx9dSK+V1dEFlnTddPWfaXA8EBgZi5MiRAIpbZpYtW4bIyEiNEp1Lly4hNDQUBw4cgEwm0ygu0lxN/NzJrmtERDrkwoULyM3Nhb+/f7Xt8+zZswCgdp8+Pj4qf7dv3x4XLlyosriIaiptrge8vLxU/nZycsLt27fVvn5eXh4GDx6M2bNno2nTphWOk+hZTHSIiPSIWCyGQqFQWVZQUCBQNEQkBCHrAUNDQ5W/RSIR5HK52u1SU1Nx4cIFjBkzBhKJBBKJBCNGjEBRUREkEgnmzp1bVSGTHmOiQ0SkQzw8PGBsbIz9+/eXut7Ozg4pKSkqy2JiYlT+NjQ0RFFRETT1pDtMWft84q+//lL5+/jx4/Dw8NB4P0SkGW2uByrK2dkZcXFxiI2NVf6EhYXBwMAAsbGxyu5wROXBZ3SIiHSImZkZQkNDMWPGDMhkMnTv3h05OTnYs2cPJk+ejG7dumHFihXo378/6tati2+//RaJiYkqDxq7ubnhwIEDuHr1KiwtLWFpaQmpVFrmPhs0aIBhw4Zh9OjRyM3NhY+PDx48eIDjx49j/PjxynK7d+/GsmXL0KNHD+zbtw9bt27F9u3bNTquzMxMJCQkAADy8/ORlpaG2NhYmJmZoUGDBhU8W0T6SZvrgYqSSqUluqydOXMGANiVjSqMiQ4RkY6ZNWsWbG1tERERgYkTJ6JWrVro2LEjAOCzzz5DYmIiAgMDIZVKMXr0aAwePFiZRABAaGgo4uLi0KxZM2RlZeHAgQPKYWfLsnbtWoSFhWHq1KlISUmBnZ2d8oHkJ7744gtERkbi008/haWlJRYsWID+/ftrdExnzpxBly5dlH8vX74cy5cvR6dOnTQa9paoptHWeoB0X4clY9AgsLg+lhcVIed2OlKPncfZuT8iO+2BwNGVj0jxfCdOqja/dJqgFaNfWLnXQb9DSyr9dbXl+HRJVVyLgAMVH3XtRngQ7kf/UPyH2ACGtZ1h4d0Tzm/NgcSidrlfr545sK2L+nJVKSvlPra3eB8AMPjvlTB1Kv9xUEkikQgbNmzAW2+9JXQoOkWb6smquhdUBW05b7p0zog0/b/psGQMzOra49CoryEyEMPc1R5t5wajIDMXe/p8/tJxVOf/DVt0dJBYKsHwm1sqvP06R9359kViYoz+R8MR/e4C3D93VehwXprE1BgDjy/F/jdn4+HFRKHD0YiZhy/qfboNiqJCZF/9G4nLgpF/LwkNv/hd6NCIiDRWk+6dRC9Lnl+InLvpAIDstAe4vDESbeeMgNRMhoLMHGGDK4cakejI5XKEh4dj5cqVuHHjBmxtbREQEICwsDCYmpoKHV65ObRrgp2dJuCRFnybVdU8x/bD/XPXcP/cVVg2cMIb+7/CyWlrceXHSGUZszq26BO1ELFfb8fFlbvh4NME/tu+QORbc5Fy6JyynI1XA7z+62wc/GAxbu45Wa443Pq1R4clY7H79UkqCYrIQIzXf52D3AePITYQQ2pmgr39pkHxzAgz1p5u6LV7Lg6PiUDi7hO4sHI3Wk1/B/sDw17izFQfkcQQ0lrF8ywY2tRBTuJ5pGz+AvK8HIiNOM+BPpg7d+4LRzTKzMx8qdf/8ccf8f7775e5/uLFi3jllVdeah9E6tSke2dFVHU9cOTIEfTs2bPM9Xv37oWvr+9L7UMoMZfu4V56Hrr7OGu8TV5+EVb99C9GBzaGgYF2jw0ms68F195tIS8sgqJI/Qh62qRGJDoTJ05EREQE+vfvj9DQUFy6dAkRERGIiYlBZGQkxGLtfoM9z7Khs8oHeH1lYCRFo3f8cWTcUgDAo4QUnAnbgNYz30HasfPIuJEGkVgM3+UhuHfuGi6u3A0ASDtxARdX7Ub7xaPxa9dQ5D3MhERmhI7Lx+PqT4fLTHIcfJqgQ/gY/NR6dIl11385hjrdWqDj8vHY/dpnKMorHqaz2YRBMHOxRdTwLyEyEKNv9CJ4hvTHP0t2FB+DsSE6LgvBtZ+PIHF38ezRCVsPwHvSm7Bq5IL0y0mVft6qmthIBsjlUBQVCh0KVZLWrVtj/fr1Za4/ffo08vPzsW7dOgQFBZUYPhYATp06pSzbqlUrlXV9+vRBmzZtynx9JyenCkZOpLmacu+siNOnT1dKPfCs5+uBli1bIjY2tszyzs6aJwna5J/4B+g2ah+ycgrxa0Q3+Lero3abvPwiDPooCrsPJ+Hspfv4PswXIpGoGqLVnEO7JhiWsAEisRgSmREA4Pw3v6IwJw8A8ErP1vD6aLDKNpbudXBq2lpcXl81I/NVhN4nOhcuXMDSpUsxYMAA7NixQ7nczc0NISEh2LJlC4YOHSpghFQW5y5eMDA2VLkx/btuH+p080bHZSHY03cqPMf1h5W7C3b5faSy7dl5m+HUqRl8FryPgyMXofWsdyEyEOPktO8rHM9fk9egb9RCeE8ZhtPT18HGqwE8Q/rjwHtfIff+YwDA8Y+/RaeVHyH5QCzun7uKFp+/BbGhFCenPt1v7v3HuHPmMuoP7Ii/5/5Y4XiEkHPzIu7sWQ5T9zYwMDEXOhyqJE9GXHqR/Px8rFmzBkOHDlX7Aed55ubmMDfn+4VIm1V1PSCTyfRyBEWH2jI42ZrgfMJD9AmJVJvsPJvkAIB349pal+QAwN2zV3B0/DIYGEnh2qcdnHxfRcz8zcr1N/eews29p5R/v/JaK3hPHoqE7QcFiLZsutWU8Zxz586hb9++sLS0hIWFBfr164fU1FSYm5tjyJAhAIDNmzdDoVBgwoQJKtuOHDkSJiYm2LhxowCRV5xlAyc8SkgWOoxqYe/TBA/OXy/RTHps4gqYu9rDd2kIvD4ajL8mrUZ2quooIPKCQhweE446Xb3hu3QcGgR2wZFxESjMyq1wPAUZ2Tg8bikav/saXPxbwnfpOMT/GIVbUWeVZW7uO42EbQfRcVkIXPxbotHw7jgytuR+7569Aof2ujFcZsb5g4gJNMPZwTJcDGkKI/t6cAvdJHRYRDVe902f4/Vf50D0XK8Ea083vJ24GXV7+wgUmfapSfdOql52tWWIWt0TTRvUQl5+EfqERGL/8dK7Rz6f5ERMaotxQ5tUZ7gaK8rNR8aNNKRfTkLsV1uRkXQHbeaMKLWsiaM12swNxqEPlqAoJ7+aI30xnU10oqKi0LZtW1y+fBlTp07F3LlzcevWLfTs2ROZmZnw8vICUNzUKhaL0bp1a5XtjY2N4eXlhdOnTwsQfcXZ+zRB2vELQodRLcxfsSuRwABAzt10/P3lZtTr3wE3/ziN67uOlbp9+uUkXFi1G/UHdcLF1b/jzunLLx3TnZOXELdiF7p8/wkUCgXOhJVs5j/9xTpAJEKX7z9BXMRO3P07vkSZ7NQHMK9r99LxVAdT9zZovCQWTZZdQvPtuXAP+xNGDvWEDouoxjs6YTks6jnAM+TpEN6ldZelmnXvpOqnSbKjS0lOaWIXbkWDwC6o3ay+6gqRCB2XjUfcsl/w8JL2DbKkk4nO3bt3ERgYCG9vb8TExOCTTz7B2LFjERUVhZs3bwKAMtFJSUmBjY0NjIyMSryOs7Mz7t27h/x87co+X8TASAp5/tNnI/y3TcdrO8OA55o9/dZ+ht775kMkMajuECuNgbGh8lmYZ4kMxGg4pAsKsnJQ27MeJKbGpW4vMTVGvX4dUJCVA7tWjUp862nqbINhCRuUP91+nFJiWd+Di0u8buzCbRAbGOD8sl9QlFvyvVOYk4fz3/wKKIBzS34qNbaivHwYGJev2V8oYkMZjB0bwMjeFWKpbsRMlU8ikaBPnz6QSPS+x7POyLmTjuMff4tmEwcpP3yU1l2Wata9syqxHijbi5IdXU9yACDjehqS/jwD70lvqixvNmEg8jOy8e/3ewWK7MV0MtGZP38+Hj58iLVr10Imezrqk6WlJby9vQE8TXSys7NLTXKA4ladJ2W0lYHs6QdLqZkM+Y+yVNYfHb8UtRq5wHNsP+Uy97e7w6nTqzgyNhyKwqLqCrXS5d5/DCMrsxLLm00YBIt6jvitx2cQiUVoPTOo1O3bzhkBeWERdvecBKuGdVS+9QSKh0v8tdsnyp/jH3+L7LSHKssi35pT4nWfnFN5UdnnVlFQfEMta3QSIysz5XM9RLrA2NgYU6dOVdabpB007S5b09Tke2dVYj3wYqUlO7sP39T5JOeJ8yt+hXNnLzj4FMdv16oRGg7timMTlwscWdl0MiXfsmULfH194e7uXup6e3t7ODgUD4drYmKCO3fulFouNzdXWeaJbdu2ISIiArGxsbCxscGNGzc0jquwsBBpaWkaly8oKHvUKpGBGC2mDENRfgFi5heP++/UqRlSDv+jUi479QFOTFoN36XjkHwgFoU5eWg14x2cCduARwkpGsdx61blD7f5ouPTxP24a2j8rupQlDbNG+LV8QNw8IPFeHw1BUfGL0OP7dNx84/TuPXn38pydXu1Qb0BvtjTZyoeXUnGX1O/Q/tFH+JW1Fk8iLsOoDgJybjx9HqZOtaGoqhIZVlVsWpcF/fPXSuxvCquRUGBPQBppb5mRRUUFODWrduCxpB7O135e2pqKozlujMfQFXJyspSWyYvLw8REREICQkp88ujJ6qiPtFXL1tPAsXdZd/48yt0+f4T/LN4R6ndZTWNRVeuXVnnrTrvnU/i0JVz9iKa1AEA6wFNbQhrhiGTz+ByYib6jPsTCkXx8rAP/of+HS0FOzea1jdHJ5SeuNw9c1k5n5ShhQl8l4bg6PhlyHtYvqHHK/J/4+DgUKGWRJ1LdNLS0pCcnIzAwMAS6+RyOeLi4tC8eXPlMicnJ1y8eBF5eXkl/imTk5NhY2OjMnJIrVq1MHbsWNy+fRuLF5fstqQuNhcXF43Lz67dHc5Si1LXKYrkiFm4FT22TkcMiitrEwdr5Nx+WKLsjV+Pw8W/JTouD0FhTj5u/3UJ/67bp3Ec8fHxCChH3Jp60fFpIjk6Bq1nBMHEqTayU+4XDxG9LARXdzwdIvr2iYu4uHI32i/8AL/4hSLv/mPI7Kzgs+B9nFuyA/diEwAA1346jFf8W8F3aQh29/i01C5x1cmhTWPELCg5cV1VXAuPpeche6Vi3x65jl9XqbHEx8fDpYewgzDUEsvwtd3rAIqHVX7IRAfBwcFqy+Tn52PPnj0l6szSrFmzprJC03svW08CT7vL+swbWWZ3WU1U1b2gKpR13qrz3gno1jl7EU3qAID1QLlIagHus6Aw+K/168ExfDEmGF+MES6kyqhvnmj0Tg/I7KxK9KpJ2H4IF1ftfuG2Ffm/SUpKQp066ofufp7OdV178q1DaUPx7dq1C3fu3FF2WwOKx3GXy+XKOR6eyM3NRWxsLFq2bKmyvHv37hgyZAjq1q1b+cGXU1FOPnLvP4Kpsw0AqExC+byTU9bAtI4tLOs74VgZmbiueXQlGanHzqP+oE4AgFZhQRBJxCX6np+dvxk59x6j3VfFExJ2CB+LjBu38U/4DpVyxz9dCSNLU3hPGVY9B1AGh3ZNIDE1xvXfjgsaBxHpD3XdZWuSmn7vJC0gkgDObwEGz3Txs2oNmHkIF1Mli1u6ExvrDcOv3T9R+VGX5FQ3kULxpEFNN+Tn58PExATNmzdXGTEtMTER7du3R3JyMjZv3qwcXjouLg7NmjVD//79VebRWbp0KUJCQrBhwwa89dZbJfbzyy+/YMKECVXade1EwDxkXX9x+YZDu0IsleD+P8XdnO7FXCm13P/efQ0tp70NsaEE0e/MVxnyWB1TNwf4bJukcXlNaXJ86ti1aYxO30zAz+3Glfrgvy7qtnEK0k5cxPnlv5RYVxXXYtxFeyTlakfXNRfjAiz1EL7r2tHeMwAAHXbPgLG9laDxaIOEhAS1ZbKystC7d2/s3r0bpqamLyyrj3NlVJXKqCcBoEFAZ7Rb9CHWu5Ts7aCpqroXVAV156067p2Abp2zF9GkDgBYD2gir0COD+bEIvLU3RLrjKRifDe9OTp52wgQWeXVNy+rIv83NabrmqGhIYYPH461a9eib9++6NWrF5KSkrB69WrY29sjOTlZpUXH09MTY8aMwbJlyzBgwAC8/vrruHTpEiIiItCpU6dKnSxUIpGUq1lNKlV/+m9F/o32X4+GSCzCv2tLb1K3bOiMltPexslpa2HlXgftFn2IXX4fIe9BhsZxVKQ5UJPXfVl3Tl7Cua+3w/wVO6TH635/X4mpMe78HV/mNx5VcS2kVwBoyXPJUqm0St5r5ZElfjqAiaOjI0ydagsYjXZITU1VW0YqlSI4OBhWVlZqu6wIfY11SWXUk5Wlqu4FVUHdeauOe+eTOHTlnL2IJnUAwHpAnSejqz1JcsJGe+OLFcXJcyNXS1y+8QgjwmLVTipaVbSlvqnO/xud67oGABERERg1ahROnjyJ0NBQnDx5Ejt37oSTkxNMTExKDFKwZMkSLFy4EBcuXMCYMWOwZcsWjBs3Drt374ZYrN2nIOdOOqRmMkhkpT/0J5IYwHdZCFIO/4MrP0bi7NwfkfcwAz4L3q/mSKtO/MZIvUhyAKAwKxf/LP4J8kp4AJmoOhkaGmLUqFHlng2dSAi8d1YN1gNlK20I6Xf7Pf08umV+F40mFaXKpd2f8stgZmaGlStXIi0tDRkZGdi/fz98fHxw/vx5eHp6lkheDAwMEBoaisuXLyMvLw/Jycn4+uuvYWZWcuhibZRy6BwyEkvv7tP800CYOtbG8dBvAABFeQU4MjYCLt1boP7gTtUZJhHpsZycHIwbNw45ORy8QRslbDv4Ut3W9BHvnZWP9UDpNJknx6aWsdpJRanyaUcbViVIT0/HrVu30KtXr5d6naKiIhQUFKCgoAAKhQK5ubkQiURqh1GsSvGbolCQUbJSsWv9PzT9sC+i31ugMifLgws3ELtwG9rMeg9pxy8gK/ledYZLOiw3OR4XxjVBoy+PwKxRW+VyeV42bq4KQf6d61DIi9Bg2u8wMDZFVsLfSN4wGYrCApg1bg/nt2YLGD1VpaKiIpw8eRJFL5g/ikib8N5Z+VgPlFSeyUCfzLPTdeRenE94iD4hkYJ1YyuNWR1bdFwxAfLCQogMDPDXpNV4eClRud53WQjMX7GHyECMf9ftw9XthwAAtV+tB+8pwyCWGODO6X+VQ7trA71JdOLi4gBA5fmcitiwYQPeffdd5d8ymQx169Yt16AEla20YTEB4M6pf8v8Bi9u6U7ELd1ZlWGRHkrdNgvmTUp+m5myZSasOw2Fxat+ymXygnykbPwc9Sf9DAOZbrSOElHNwXsnVYdTcXex77+WGU0mA30+2flqXRy6+ziXOppwdctKvY89facCCgUc2jfFqyEDcOjDp1OtxC7ahozraRAbStA3+mtc/+UYAMB70ps48N5XKMzWkgeCn6GTXddKU1mJTlBQEBQKhcqPkEkOUXXJunwSUisHGNqU/GYpI+4AHp36FZc/74zUbbP/K38CYmNTXF84BPHTuiLz3xPVHTIREZGgfFs4YOsCPyyd7KM2yXniSbIzor87fl7cVSuSHOC/4en/G4zZ0FyGBxdvqKzP+G/ENnl+IfDfZ2Tblu4oyM5Dp28nwn/bdNi2cH/+ZQWlN4nO6NGjoVAo0LZtW/WFiaiE1O1z4DCw9OEec66fg4X3a3CfFY3sq2eREXcQBQ9SkHPjH7iFboZryDokrhhVvQFTtTIyMsKUKVME7cZLRMJiPVC6Ad1cMfbN8s2RY1dbhjUzfWFuql0DO1g3ccXrv81BmznBSD0SV2qZpmP64cbvf0FRWAQT+1qwblwXhz5cjKMTlinnNNQWepPoEFHFPTrzO0watITEovShliUWNrDw8odILIaFlz9ybvwDAzNrmDVuDwMTcxjausDAyBRF2Y9L3Z50n1QqRb9+/SCVasecTERU/VgP6L8HF25gzxufIypoHtrMHVFivVvf9qjt6aZ8DicvPRN3Tv+LwqxcZKfcR2F2HqRmshLbCYWJDhEh+1osMs8fxJUZr+Fx7J+49d1EFDx4Oq+CWZOOyL5aPBdAVsIZGDk2gKl7G+Qmx0NRVIiirEcoyn4MAxMLoQ6Bqlh2djYCAwORnZ0tdChEJBDWA/pNbPj00f2Cx9koylGdqN2pczM0fNMPR0KWKru43Tt7BRb1nCAyEENqbgKpuQwFmdozKp/eDEZARBXnGPA5HAM+BwDcCA+CzWsfIPvGORTFHYB1p6FwHj4PicuCoSjIhbFLE1i06AmRSATb1z7A5c87Q1FYgDrvfiXwUVBVksvluH79OuRyudChEJFAWA/oN7tW/4PXxwFQFMkhEolwasY6OHfxgqGVGa7vPArf8LHIvv0Q/punAQAOfbAYOXfTcXnDfrz280yIJRKcCdsg8FGoYqJDRCpcx68rsczIri7cw/4ssby233DU9hteDVERERFRVUo7dh77jp0vc/3WZiNLXX51+yHlUNPahl3XiIiIiIhI7zDRISIitYyNjREeHg5jY2OhQyEigbAeIF3DrmtERKSWRCKBj4+P0GEQkYBYD5CuYaIjIHNXB6FDAKA9cVDVcDYROoKntCkWKp/MzEy88cYb+O2332BmZiZ0OHpDm+pfbYpFHW2JVVviqC6sB3Tby7xf5YVFeHyteDRWi3qOEEsMBImjvJjoCKjrD6VPzkhUmRa3EToC0hdZWVlCh6B3eB+oGJ434bAe0F0v83+TlXIf21sUTwbaY/sMmDqVPu+etuEzOkREREREpHfYokM6o+HQrmg4xA8KhRwnPluN9H9vqqzv8t0nMLIqbkqv7VUfe3p/joeXEtFu4QewqO+Eotx8HAv9Btkp95XbeH0cALe+7bHTd3yZ+3Vo1wTek4dCXlCIwuw8HB4bgfz0TJUy7RZ+gDrdWiDpj9M48dkqAICBzBC+4eNgZG2O/EdZODZxOfIfc5I1IiIiourAFh3SCYZWZmj0jj/2DvgCxz76Bm1mvVuizIERX2HfwOk4MGoRMm/ewcNLiXjltVYoyivAvv5f4OyXm9Di87eU5Y1tLGFRz0ntvh/fSMMfg2Zg34DpSNp/Bo3f61miTOzCbTj84RKVZY3e6o67Z6/gj0EzcO3nw2gyum/5D5xIS8hkMmzevBkymUzoUIhIIKwHSNcw0SGdYNu8AdKOX4CisAiPr6bAyNoCEIlKLev2Rjvc+O0EAMCinhPun7sKALj/zzXYt/mfslyziYMQt3Sn2n1np9xHUV4BAEBeUAhFKTNCZ6c9KLHMop6jct93YxLg2K6p2n0RaSuxWAx7e3uIxbxtENVUrAdI1/CdSjrB0MoM+Y+ePgBZkJkDQ4vSh/CqN8AX134+AgB4+O9NOHX2AgA4d/GCrLYlAMDczQFSU2M8vJSocQxGtS3QKKgHrmyK0qj8w0s34dyleN8u3VrAqBZHqCHdlZWVBT8/Pz6ITFSDsR4gXcNEh3RC/qMsGFqYKv+WmslKfd7F7BU7iAzEyLiRBgBIjo7B42speG3HTDj7NceD/xIbr48DcW7xTxrvX2JijM4rP8Jfk9Yg5066Rttc2RwNiakxevw0A6bONqW2+hARERFR1eBgBKQT7p69Aq+PAyAyEMPMxQ55Dx4DCkWJcvUG+OLaziMqy2IXbgMAOHbwVHZBM3/FDm2/DAYAmDhao+UXw3EmbD1MHKyRcyddpXuaWCpB59WhuPDtb7gXc0XjmOUFhTj5+XcAgAZD/JD1zCAIRERERFS1mOiQTshPz8SVTVHouXMWFAo5/pq8BkBxdzRDKzNc33kUAODWpx32B85SbmdkbY4uqz+GvLAIWcn3lInHnjc+V5bpfyQcZ8LWAwA6fjMB0e/MU2ktavimH2ybN4DEuA+aftgHyQdiELfsFzQI6IzM5HtIO3YezSYOgstrrSCzsYL/1i+wf8gsWDVyQds5IyAvLMLDS4k4M2tDlZ8noopo1aqV2jJ5eXmYPn062rVrByMjo2qIioiqiyZ1AMB6gHSPSKEo5WtxokrwS6cJSI+/JXQYGhNJDNB+0Yc4On6ZYDFYuddBv0NLBNt/TfDspGeD/16pM5OeERGRbrmVlgUX/y0AgKT9Q1DHwVTNFtpLV++dfEaH6D+KwiJBkxwiIiIiqjxMdIiIiIiISO8w0SEiIiIiIr3DRIeISE9069YNQUFBQodR5eLj49GjRw+YmJjAxsYGH3zwgU7P66FL1+2tt95C/fr1IZPJULt2bXTv3h0nTpwQOiwiolIx0SEiIp2RmZmJrl27QiKR4Pjx49i2bRv27duHESNGCB2aoPLz86tlP23btsW6detw6dIlHDhwAHXq1EH37t2RnJxcLfsnIioPJjpERFpk+fLl8PDwgJGREezs7DBw4EAAgKurK2bPnq1SNjg4GJ07dwYABAUFISoqCj/88ANEIhFEIhEOHjyodn+7du1C8+bNYWJiAisrK7Ru3RoxMTEAAF9fX3z++dOh2KdPnw6RSITIyEjlsvbt22Py5MkAgOvXr2PAgAFwcnKCiYkJPD09sWGD6rDqnTt3xnvvvYdJkybBxsYGFhYWGDVqFHJzczU6P5s2bcK9e/ewadMmeHl5wc/PD8uXL8fWrVtx/fp1jV6jKlT3dXN1dcXUqVMxevRo1K5dG76+vhg9ejRcXV2Rnp6uLPfee++hUaNGyMzMREJCAiwsLLB48WLl+kuXLsHU1BSrVq3S6DjHjh0LX19fuLq64tVXX8WSJUuQlZWFM2fOaLQ9EVF14jw6RKRTot6Zh4wbaRXeXl5YpPz9j8EzIJYYVOh1zF0d0PWHSRWOozTTp0/HokWLMG/ePPj7+yMzMxN79+7VaNvw8HBcu3YNjo6OCA8PBwBYW1u/cJu0tDQMHjwYs2fPxuDBg5Gbm4uYmBhIJMW3hi5duuDPP/9Ulo+OjoatrS2io6PRrVs3ZGZm4vTp05gxYwaA4tYWPz8/TJ8+HWZmZtizZw/effdd1KlTB126dFG+zk8//YTAwEAcOXIECQkJGDFiBExNTVU+gJfl2LFj8PHxgaWlpXKZv78/xGIxjh07Bjc3N43OV2Wq7uv2REREBD766COcOHEChYWFqFevHo4ePYqRI0di+/bt2LRpE3788Uf89ddfMDMzQ4MGDfDNN9/gvffeQ6dOneDh4YHAwED06tULo0aNKvdx5+bmYsWKFTAzM9N4HpbKMvEkkJytvlxVczYBFrcROgrN8JxRTcREh4h0SsaNtEqbn+nxtdRKeZ3KkJWVhQULFmDWrFkYO3ascrm3t7dG21taWsLQ0BAymQwODg4abZOamoqCggIEBATA1dUVANC4cWPlej8/P3z55ZfIyMiAgYEBTp06hblz52L79u0AgCNHjkAkEqFDhw4AAE9PT3h6eiq3HzduHCIjI7Fp0yaVRMfa2hrffvstDAwM0LhxY8yePRshISGYPXs2TE1fPM9EampqieOTSqWwtrZGamr1X08hrtsTrVq1UiaZT2zduhUtW7bE5MmTsXz5cixYsADNmzdXrh82bBgiIyMxZMgQtG/fHhkZGVi9enW59rtixQp8+umnyM7OhrOzM6KiouDk5FSu13hZydnAtYxq3aXO4zmjmohd14iItMCFCxeQm5sLf3//atvnq6++ih49eqBp06bo378/wsPDkZSUpFzv4+MDiUSCQ4cO4ciRI6hbty7efvttnD17FhkZGYiOjkbbtm0hk8kAANnZ2Zg0aRKaNGkCa2trZatOYmKiyn5bt24NA4OnLWnt27dHXl4erl69Wj0HXomEuG5PtG7dusSyxo0bY+HChZg3bx46dOiA8ePHlyizbNkyFBYWYv369di0aZNK65gmhg0bhtjYWBw9ehRdu3bFoEGDcPPmzQofBxFRVWGiQ0SkA8RiMRQKhcqygoKCl3pNAwMD7N27F9HR0WjVqhV27NgBd3d37N69GwBgZGSEdu3aISoqCtHR0fDz84OdnR0aNWqEQ4cOKZc98cknn2Djxo2YPn06Dhw4gNjYWLz++uuV+qC8o6Mj0tJUuy4WFBTgwYMHcHR0rLT9VJaquG5PlNX6dejQIRgYGCApKanUZ58SEhKQkpICkUiEhISEcu/X0tISDRo0QLt27bBu3TqYmJhgxYoV5X4dIqKqxkSHiEgLeHh4wNjYGPv37y91vZ2dHVJSUlSWPRk04AlDQ0MUFRWhPEQiEVq3bo0pU6bg8OHD6NSpE9auXatc36VLF0RHRyM6Ohpdu3YFUNylbceOHYiNjVVJdA4fPoxhw4YhICAAzZo1Q7169RAfH19in6dPn1aJ8/jx4zAyMkL9+vXVxtu+fXucOHECjx8/Vi77888/IZfL0b59+3Ide2UQ6rqV5bvvvsOvv/6Kw4cPIyMjAxMnTlRZn5WVhSFDhmDIkCFYuHAhxowZU6Fk51lyuVzjwSSIiKoTEx0iIi1gZmaG0NBQzJgxA8uXL0d8fDzOnTuHL7/8EkDxXCtbt27F/v37cfnyZUycOLFElzA3Nzf8/fffuHr1Ku7du6e25eD48eOYNWsWTp48iZs3byIqKgr//PMPPDw8lGX8/PwQFxeH2NhY5XM2fn5+2LhxI4yNjdG2bVtl2UaNGmHXrl04deoULl68iFGjRpX4kA8A9+/fx5gxY3Dp0iX8/vvvmDZtGt5//321z+cAwNChQ2FjY4OhQ4fi3LlzOHDgAMaMGYPAwEBBBiIQ4rqV5fLlyxg/fjyWLFmCdu3aYfPmzVizZg127typLBMSEoKioiIsW7YM48ePR8eOHfHmm29qtM/z58/jq6++wt9//42bN2/i9OnTeO+993D9+nUMGzasQjETEVUlJjpERFpi1qxZmDNnDiIiItC0aVP4+/vj7NmzAIDPPvsMvXr1QmBgIHx9fWFpaYnBgwerbB8aGgobGxs0a9YMtra2OHbs2Av3Z2lpiRMnTqBv375o2LAh3nvvPQwbNgzTpk1TlmnVqhVMTU3h4eEBGxsbAECnTp2gUCjQoUMHSKVSZdnFixejbt266NKlC7p27QpnZ2cMGjSoxH4HDRoEc3NzdOjQAUOGDEHv3r0xb948jc6RmZkZIiMjkZ+fDx8fHwwaNAj+/v747rvvNNq+KlT3dStNXl4ehgwZgtdee005gpqPjw9mzpyJ4OBgJCUlYdu2bdi4cSO2bNkCMzMziEQirFu3DikpKZgyZYrafRgbGyMqKgqvv/46GjRogH79+uHBgwc4cuRItY+6RkSkCZHi+c7DRJXkl04TKm10rJrCyr0O+h1aInQYWk1b3le8VhXTuXNnNGjQAGvWrBE6FNJhAQcqNoLYjfAg3I/+ofgPsQEMazvDwrsnnN+aA4lF7XK/Xj1zYFsX9eW0QUXPWWXTpXP2sm6lZcHFfwsAIGn/ENRxUN9qra2yUu5je4v3AQCD/14JU6fy/78IgcNLExERUY1h5uGLep9ug6KoENlX/0bismDk30tCwy9+Fzo0Iqpk7LpGRKSn5s6dCzMzszJ/tM3NmzdfGO+PP/4odIjVQqjr1rNnzzL32bNnzyrbb3UTSQwhreUAQ5s6sGrTF3ZvTMDjmH2Q5+UIHRrpKLlcgfyC8g8okptXWAXR0LNqRIuOXC5HeHg4Vq5ciRs3bsDW1hYBAQEICwvT6OFXIiJd9MEHHyAgIEBtudOnT6stk5+fj3Xr1iEoKAiGhoYvLPui5zUOHjxY5jonJyfExsaWud7e3l5dmHrh2ev2zz//lFj//PWqrGuzZs0a5OSU/mH/yVxJ+khsJAPkciiK+KGTyk8uV+CDWceQfCcLPy/uBiNDA/UbAYg+mYLhnx/CrxHd4e1hU8VR1lw1ItGZOHEiIiIi0L9/f4SGhuLSpUuIiIhATEwMIiMjIRazYYuIgEGnVuCn1qOFDqPSWFtbw9raulJeKz8/H2vWrMHQoUPVfpiuKIlEggYNGlTJa+uSZ6/bw4cP1ZavrGvj7Oxc4W11Vc7Ni7izZzlM3dvAwMRc6HB0UtxIV3iuviF0GII5dCYVq3dcBgAMmBipUbITfTIFvcftR05uEULm/4Uj63pBJBJVR7g1jt4nOhcuXMDSpUsxYMAA7NixQ7nczc0NISEh2LJlC4YOHSpghDWTs19ztJg8FJYN6yDnzkNc/G4PLq7cLXRYRESk5zLOH0RMoBkU8iIoCvJg/mpX1B29UuiwSEd1ae2EZVN8MHbuCew5ckttsvNsktO4nhV+WuSn9UlOXnom4n+MVP59avo6NH73Ndj7eGh97DrdlHHu3Dn07dsXlpaWsLCwQL9+/ZCamgpzc3MMGTIEALB582YoFApMmDBBZduRI0fCxMQEGzduFCDymq12s/rouu4z3DoQg1+7f4zYhdvQYtJQNBruL3RoVEO1mhmEPn9+BZl9LfT58yt0+nai+o2ISCeZurdB4yWxaLLsEppvz4V72J8wcqgndFg6J2nNRFyc4IWCBym4OMEL1xYECh2SYMYM8cCyKT4AoEx28vJLPrPzfJITvaYnHGxMqjvccrmyJRrbvEbi3NfblcsSd5/AvoHTseeNz5F9R32rs5B0tkUnKioKvXv3Rt26dTF16lTIZDKsW7cOPXv2RGZmJry8vAAU92UWi8Vo3bq1yvbGxsbw8vLSqG86Va4mo3rjXuxVnJ27CQDw6EoyrBq5wHNsP1xeX/rs4kQVYWBsiFdDBsCtb3uYOFqjKDcfGYm3cfWnw7j03R5ludPT1wEo7rr2a/dPBIpWu0kkEvTp0wcSic7eNvQWr035iA1lMHZkF8my/N33xd/QG9rVhefqG3AJXgyguOuax5LYaohMu40ZUjzR8rMtOxGf+SjXH4u5jXenH9apJOfqT4dxbOIKoIy3xN2/47E/IAyv/zYHhubaeSw6WSvevXsXgYGB8Pb2RmRkpPIhybfffls5M/aTRCclJQU2NjYwMjIq8TrOzs44fvw48vPzq6zPOZVk1/p/uLIpSmVZ8oFYNB3dFyaO1shOfSBQZKRvfOaNhEP7pjg17Xs8uJAIqbkMtZu6wdSZD36Wl7GxMaZOnSp0GFQKXhuqTK+uS1X+nvnvcVybNxCNF5+FtJZj8UKxZg/b10TPJzu5eUeV64K+OIzcPN1JcoryCnBqxrriJOcFM26mX05C/IY/0XR03+oKrVx0MtGZP38+Hj58iLVr16qMBGNpaQlvb29ERUUpE53s7OxSkxyg+ObwpExlJDqFhYVIS0t76dfRFwUFpY9gI7OzQs7ddJVlOf81fcrsatXoRKegoBC3bgk/GaY2K+t9VZpXXmuNs/M34+a+py23Dy8mVloc+nKtsrKy1JbJy8tDREQEQkJCyqxTn9CX86INeG1KV1BgD0AqdBgoKCjArVu3hQ5DI5qeM2ktB+XvErPiQTEkFrYqy18uDt05ZxXRt4MFHn7YGNO+uYToU0+Txty8IjR0McXGMC8U5j7ArVva/Vkn7Y+/kXf/sfqCIuD8mt9h2bs5RFU4uJeDg0OFWq11MtHZsmULfH194e7uXup6e3t7ODgU/0OamJjgzp07pZbLzc1VlgGKbxZjx45FVFQU7t69C0dHR4wbNw7jxo3TKK60tDS4uLiU93D01uza3eEstRA6DJ0SHx+PAL6HXqg876vsOw/h3KU5ru08ivz0zEqNQ5+uVXBwsNoy+fn52LNnD2xsbNR+MbRmzZrKCq3G47UpncfS85C90qTc27mOX1epccTHx8OlR9NKfc2qUtFzVtl06Zy9FOsugPOwp3/n3caV/fPRYo8GyYMWGGL+KnqYNlRfUAHkpj5AE9eGyFDkV1k8SUlJqFOnTrm307nBCNLS0pCcnIwWLVqUWCeXyxEXF6dszQGK52W4d+8e8vLySpRPTk5WuTEUFhbCwcEB+/fvx6NHj7Bt2zbMnj0b27Ztq7LjqYly7qRDZmulssz4v79ztPyhNtItx0O/Qa3Gr2DI+e/QJ2oRfL56H6+8VvY8IkRERJUiLxWQP9MDoeAxUJQtXDzlJC7rwZwyaOvoazrXovOkGb+0E7pr1y7cuXNHJdFp1aoV9u/fj1OnTsHX11e5PDc3F7GxsejYsaNymampKWbNmqX828vLC3369MHRo0c1mnTPwcEBSUlJFTksvXQiYB6yrpfsynfn1L9w6uyFc4t/Ui5z7uKFzKQ7NbrbGgC4u7sjadv3Qoeh1cp6X5XmzunL2NF2DGyaN4RdC3fYt/VA59UfIzk6BlHvzCtRPj1e8249+nStEhIS1JbJysrC+vXrERAQoHai5enTp1dWaDUer03pxl20R1Ku0FEU1wN/6Mh9v6rOmbGLR7nK69I5q6hjsfcRNPMscvPkqG0pxf1HBYBZQ/i9+xNWTW0OI6n2tzMkbT+Kywt+Ul8QgMTCBHEnLkMsqbrnt5701CovnUt0XFxcYGBggEOHDqksT0xMVHYxezbRCQwMxNy5c7FkyRKVRGf16tXIzs7GsGHDUJaCggIcOXIEH3/8sUaxSSSSCjWr6SuptPS314VVu9HrtzloPulNXPvpEGyaN0Tj93ri9IwfqjlC7SOV8j2kTlnvq7IoiuS4e+Yy7p65jAsrf0O9gb7ouGw87H08cPvERZWykW/NLVcc+nKtUlNT1ZaRSqUIDg6GlZWV2u5R+nJetAGvTemkVwBoQaIjlUp15pxW1Tlr+MUe9YWejUOHzllFRJ9MwbthMcjNkysHHtgReQNj555A9Ol7CFl4SaNJRYVmN+INJET8iqJc9d3R/vd2d7ziWrcaoio/7U8pn2NoaIjhw4fjzJkz6Nu3L1atWoVp06ahTZs2qF27NgDVRMfT0xNjxozBzz//jAEDBmDNmjUIDQ3FRx99hE6dOr1wstCxY8fC3Nwcw4cPr+rDqlHun7uK6HcXwKVbC/SJXITmnw7B2fmbObQ0VYtHV5IBAMa1LQWORLcYGhpi1KhRHKFSC/HaEGmHsubJ0XSeHW1iaGGKpmPUjKQmAoyszdH4vderJ6gK0LkWHQCIiIiAVCrFrl27EB0dDR8fH+zcuRNhYWFISEgoMUjBkiVL4OrqilWrVuH333+HjY0Nxo0bh7CwMIjLGCHio48+wokTJxAdHc2bRxW4FXUWt6LOCh0G6bnXfp6J678cw71zV5F7/xEsXB3hPXko8tIzkXb8vNDh6ZScnBx8+umnWLBggcpolyQ8Xhsi4ambDLS0eXa0vWXH66PByE/PxKXv9qquEIkAhQLG1hbovmkqTJ1qCxOgBnQy0TEzM8PKlSuxcuVKleXnz5+Hp6dnieTFwMAAoaGhCA0N1ej1J0yYgKioKERHR8PGhvNtEOmq5OgY1BvgC69PAmFoJkPO/Ue4/dclHJ24HHkPMoQOT6cUFRXh5MmTKCrS7m8hayJeGyJhqUtyntC1ZEckFqP1rPfg1q8DLv/wB5IPnUNRbgFMnW3Q8E0/NAjoDCMrM6HDfCGdTHRKk56ejlu3bqFXr14v9TohISGIjo7GgQMHYGtrW0nREZEQ4pb9grhlvwgdBhEJKOfmBSSueB8ikRgiAwnqjl0DI4d6Jcpd/rwzjJ3/h7qjvxUgSu1k7tkZLXa9YLZIwsl/7miU5DzxfLIT8HE0fgnvprWjlolEIti1bAS7lo2EDqVC9CbRiYuLA6D6fE55JSYmYunSpTAyMoKbm5tyua+vL/bu3fuCLYmIiEgbSSxs0XDa7zAwtcSjs/uQunUWXMevVSmTfno3DGTmAkVIuqxJg1po6WGDe+l5apOcJ54kOxMW/IVhveprbZKjD5joPKNu3bpQKPjNBRHR84yMjDBlyhQYGRkJHQo9h9fmxaRWdsrfRQZSQKzaTUghl+PunuWwe2M80v/6pZqjI11nZiLFnhU9kJVTCPvamj8jN2aIB3p2qIN6dTixelXSuVHXyjJ69GgoFAq0bdtW6FCIiPSOVCpFv379IJVKhQ6FnsNroxl5Xg5SNk+H/RvjVZbfj/4BVj4DIJYaCxQZ6TozE2m5kpwnmORUPb1JdIiIqOpkZ2cjMDAQ2dm6M7N3TcFro56iqBDXFw2FQ7+PIXP1VC6X5+fiwaEfYdP1XQGjI6Kqojdd14iIqOrI5XJcv34dcrlc6FDoObw2L6ZQKJC4LBgWzXvAqm0/lXV5t6+jKCsdCbN6ozDzAQoepuF+9HrU9uP8eUT6gIkOERER6a3HMX/gwdFtyLtzAw+OboGJmxcsvF9DUcYDWHcaisZfnwEAZMQdxIMjW5jkEOkRJjpERESktyy9X4P3dvXd+sw9O8Pcs3PVB0RE1YbP6BARkVrGxsYIDw+HsTEf2NY2vDZERKVjiw4REaklkUjg4+MjdBhUCl4bIqLSsUWHiIjUyszMRJcuXZCZmSl0KPQcXhsiotKxRYeqjLmrg9Ah6ByeM/W05RxpSxzVKSsrS+gQqAw17do4q598vlpoSxya0JZYtSUOqhmY6FCV6frDJKFDID3E9xURLW4jdAS6h+eMaiJ2XSMiIiIiIr3DRIeIiNSSyWTYvHkzZDKZ0KHQc3htiIhKx0SHiIjUEovFsLe3h1jM24a24bUhIioda0UiIlIrKysLfn5+Ne6hd13Aa0NEVDomOkREREREpHeY6BARERERkd5hokNERERERHpHpFAoFEIHQURE2k2hUCAjIwPm5uYQiURCh0PP4LUhIiodEx0iIiIiItI77LpGRERERER6h4kOERERERHpHSY6RERERESkd5joEBERERGR3mGiQ0REREREeoeJDhERERER6R0mOkREREREpHeY6BARERERkd5hokNERERERHqHiQ4REREREekdJjpERERERKR3mOgQEREREZHeYaJDRERERER65/+HL6lYVB2i1QAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "execution_count": 6, @@ -187,9 +194,9 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtMAAAD2CAYAAAAUCgudAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABP7klEQVR4nO3dd1hT1/8H8HdCEghbVEABQVSsqyhObHHPat2rVq22dnyts7Z1VOuetT+3dVYqWkdrraNqK7j3QBAnQ0GGCIrsneT3BzU1BgTCuAm8X8/jozn33Hs/OclNPp6ce45IpVKpQERERERExSYWOgAiIiIiIkPFZJqIiIiISEdMpomIiIiIdMRkmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEZJqIiIiISEdMpomIiIiIdMRkmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEZJqIiIiISEdMpomIiIiIdMRkmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEZJqIiIiISEdMpomIiIiIdMRkmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEZJqIiIiISEdMpomIiIiIdMRkmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEZJqIiIiISEcSoQOg0uP30VKkhMcKHUaxWbjYo/Mv04UOQ00f21Hf2uh1bDPd6UvbGUp7UenRl/eeISmL62TKFSA6vVQPqTMHU2Bla6GjMDxMpiuQlPBYJAZHCR2GwWM7Fh/bTHdsOxIK33v6ITodeJgidBRUEhzmQURERESkIybTREREREQ6YjJNRERERKQjJtNERERERDriDYhERAbg3VVfou7QjgAApUKBjKeJeHLhNvwX70J6bILA0RERVV7smSYiMhCxl+9i79tj8XuL/+Hsl6tQtbELOmyeKnRYRESVGpNpIiIDoczORUZ8ItJjE/D08j082OkL25b1ITWXCx0aEVGlxWSaiMgAye2qwKV3GyhzFVAplEKHQ0RUaVX4ZHrJkiUYPHgwXF1dIRKJ4OLiInRIREQ6sW/bCB+G+mDEw10YGrAF9p6NcHfLX8jNyAIAdNgyFW4juqjr2zSujX5nV8HIWCpUyEREFV6FvwFx5syZsLGxgYeHBxITE4UOh4hIZ/H+ITg/aR2MjKVw6dMWNb3exs1lu9Xbr87ejp4HFyDi6BVkvUiF59JPcWXmNiiycgSMmoiEEPSpC5psCRc6jEqhwifTYWFhcHV1BQA0btwYqampAkckDLs2DdDo8z6waewCc8fq8F+2G7dW7Rc6LIPj0KkZms8YDqt6jsiIe4G7247i7qYjQoel19hmpUeRmY2U8FgAQMAPe2HhYo/Wiz7Bxa83AgDSYxNwZ9MRtJg9Es9uhiLp4RM8OR8kZMhkgPh9QVQ8BjvMIzAwEH379oWVlRUsLS3Rr18/PHnyBBYWFhg2bJi63stEurKTmJogMSQS1xf4IP3pC6HDMUhV3eugs/c0RJ26iUNdv0bAin1oPn046o/qJnRoeottVrYCVuxF3aEdUdW9jrrs/vbjsK7vhCbj++HavF8EjI4MFb8vDFvk1im4O7kpchJicHdyUzxcPlTokCo8g+yZ9vPzQ+/eveHs7IxZs2ZBLpfD29sbPXv2RGpqKpo2bSp0iHon+uRNRJ+8CQBoMWuEwNEYpkaf9cazgDD4L/4VAJAUEq1OWh7s+Efg6PQT26xspTyKReSJ6/CY/gFOfLAwr1ClwoMdJ1DN3RVZz5OFDZAMEr8v9NONvqI3bpfZOqPJlnA4jV0JIG+YR8NVAeUQGRlcMh0fH4+hQ4fCw8MDvr6+kMvzpoQaOXIkateuDQBMpqlM2LZ6CyG/+mmURZ8KQONxfWFawwbpT7hwxuvYZmXv9oZD6HV4Eew9GyH20p28QqUSKqVK2MCIqFS97f1E/e/U+xfxcOlANFjpD2mVGnmFYiOBIiODS6aXLVuGFy9eYPv27epEGgCsrKzg4eEBPz8/wZLp3NxcxMbGCnJuAMjJyRXs3CWRk5OLqKgoocNQK6gd5bbWyIhP1CjLiHvx77YqZZoY6lsbvY5tpruiXrfnJ6/Ptzz++gN41xhUKnEYQntR6THU7wwhlcV1kpNjB6DwGXekVezV/5aY2+T9bVldo7zkseQgKuppqR3P0Njb20MiKX5qbHDJ9J49e+Dl5QU3N7d8t9vZ2cHeXrc3Vm5uLqZOnQofHx8olUoMHDgQ69evh4mJSZH2j42NhZOTk07nLg0Lq3aFg9RSsPPrKjg4GEMEbLfX6WM76lsbvY5tpjt9aTtDaS8qPfry3jMkZXGdNFx7G/JajUr1mLoKDg6GU/fGQochmMjISDg6OhZ7P4O6ATE2NhbR0dFo3ry51jalUomgoKAS9UovXrwYp06dQlBQEEJCQnD37l18++23JYiYKpKMuETIq1trlJn8+/hlbytpYpsJI3TfaVz5bpvQYRARVQoG1TOdlpYGABCJtAfhHzx4EHFxcSVKprdu3Yrly5fDwcEBADB37lwMHjwYK1euhJFR4WOR7O3tERkZqfP5S+rSkKVIeyTcMBNdubm5IXLfz0KHoVZQO8ZdvY+aHZoicOXv6jKHjk2RGhlX5mN/9a2NXsc2052+XLeG0l5UevTlvWdIyuI6mXDXDpGZpXpIAICJU8Ni7+Pm5oa/BcxjhKbryAaDSqadnJxgZGSEM2fOaJRHRERgwoQJAHS/+TAxMRGRkZEa+3t4eCAlJQXh4eGoU6dOwTv/SyKR6PTzQGmRSgt+OSWmJrCsnfcmEUslkFe3hk0jF+SkZarnrRWKVCpsu72uoHa8s/kIeh1ehGbTP8DD38+gWrN6aPBxT1ybW/bTj+lbG72Obaa7N1235clQ2otKT0HvPX3+vhBaWVwn0hAAZZBM1/v+aPFjkUr5OaAD/fgULyKZTIZRo0Zh+/bt6Nu3L3r16oXIyEhs2bIFdnZ2iI6O1kqmfXx8EBERASBvJpDs7GwsXJg3hZSzszNGjhwJAEhJSQEAWFtbq/d9+e+X2wxZNfc66PHHPPXjBh/3RIOPeyL24h0cHzhHwMgMx/PAMJwcsxweM4aj8Rd9kBGfCP9luznF2xuwzYgMD78viIrHoJJpAFizZg2kUikOHjyIkydPwtPTEwcOHMD8+fMRGhqqdWPitm3btHqyZ8+eDQBo3769Opm2sLAAACQlJam7+V8uP/5ymyGLvXSnVO74r+yi/PwR5ecvdBgGhW1GZFj4fUFUPAaXTJubm2PTpk3YtGmTRvnt27fRpEkTiMWa91SePn26SMe1traGk5MTAgICUL9+fQDAzZs3YWFhARcXl9IInYiIiIgqGINLpvOTmJiIqKgo9OrVq0THGTt2LJYsWQIvLy9IpVLMnTsXo0ePLtLNh0REpane8M6oN6wTVColLk3bgsT7j7Xq9Ng/D0mh0bg0bTMAoPWiT1D1bVeIjMQI+GEvok8FAADqDG6POoM7QCQW4f7244j463J5PhUiKmUWTTqg+UEuzKQvKkQyHRQUBKDkKx/OnDkTz549Q6NGjaBUKjFo0CAsW7asFCIkIio6mbU56n/UDX/1mgkLZzt4Lv0Ufw+ep1HHsUtz5KRmqB9b1XOAVT1HHH3/O8irW6PzzhmIPhUAazdH2LdthH+GzHv9NEREVAoMap7pgpRWMi2RSLBmzRq8ePECSUlJ2LZtm8Yqi0RE5aF6s7qIvXgHqlwFksNiYGxjCbw6JahIhLfG9MB97+PqooynL6DIyobISAyZlSmyEvJunHbu7QlFVg667f0eHbZ+rTXvNxERlUyFSKbHjRsHlUqFNm3aCB0KEVGJyazNkZ2Upn6ck5oBmaWp+nHdIR0QcfQKFJk56rLs5HSkPo7DgAtr0WP/PAStPQAAMLWvApmlGf4ZOh8Pfz+D5t99WH5PhIioEqgQyTQRUUWSnZQGmaWZ+rHUXI7s5HQAgJGxFK4DvBC656TGPjXbu0Nua439nuNxoP0UtFrwMURGYmQlpiLmdAAAIPpUAKo0dC6350FEVBlUiDHTVLreXfUl6g7tCABQKhTIeJqIJxduw3/xLqTHlu2qdUQExPuHoOnXQyAyEsPcyRZZCcmAKu9mI/NatpBZmaGLzwzIrM0ht7VGncHtkRGfiKzEVEClQk5qBoxkEoglRoi9eAdOXVsgdN9pVHWvg2SueEdEVKqYTFO+Yi/fxZnP/g8iIzEsXOzQZvFYdNg8FUf7fCd0aEQVXnZiKkJ+9UPPAwugUilxecZWOHRsCpm1OR4dOI8jPaYBAOw9G6F2v3cQ9tsZiMRiuPZ7Fz3/XAAjYynubTsGRVYOYk4HwrFTM/TYn3cD4oWpPwn51IiIKhwm05QvZXYuMuITAQDpsQl4sNMXbRZ9Aqm5XGMGASIqG8E7fRG801f9+MXdCK06sZfuIPbSHQCASqnE+cnr8z3W1e+9yyRGIiLimGkqArldFbj0bgNlrgIqhVLocIiIiIj0BnumKV/2bRvhw1AfiMRiSOTGAIDbPx1CbkYWAKBWz1Zo+tVgjX2s3BxxdfZ2RP5zHe8dWYQj3ach83kyjOQy9PX9ESc/+SHfhSeIiIiIDBWTacpXvH8Izk9aByNjKVz6tEVNr7dxc9lu9fbHx67i8bGr6se1erSEx4zhCP3tNBQZ2bi76QhazhuNc+PXoOnUIYg4doWJNFE+LFzsdd5XmatA8sMnAABL1xoQS3RfrbUkcRCR7hxMC69TXvQpFkPCZJrypcjMRkp43l3/AT/shYWLPVov+gQXv96oVde0hg1aLx4L3w8XQ5GRDQC4t+0Yeh9fhgZj34Pze61xqPPX5Ro/kaHo/Mt0nfdNi3mO35p/DgDo/ttcmNWsWlphEVE5Wdla6AiopDhmmookYMVe1B3aEVXd62huEInQbt0kBK37Ey/u/XeDlEqpxLU53mi94GNcX+CjHh5CREREVJEwmaYiSXkUi8gT1+Ex/QONcvfJA5Gdko77Px/T2sehczOkxyagylu1yitMIiIionLFYR5UZLc3HEKvw4tg79kIsZfuwLZlfdQb3hmHu32jVdf6rVqo1aMVjvScjvcOL0LY/rNIfRwnQNTl69UFb16Vk5aBXXVHChCR/mObERGRIWMyTVoKmqs2/voDeNcYBACQWZrCa+1EnJ+0DlkvUrXqei77DNfmeCM9NgE3l+9B60WfwG/kkjKNW1+8XPDmVSqlblMKiqUSKHNySyMsvcY2IyIiQ8VkmnRS/6PukNtao9W80Rrlob+dQU5aJjKfJSHKzx8AEPbbGdT7oBNqvdcaj49eESDa8vXqgjf5eWt0D7w1pjssnO2RnZKOp1fu4fTYFQCAQVc3IGz/WRhbm8OlzztICY/FX71mlFPkwmGbERGRoWIyTToJWnsAQWsPFLg9ZJevxuPjA+aUdUgGoenXQ9Doi/dxY9EuxJwJhMTMBI6dmmnUafDJe7i76QiOvj8TohJMdVZRsM2IiEifMZkmKmUvF7x5VeyFOzjzxUo0HtcXN5fvxf3tx9XbEoIeadR9FhCGgB/3lUus+oJtRkREhorJNFEpe7ngzatyM7JgXd8JErkxYs4EvnH/ZwEhZRmeXmKbERGRoWIyTVTKXl3w5lVmNYq2oEZueuWbk5ttRkREhorzTBOVk8TgKORmZKFme3ehQzEYbDMiItJ37JkmKmVimQTy6tZa5Rnxibiz6TCafj0YisxsxJwNhJGJDI6dPd54M2dlwDYjIiJDxWSaqJTZt2mIobe2apXvbjQGN5ftQebzZDT4pCdazvsI2UlpeHr5ngBR6he2GRERGSom0wQAqDe8M+oN6wSVSolL07Yg8f5j9TbzWrZ45//GQSyV4PGxq7iz8RAAYMTDXXh2MxQAcHfrX3h87CrcpwxCjXebAAAsatvj9vqDuLftKABAJDFC/zOrELLbD0Hr/izfJ1hOzk9eX+CiNy/d23oU97YezXfb763GlUVYeo1tRvpIJBLBx8cHI0aMEDoUItJzHDNNkFmbo/5H3XBswPe48NVPaL1gjMb2FrNGwn/JrzjWdxacujWHuZMtACAt+hmOD5yD4wPn4PGxqwCAwJW/q8synyUh4q/L6uPUH9kVSaHR5ffEiKhS6NKlC0aPHi10GBru3LmDwYMHo169ehCLxRg7dqzQIRFRGWEyTajerC5iL96BKleB5LAYGNtYAiKRertVPQfE3wgGAET5+sOuTQMAgNyuCnr8MQ/tf5oCk6qWGse0dnNEdlIa0mMTAAASUxM4dGqmkVwTEVVU6enpqFWrFr7//nu4u/MGWqKKjMM8CDJrc2Qnpakf56RmQGZpqi4Tif9LrLOS0mBcxQIAsL/Nl8hKSEHt/u+i5dyPcG7CWnU914Ht8PDAefXjxuP64O6Wv2Bmb1PWT4eIDND69euxfv16hIWFwcrKCl5eXti/fz9cXFwwduxYzJo1S1137NixCA0NxenTpzF69Gj4+fkBAH755RcAwKlTp9ChQ4c3ni83NxeLFi3Cjh07EBUVhWrVqmHAgAFYu/a/z7Hk5GSMHDkSf/75J6ysrPDll19ixoyiLVXfsmVLtGzZEgCwbdu24jQFkcHw+2hpvtOa6isLF3t0/mV6qR+XyTQhOykNMksz9WOpuRzZyenqxyrVf3VllqbIfJYEAMhKSAEAhB+6iLcnDtA4pvN7rfFXr7wvHZNqVrBpXBsBK/ah7pAOZfQsiMhQzZkzBz/++COWLl2Kbt26ITU1FceOHSvSvqtXr8bDhw9Ro0YNrF69GgBgY1P4f9o/+eQTHDt2DD/++CPatm2L+Ph4XLp0SaPOvHnzsHDhQsydOxfHjx/H+PHj0apVK3Tu3Ln4T5KoAkoJj0VicJTQYQiOyTQh3j8ETb8eApGRGOZOtshKSNbIoJOCo1CtaV08CwiFY2cPXPhqAyRyYyiycqBSKmHXpqHG/0xtW72FxJAodUJepUEtmFS1RNdfv4OpvQ3EUgme336EmNNvXtWOiCq+tLQ0LF++HAsWLMD48ePV5R4eHkXa38rKCjKZDHK5HPb29kXaJzQ0FDt27MBvv/2GQYMGAQDq1KmDNm3aaNQbOnQoPv30UwDAl19+iXXr1sHX15fJNBFpYDJNyE5MRcivfuh5YAFUKiUuz9gKh45NIbM2x6MD53Fj8S688+P/IJIYIfLva0h9HIeqb7ui7YovkJOWCWWOApe+3aQ+nusALzz8478hHk/OBeHJuSAAQN0hHSC3tWYiTUQA8m7Uy8zMRLdu3crtnP7+/gBQ6DmbNm2q8bhmzZp4+vRpWYVFRAaKyTQBAIJ3+iJ4p6/68Yu7Eep/p4TH4vjAORr1n996iMPdvs33WJenbynwPKH7TpcsUCKqVMRiMVSvjjUDkJOTUy7nlslkGo9FIhGUSmW5nJuIDAdn8yAiIsE0bNgQJiYm+Oeff/Ldbmtri5iYGI2ymzdvajyWyWRQKBRFPufLISQFnZOIqDjYM01ERIIxNzfH1KlTMXfuXMjlcnTt2hUZGRk4evQoZsyYgS5dumDDhg3o378/nJ2dsXHjRkRERGjcZFi7dm2cOnVKPROIlZUVpFJpgeesW7cuPvzwQ4wbNw6ZmZnw9PREQkICLl68iEmTJpXK88rOzsbdu3cBAKmpqUhISEBAQABkMhkaNmxYKucgIv3AZJqIiAS1YMECVK9eHWvWrMGUKVNQpUoVtGvXDgAwbdo0REREYOjQoZBKpRg3bhwGDx6M0NBQ9f5Tp05FUFAQ3N3dkZaWVqSp8bZv34758+dj1qxZiImJga2trfpmxNIQExODZs2aqR/fuHEDBw4cgLOzM8LDw0vtPEQkPCbTREQkKJFIhEmTJuXbK2xhYQEfH5837u/q6oqzZ88W65xSqRQLFizAggUL8t3++jhtAPD19c2nZv5cXFzyPQYRVTwcM01EREREpKNK0TO9ZMkS+Pv748aNG3j06BF/ZiMiqsDGjRsHb2/vArefOXMG2dnZ8Pb2xujRo7Vm7Xjdy5UMXzp37hx69uxZYP1jx47By8urWDETkeGqFMn0zJkzYWNjAw8PDyQmJgodDhERlaEBAwagS5cub6yTnZ2NrVu3Yvjw4YUm069r0aIFAgICCtzu4OBQrOMRkWGrFMl0WFgYXF1dAQCNGzdGamqqwBEREZVMdko6QvedUj++NH0z6o/qBoeOTSE2MhIwMuG9nNGjrMjlctStW7fMjk9EhsWgx0wHBgaib9++sLKygqWlJfr164cnT57AwsICw4YNU9d7mUhXZg6dmqHPiR8wMnw3Bl3dgIaf9xY6JINj16YBOm2fhkHXfsLoJ7/j7ckDhQ7JILDdSl/EX5exr+mnuLlsj7os6sQN+I1cgoMdvkJyeKyA0RFRZVfZPvcNNpn28/NDmzZt8ODBA8yaNQuLFy9GVFQUevbsidTUVK1lYCuzqu510Nl7GqJO3cShrl8jYMU+NJ8+HPVHld/yvRWBxNQEiSGRuL7AB+lPXwgdjsFgu5WuKD9/nPrsR+RmZOe7PSk0GscHzEF6HNv6TSQSCfr06QOJpFL8QEtUrirb575BforEx8dj6NCh8PDwgK+vL+RyOQBg5MiRqF27NgAwmX5Fo89641lAGPwX/woASAqJhnV9JzQZ3w8PdnAFsKKKPnkT0SfzVl5rMWuEwNEYDrZb6VGpVLj6/XZABeAN066lP3mOOz8dQss5H5VfcAbGxMQEs2bNEjoMogqpsn3uG2QyvWzZMrx48QLbt29XJ9JA3jg5Dw8P+Pn5CZJM5+bmIjZWuJ9Xc3Jy8y23bfUWQn710yiLPhWAxuP6wrSGDdKfJJRHeAXKyclFVFSUoDG8qqB2FJK+tdHr2GblI+FqMJIfPilS3Qe7fGH7oReMTIp3c11FkJaWVmidrKwsrFmzBhMnToSxsfEb61a099FL+njd6ruK+LlSEob2Hirs9bO3t9fp1yqDTKb37NkDLy8vuLm55bvdzs4O9vb2Oh173759WLNmDQICAlCtWrViTaEXGxsLJycnnc5bGhZW7QoHqaVWudzWGhnxiRplGf/+BCy3rSJ4Mh0cHIwhArbb6wpqRyHpWxu9jm1WPt4zc8NgiyZFqpubkoG2DZoiJjeljKPSP2PHji20TnZ2No4ePYpq1aoVOpvH1q1bSys0vaKP162+q4ifKyVhaO+hwl6/yMhIODo6Fvu4BjdmOjY2FtHR0WjevLnWNqVSiaCgoBL1SlepUgXjx4/HokWLShAlEVHpE0NUrPpGhvcRT0RkcAyuZ/rlz3cikfaXysGDBxEXF1eiZLpr164AgD///LPY+9rb2yMyMlLnc5fUpSFLkfZIe5hJRlwi5NWtNcpM/n2coQc3Kbm5uSFy389Ch6FWUDsKSd/a6HVss/IRdzIQt6ZtL1JdsUyCs0HXIDGXF165ggkNDS20TlpaGnbs2IEhQ4bAzMzsjXXnzJlTWqHpFX28bvVdRfxcKQlDew8V9vrpOqrB4JJpJycnGBkZ4cyZMxrlERERmDBhAgDhbj6USCQ6/TxQWqTS/F/OuKv3UbNDUwSu/F1d5tCxKVIj4wQf4gHkxS1ku72uoHYUkr610evYZuWj5gf2CF7xBzKfJeXdhPgGrv294PJWvfIJTM88eVL4uHKpVIqxY8fC2tq60GEeFe199JI+Xrf6riJ+rpSEob2Hyur1M6xWACCTyTBq1Chs374dffv2Ra9evRAZGYktW7bAzs4O0dHRWsm0j48PIiIiAOTNBJKdnY2FCxcCAJydnTFy5Mjyfhrl6s7mI+h1eBGaTf8AD38/g2rN6qHBxz1xbe4vQodmUCSmJrCsnfe/VrFUAnl1a9g0ckFOWiZSOK9vgdhupUcslaDZ10NxadrmgiuJRJDIZWg8rm/5BWaAZDIZPvvsM6HDIKqQKtvnvsEl0wCwZs0aSKVSHDx4ECdPnoSnpycOHDiA+fPnIzQ0VOvGxG3btmn1ZM+ePRsA0L59+wqfTD8PDMPJMcvhMWM4Gn/RBxnxifBftpvT4hVTNfc66PHHPPXjBh/3RIOPeyL24h0cH1gxfwYuDWy30lV/VDdkvUiB/9LdmhtEIkClgtTMBJ13zIC1G3vP3iQjIwPffvstli9frjErFBGVXGX73DfIZNrc3BybNm3Cpk2bNMpv376NJk2aQCzWvOnm9OnT5Ridfory80eUn7/QYRi02Et34F1jkNBhGBy2W+l7e9JAOHVrgfvefyPyn+vITc+E3M4GdYe0R71hnWBSreyW0q4oFAoFrly5AoVCIXQoRBVOZfvcN8hkOj+JiYmIiopCr169SnQchUKBnJwc5OTkQKVSITMzEyKRqNB5SImIylOVBs7wXPYZPJdxqAIRkZAqTDIdFBQEoOQ3H/r4+GDMmDHqx3K5HM7OzsWab5qIiIiIKocKMwlpaSXTo0ePhkql0vjDRJqIqGIxNjbGzJkz+asjEZVYhUmmx40bB5VKhTZt2ggdChER6TmpVIp+/fpBKpUKHQoRGbgKk0wTEREVVXp6OoYOHYr09HShQyEiA8dkmoiIKh2lUolHjx5BqVQKHQoRGTgm00REREREOmIyTURERESkIybTRERU6ZiYmGD16tUwMTEROhQiMnAVZp5pIiKiopJIJPD09BQ6DCKqANgzTURElU5qaio6duyI1NRUoUMhIgPHnukKxMLFXugQdKJvcetbPIB+xvQqfYxPH2Mi/ZKWliZ0CERUATCZrkA6/zJd6BAqBLZj8bHNiIiosuIwDyIiIiIiHTGZJiKiSkcul2P37t2Qy+VCh0JEBo7JNBERVTpisRh2dnYQi/k1SEQlw08RIiKqdNLS0tCpUyfehFgCElMTDPbfhKrudYQOpVRIzEwwNHALqjR0FjoUMjBMpomIiKjYmozvh+eBD/E8MAxWdWtixMNdqPdhF4065o7VMfzBL2j4eW8AgL1nI4yK3Iua7d016lVrWhejHu9BrfdaFzuO2v3ewcjw3VpJsMhIjF5/LUFnnxno+ut3eO/QIohe+yXCpkltjIzYDefenshNy8SdTUfQcs5HxY6BKjcm00RERFQsRsZS1P+oGx74/AMASAqNwfX5Pmg17yP1tJQisRhe6yfiWeBD3N10BAAQe+kO7m4+gndWjoNxFXMAgERujHbrJyHs97N4fPRKvuez92yEQVc35Lvt0Z8XEH7kEtqtnwQjY6m63H3yIJg7VceFyetxfvJ6WLrao8nE/v89BxMZ2q2biId/nEPEkUsAgNC9p2Dv2RDW9Z1K2EJUmTCZJiIiomJx6NgURiYyxJwJVJfd9z6Op5fvod26iRAZidFkYn9Yuznh/KS1Gvv6L92NrIQUeC7/HADQasEYiIzEuDL7Z53juTxjK6RmJvCY+SGAvJ7uJhP748KUDch8noyMuERc/Hoj3KcMUg9Laf7dCIhlUlyZ9d95M58nI+76A9QZ2E7nWKjy4TzTRERUobRs2bLQOiqVCklJSbCwsIBIJCqHqCoWO89GSLj9CCqFUqP8wpQN6HvqR3itnQiX3m1wbsJapD9J0KijzMnF2S9Xo/expfBaOwG1+72L4wO+R25aps7x5KSk4+yEtejx2xzEXriNFrNHIniXH6L8/NV1Hh+/htB9p9Fu3URcX+CD+qO64viAOVrnjfcPgf07jXWOhSof9kwTEVGlIxKJYGlpyURaRxa1bLWSZADIiE/EjSW74dr/XTz++xoeHbyQ7/6JDyJxZ/MR1BnUHne3/IW4aw9KHFPclXsI2nAQHX/+BiqVCtfn79Cqc+17b0AkQsefv0HQmgOIvxGsVSf9SQIsnG1LHA9VHuyZJiIiomIxMpEhOzldq1xkJEa9YR2Rk5aBqk1cITEzybfHWWJmAtd+7yInLQO2LetDJBZDpfyvl9vMoRr6nVn533HFYhgZS/FhqI+6LDXqGQ52mKJx3IAV++A+aSBur/sTisxsrfPmZmTh9k+H4Ln0UwSu+j3f56bIyoaRiazwRiD6F5NpIiIiKpbM58kwtjbXKnefPAiWrjVwuPs0dNs9C63mjcbFrzdq1Wuz6BMocxU40nM6eh1ejCYT++PWqv3q7emxCTjU5Rv14+oe9dD8uxE4PnCOukyZm6t1XFWuIm+bQlFg7KqcvP1eH6LykrG1OTKfJxe4P9HrOMyDiIiIiuV50EOtGS+qNauHtycNwMVvNiE5LAbnJq1D3WEd4di1uUY9516t4TrAC+fGr0FSSDQuz9oG9ymDYNOktrqOSqFESnis+k/6kwSoFAqNsrSoZ2Xy3KwbOON54MMyOTZVTEymiYiIqFiiT96EhbMdTGtWBfDv9HbrJiJs/3/T2z29dBd3Nx3BOyu+gHFVSwCA3NYanss/R+Cq/XgWEAoAePj7WUT+fR1eaydqTG0nFPvWDRDle0PoMMiAMJkmIiKiYkkKicaTC7dRZ1B7AEDL+aMhkog1ppkDAP9lu5HxLBltf8ibBu/d1eOREv4Ut1bv16h38dtNMLYyU09tJxT7to0gMTPBo8MXBY2DDItIpVKphA6CiIiIytef7ScjMThK5/1tWzdA+58m44+2E/K92c8Qddk5E7GX7uL2+j/z3W7t5oh+Z1aVa0z6rKTvofJWVq8fb0DUM34fLUVKeKzQYRgUCxd7dP5leqkec8oVIFr7RnVBOJgCK4u/wm65Y5vpRl+u+bK4jspKnwknEBYl/A1idRwtcWhtV6HDEEzclXsI/L/fYFHL1qASqoJIzEwQdyMYdzcfKdfz6stnAGBYnwP6hMm0nkkJj60QH0qGLjodeJgidBSGhW2mG17zxRcWlYy7YYlCh0EAgnf6Ch1CqclNy8StlflPl1eW+Blg+DhmmoiIiIhIR0ymiYiIiIh0xGSaiIiIiEhHTKaJiIiIiHTEGxCJiIiI9Ny7q75E3aEdAeQtl57xNBFPLtyG/+JdSI9NEDi6yo3JNFEpC189Gs9P/pL3QGwEWVUHWHr0hMOIRZBYVhU2OCIiMlixl+/izGf/B5GRGBYudmizeCw6bJ6Ko32+Ezq0So3JNFEZMG/oBddv90GlyEV62A1ErBuL7GeRqPf9X0KHRkREBkqZnYuM+EQAQHpsAh7s9EWbRZ9Aai5HTmqGsMHpqCL0uDOZJioDIokM0ir2AABZNUdkRNxGzO7voczKgNhYLnB0RERk6OR2VeDSuw2UuQqoFEqhwykRQ+9xrxQ3IC5ZsgSDBw+Gq6srRCIRXFxchA6JKhmxsRxQKqFS5AodChERGSj7to3wYagPRjzchaEBW2Dv2Qh3t/yF3IwsAICpvQ0GXf8JJlUtAQBGchkGXFgL67dqCRl2oV72uKfHJuDp5Xt4sNMXti3rQ2puGJ1PlaJneubMmbCxsYGHhwcSExOFDocqmYzHdxF3dD3M3FrDyNRC6HCIiMhAxfuH4PykdTAylsKlT1vU9HobN5ftVm9Pj03A3U1H0HLeaJwbvwZNpw5BxLErSLz/WMCoi8cQe9wrRTIdFhYGV1dXAEDjxo2RmpoqcETFZ9emARp93gc2jV1g7lgd/st249aq/UKHRQVIuX0aN4eaQ6VUQJWTBYu3O8N53Cahw9JLN/qK3rhdZuuMJlvCyycYA9L11+8gNTfFsX6zoVL+94Vj06Q2eh1ZjLNfrkHEkUsCRqjfti/wgqOdGbp+dlzoUIiKTJGZjZTwWABAwA97YeFij9aLPsHFrzeq69zbdgy9jy9Dg7Hvwfm91jjU+Wuhwi2ylz3uIrEYErkxAOD2T4fUPe61erZC068Ga+xj5eaIq7O3I/Kf63jvyCIc6T4Nmc+TYSSXoa/vjzj5yQ/l9p8Ig06mAwMD8f333+P06dNQqVTo1KkTfvrpJ7i5uaFXr17Ys2cPAKgTaUMmMTVBYkgkHh44h1bzxwgdDhXCzK01XCb/ApFYAqlNTYilMqFD0ltvez9R/zv1/kU8XDoQDVb6Q1qlRl6h2EigyPTb+cnr0ffkj2gysb/6P9ZGJjK0WzcRD/84x0SaqBIIWLEX/c+uxgOfE3geGAYAUCmVuDbHGz3+mIeTHy9XJ6T6rLAe98fHruLxsavqx7V6tITHjOEI/e00FBnZgvfGG+yYaT8/P7Rp0wYPHjzArFmzsHjxYkRFRaFnz55ITU1F06ZNhQ6xVEWfvAn/xb8i/NBFKLNzhA6HCiGWyWFSoy6M7VyYSBdCWsVe/UdibgMAkFhW/6/cqrrAEeqnjLhEXPx6I9ynDEJV9zoAgObfjYBYJsWVWT8LHB0RlYeUR7GIPHEdHtM/0Ch36NwM6bEJqKLnY6VfetnjnvggEgE/7EVKZBxaL/ok37qmNWzQevFYnPliFRQZ2QDyeuOt3ZzUvfGBP/5WnuEbZjIdHx+PoUOHwsPDAzdv3sQ333yD8ePHw8/PD48f5/1PpKIl00REr3t8/BpC951Gu3UT4dStBeqP6opz49cgNy1T6NCIqJzc3nAIDh2awt6zEQDA+q1aqNWjFY70nI56wzvDvJatwBEWX8CKvag7tKO6o0BNJEK7dZMQtO5PvLgXoS5+2RvfesHHuL7Ap9x74w1ymMeyZcvw4sULbN++HXL5f3d6WllZwcPDA35+foIk07m5uYiNjS3RMXJyONtDceXk5CIqKqqUj2kHQFqqx9RVTk4OoqKeCh1GodhmuinpNX/te2+8f+IHdPz5G9xauR/xN4J1jqO0r6OykpujH7/O5ebkGEyb5YffN8VXNt83RXsdzk9en295/PUH8K4xSP3Yc9lnuDbHG+mxCbi5fA9aL/oEfiOXFDmW4jy/snoPvdrjfuKDhepy98kDkZ2Sjvs/H9Pa59Xe+FeHhLwe75uen729PSSS4qfGBplM79mzB15eXnBzc8t3u52dHezt7Yt93KysLHUPd3x8PGrUqIEJEyZgwoQJRdo/NjYWTk5OxT7vqxZW7QoHqWWJjlHZBAcHY0gJ2/11DdfehrxWI532dZnkXaqxBAcHw6l741I9ZlkoSZuVNkNpM6Dk13xuRhZu/3QInks/ReCq33U+TllcR2Wm3jzAxEHoKPLeZ04fFF5RT/H7pvjK4jopzdeh3oddkPksCVF+/gCAsN/OoN4HnVDrvdZ4fPRKofsX9/mV5Xvo9oZD6HV4Eew9GyH20h3YtqyPesM743C3b7Tqvtob/97hRQjbfxapj+O06hX2/CIjI+Ho6FjsWA0umY6NjUV0dDSGDh2qtU2pVCIoKAjNmjXT6di5ubmwt7fHP//8A1dXV9y6dQvdu3eHnZ0dhgwZUtLQiYjKhOrf3iFDmUaKiMpGyC5fhOzy1Sg7PmCOQNEUTVF63GWWpvBaOxHnJ61D1gvtGdlK0htfGgwumU5LSwMAiETa02kdPHgQcXFxOg/xMDMzw4IFC9SPmzZtij59+uD8+fNFSqbt7e0RGRmp07lfujRkKdIelWyoSGXj5uaGyH2le8PVhLt2iNSTYadubm74u4Tvq/LANtONvlzzZXEdlZXOX5xH8OM0ocOAm5sb/E4axvssP/ry3jMkZXGd6NPrUNznV16x1/+oO+S21mg1b7RGeehvZ5CTllnk3vjCnp8uoxoAA0ymnZycYGRkhDNnzmiUR0REqIdjlNZ46ZycHJw7dw5ff120ORolEolOPw+8SirN/yWRmJrAsnbeiyyWSiCvbg2bRi7ISctUzzlZWUmlJW93rWOGANCTxFAqlZb68ysLbDPdFHTNl7eyuI7KikSqH2PzJQb0PsuPvrz3DEmZfN/o0etQ3OdXXrEHrT2AoLUHCtxe1N74svqc059XsIhkMhlGjRqF7du3o2/fvujVqxciIyOxZcsW2NnZITo6WiuZ9vHxQURE3l2f8fHxyM7OxsKFeQPanZ2dMXLkyHzPNX78eFhYWGDUqFFl+pyKopp7HfT4Y576cYOPe6LBxz0Re/EOjg/U759wiIiIiCoqg0umAWDNmjWQSqU4ePAgTp48CU9PTxw4cADz589HaGio1o2J27Zt0+rJnj17NgCgffv2+SbTX331FS5duoSTJ09CJhN+nuDYS3c07tYlqogsmnRA84MqocMwOKH7TiN032mhwzAoY2afEzoEIqogDDKZNjc3x6ZNm7Bpk+byzLdv30aTJk0gFmtOn3369OliHX/y5Mnw8/PDyZMnUa1atZKGS0REREQVlEEu2pKfxMREREVFlXi89MSJE+Hr64uTJ0+ienWuvEZvlhZ6A8FzuuHBdx0RvXOWxraY3XMRNNYZIXN7qMtUKhUi1n2KBzPaIWROd2THG+7NS0REJAxL1xoY9XgPqnvUy3d7j/3z4Lnss3KOqvIyyJ7p/AQFBQEo2c2HERERWLt2LYyNjVG7dm11uZeXF44d054gnCo3ZU42YnZ+hzrT/4CR3Fxre/Xun6Nqx1F4vHGcuizpykGIpMaov+Qs0kJvIHrHdNSeuqs8wyYiIgPnPmUQYi/dzXebY5fmyEnNKOeIKjcm069wdnaGSsXxmlQ0aQ8uQWxihkcrhkGZnYGaHy6E+Vue6u1SmxrIehqusU9mTDBM67YAAJjW8UDKXY7bJCKioqvWrB4y4hLzn1deJMJbY3rg3ta/UKtHq/IPrpKqMMM8xo0bB5VKhTZt2ggdClUSOQkxyAi/hdpTd8NlojciNhT+k5rcuQmSb/4NlUqF5Jt/IzdJe4UmIiKigrw9aQCC1uU/TVzdIR0QcfQKFJk55RxV5VZheqaJypuRuQ3MG7wDI1OLvD/GZlCkJ8PItOClVa2a90Tag8sIntURpi7ukLu8XY4RExGVDSO5DN33zYF1PUdcmrYZjw5e0Krj1K0F3p44AIqcXAT7nMDDP86hWtO6aDE7b0YtibkJRCIRDnf7tsDzVHWvg1bzx0AkFuHez8fw6MB5je3uUwahxrtNAAAWte1xe/1B3Nt2FG1XfAHHLs0R+fc1XJq2WWMf+7aN0GP/POx9eywy4hNL2BJly7GzB54HhuW7CqCRsRSuA7xwYvhC2LVqIEB0lReT6QpGYmqC/udX4+SY5XgeGCZ0OCUmMTPBwItr8c8HC/HiboTQ4Wgwc2uNJ3vmQaXIhTIzrdBE+qWaw/PmC08O9INIalzWYRIRlTllVi5OffwD6o/qln8FkQjNv/sQR3rOgCIrGz3+mIfIEzfwLCBUvVZCw097wcjkzVPRtl7wMc78byUynyWh15HFiPz7OnLT/1stKnDl7whc+TsA4P1/liPir8sAgIAV+/Bw/znU7veO1jEbff4+ngWE6vK0y51NYxfYt20E25b1Yf1WLVjWqYlTn/yAjLhEmNeyhczKDF18ZkBmbQ65rTXqDG6PsN/OFH5gKpEKM8yD8jQZ3w/PAx/ieWAYrOrWxIiHu1Dvwy4adcwdq2P4g1/Q8PPeAAB7z0YYFbkXNdu7a9Sr1rQuRj3eg1rvtS52HLX7vYOR4btRpaGzRrnISIxefy1BZ58Z6Prrd3jv0CKIXpvK0KZJbYyM2A3n3p7ITcvEnU1H0HLOR8WOoaxJzK1RvccXePBdBwTP6QbHMT8gyf84Es78CgCI/3szHq0cgbTQ6wie3QXZz2OQm/wsr/7sLkg4sws1hnHBHSIyfCql8o29uiY2Fsh8lozc9EyoFEokhcZozURRu/+7Wj3NrzIylkIskyAt+hkUWTmIu/4AVd1d861r7eaI7KQ0pMcmAID679e5vO+J6NMByE3PKuQZ6odbq//A34Pn4cTwRXhy9hauzfGGTSMX1O7/LpJConGkxzScGL4INxbsRLTfTSbS5YQ90xWIkbEU9T/qhnMT1gIAkkJjcH2+D1rN+wixF24jJTwWIrEYXusn4lngQ9zddARA3oIwdzcfwTsrx+FQ56nIepEKidwY7dZPQtjvZ7XWtn/J3rMR3l39JX5vNU5r26M/L8CxS3O0Wz8JR3pMgyIrb/yW++RBMHeqDr9RSyAyEqPvyR/RZGJ/3Fq1P+85mMjQbt1EPPzjHCKOXAIAhO49BY/pH8C6vhMSH+jXVHJVO41C1U75r5BZvftnqN5dexx1/UWnyzgqIiL9kvk8GSbVLCG3tUZOWibsWjfAk7O31NstXWtAmZOL1Kj4Ao8hszZHdlKa+nFWUhqMrbVnUgIA14Ht8PANiTkAiCRGqPdhF/iNXAKX3p5vrKuPzk9eX+C22Et3EHvpTjlGU7mxZ7oCcejYFEYmMsScCVSX3fc+jqeX76HduokQGYnRZGJ/WLs54fyktRr7+i/djayEFHgu/xwA0GrBGIiMxLgy+2ed47k8YyukZibwmPkhgLye7iYT++PClA3IfJ6MjLhEXPx6I9ynDEJV9zoAgObfjYBYJsWVWf+dN/N5MuKuP0Cdge10joWIiIR1adpmtFs/Ce1/moLEB5FIf/pfb7HrAC88/OPNyW92UhpkVmbqxzJLM2Qlao8dBgDn91qrO2QKUn9EVzzcfxbKnNxiPAsibUymKxA7z0ZIuP1Ia7qcC1M2wMLFDl5rJ6LpV4NxefoWpD/R/MlLmZOLs1+uhmNnD3itnYC6Qzvi3IQ1yE3LhK5yUtJxdsJaNBjTA07dWsBr7QQE7/JDlJ+/us7j49cQuu802q2bCKduLVB/VFecG6993nj/ENi/01jnWIiISFhPL9/D34Pn4cwXKyExNUb8jRD1Npc+bRF++KL6scTMBDJLU439FZnZUGbnwtTeBmKZBLYt3PD81kOt89i2eguJIVHITk5/YzzWbznBdWA7dP31O1RpUAvtNkwCRKISPkuqjDjMowKxqGWrlSQDQEZ8Im4s2Y13VnyB8COX8r3LGgASH0TizuYjcJ80ELd/OoS4aw9KHFPclXsI2nAQHX/+BskPn+D6/B1ada597433T/yAjj9/g1sr9yP+RrBWnfQnCbBwti1xPEXlYFp4nfKiT7G8iT7FqU+xFMbCxV7oEADoTxxFUcex8Bt9y4O+xKEvOmz9GlUb10ZueiaqedTDtTnecOjYFDJrczw6cB4t5oxC1SauUOYq4L/kV3WPcLVm9ZAS8RRZCSnqY9Xu9y4kJjLc23ZU4xxXv9+O9pu+gkgswp1Nh5Gblgl5dWs0/Lw3bizcCSD/Xm73KYPg1KMl5NWs0W3v9/hn2AJcnr5Fvb3H/nk4O241IMBaE/p07elTLIZEpOIqJXrlz/aTkRgcpdO+XXfPQkZcIs5PWqdRLjISo+efC1ClQS1kPkvGwc5T8+1xlpiZoK/fjzCpZokX9x7jWN/ZUCn/6+U2c6iGfmdW/ndcsRhGxlLkZvx340Zq1DMc7DBF8/wSI3wUuRfnJ61D6L7T+cZe78Mu8Fz6KXxcPsh3Inq3EV3Qcu5H2FV3pNY2azdH9DuzKt/jEhFR/kryfVPWWi0Yg8BV+5H1PFnoUDTw+0aTPr+H8lNWrx97piuQzOfJ+d6M4T55ECxda+Bw92notnsWWs0bjYtfb9Sq12bRJ1DmKnCk53T0OrxY48ZAIO9u6ENdvlE/ru5RD82/G6Ge1ggAlLnaY89UuYq8bQpFgbGr/u2hyHdFJwDG1ubI1LMPVSIiKhtXZ28XOgSiIuOY6QrkedBDWNd30iir1qwe3p40ABe/2YTksBicm7QOdYd1hGPX5hr1nHu1husAL5wbvwZJIdG4PGsb3KcMgk2T2uo6KoUSKeGx6j/pTxKgUig0ytKinpXJc7Nu4Izngdpj44iIiIiExGS6Aok+eRMWznYwrVkVAPKmt1s3EWH7/5ve7umlu7i76QjeWfEFjKvmjfeT21rDc/nnCFy1Xz1x/cPfzyLy7+vwWjsRRsZSYZ7QK+xbN0CU7w2hwyAiIqIyYO3miJ4HF6DHgfno/tscmNfSvE/KqVsL9DqyGD0OzIfrAC91eetFn+C9w4vQ6+gSOHRsWs5R52EyXYEkhUTjyYXbqDOoPQCg5fzREEnEGtPMAYD/st3IeJaMtj/kTYP37urxSAl/ilur92vUu/jtJhhbmamnthOKfdtGkJiZ4NErd3oTERFRxZH5PBm+I5bgeP/vcXvDQbhPGfTfxn9X0Px7yHz8PWgu6n/UDVILU1jVc4BVPUccff87nPxoGZpN/0CQ2DlmuoK5+cNetP9pMu5uPoJL32zKt44yOxeHOk9VPz7xwcJ862UnpmJfM+1FR16KvXQn3wVb8uNdY9Abt4fuO13gzYmNx/VF0Lo/ocjILtK5iIiIyLC8el+UMkehcQ/VqytoAlCvoPnsZggUWdkQGYkhszLVmBGmPLFnuoKJu3IPgf/3Gyxqld80cmVJYmaCuBvBuLv5iNChEBERURkzMpGh6TdDcHfrf9MivrqCpsTMBHatG8DY2hzZyelIfRyHARfWosf+eQhae0CQmNkzXQEF7/QVOoRSk5uWiVsrfxc6DCIiIipjIiMx2m2YhDs/HULi/cca216uoJmbka1eQbNme3fIba2x33M8ZFZm6LF/Hg53+6bAmcHKCnumiYiIiEhw7/z4P8ScDsTj49e0tuW7gqYIeUvKq1TISc2AkUwCscSo3ONmzzQRERERCcqhY1O49GkLcydb1O77DhLuPEL0qYA3rqD55GwQXPu9i55/LoCRsRT3th2DIiun3GNnMk1EREREgoo+FYCdrgXPHnZ93g6tMpVSifOT15dlWEXCYR5ERERERDpiMk1EREREpCMO86hERjzchWc381Y4vLv1Lzw+dlVj+7urvkSVhs7ISclAUlg0Ln27GeaO1dFuw2Qoc3MhMjLC5elb8OJeRIHn6LJzJiSmxpDIjXFn42E8OnhBY7uRiQzv/N84mNWsipSIp7j49UYoc3IL3Y+IiIhIHzGZrkTSop/h+MA5b6xzefoWxPuH/LfPk+c42ncWoFLB/p3GeHviAJz538oC9z85ZjmUObmQmsvx/t/LtZLiesM64cW9CJwdtwrNpn8A1/7vInTf6UL3I8PQpUsXODo6wtvbW+hQCpWTk4PvvvsOPj4+SExMRPPmzbF69Wo0b95c6NCIiMiAcJhHJSK3q4Ief8xD+5+mwKSqZb51Wi34GD3+mKde316lUAIqFQBAZiFHwt3wN55DmZMLAJCYGiMxOFJru13rBog8cQMAEHn8Guw8GxZpP6o8srPLZ6XLb775Btu2bcOmTZtw7do1uLq6okuXLoiNjS2X8xMRUcXAnulKZH+bL5GVkILa/d9Fy7kf4dyEtRrbr83fgayEFJhUs0KP/XMRfyMY2cnpsGnkgjZLP4VZzWo49ckPhZ6nxx/zYO3miBuLf9XaJqtijuykVABAVlIqjK0tirRfeZtyBYhOFzqKPA6mwMrW5Xe+9evXY/369QgLC4OVlRW8vLywf/9+uLi4YOzYsZg1a5a67tixYxEaGorTp09j9OjR8PPzAwD88ssvAIBTp06hQ4cObzyfi4sLRowYgYSEBOzduxd169ZF8+bNcfToUQQEBMDa2hoA8PHHH+PChQu4ceMGYmNj4eHhgXnz5mHKlCkAgHv37qFFixZYuXIlPvvsszeeMzk5GRs3bsSaNWvQp08fAMD27dvh4OCAjRs3Yu7cuTq0XNH5fbQUKeH6m7RbuNij8y/ThQ6DiMggMJmuRF6uWR9+6CLenjigwO2Zz5LwLPAhLGrXwPPAMCTcCcfR97+DTZPa8Fz2Gf56b8Ybz3N8wBzIrMzQ+9hShB++hJyU/7LS7MRUyCzNkP4kATJLM2QlphRpv/IWnQ48TCm8XkUzZ84c/Pjjj1i6dCm6deuG1NRUHDt2rEj7rl69Gg8fPkSNGjWwevVqAICNjU2R9l2zZg2++uorXLp0Cbm5uXB1dcX58+fx6aef4rfffsOvv/6KXbt24fLlyzA3N0fdunXx008/4eOPP0b79u3RsGFDDB06FL169So0kQaAGzduICsrCz169FCXGRkZoWvXrjh//nyRYi6JlPBYJAZHlfl5iIio7DGZriQkcmMosnKgUiph16Zhvr1iUgtT5KSkw8hEBptGLkiLiodYJoEyO28IRk5yOhQZeT/BS8xMIDYSIzv5v4RXJBYDoryhIbkZWVBk5UCRpfmT/dPL9+DY2QOJDyLh1K0Fnl66W6T9qOylpaVh+fLlWLBgAcaPH68u9/DwKNL+VlZWkMlkkMvlsLe3L9a5W7ZsqdUbvHfvXrRo0QIzZszA+vXrsXz5cjRr1ky9/cMPP4Svry+GDRuGd955BykpKdiyZUuRzvfkyRMA0IrT3t4e/v7+xYqdiIgqNybTlYRVPQe0XfEFctIyocxR4NK3mwDkrTj0cnWh9j9NhtTCFGKpEe5sPITM58mwf6cxmn49BCqFEiKRCFfnegMAavd7FxITGe5tO6o+h8zKFB23fQOoALFUgqC1B6DMzoW8ujUaft4bNxbuRMjek3h35ZfocWA+0qLicWvV/gL3o/J1584dZGZmolu3buV+7latWmmVNWjQACtWrMC4cePQs2dPTJo0SavOunXr0KRJE+zYsQPnz5+HlZVVeYRLRESkxmS6knh+6yEOd/tWqzz6VID6374jFmttj71wG8cv3NYqr/KWEwJX7dcoy3qRiuMDtGcLyYhPxI2FOwEAioxsnPliZZH2I/0iFouh+vdm1Jdyckpn2VYzM7N8y8+cOQMjIyNERkYiMzMTJiYmGttDQ0MRExMDkUiE0NBQeHp6Ful8NWrUAADExsaiVq1a6vKnT5+qtxERERUFZ/MgnVydvR1Zz5OFDoNKUcOGDWFiYoJ//vkn3+22traIiYnRKLt586bGY5lMBoVCUSrxbNu2DYcOHcLZs2eRkpKivtHwpbS0NAwbNgzDhg3DihUr8OWXXyI0NLRIx27evDmMjY3x999/q8uUSiV8fX3x7rvvlkr8RERUObBnmogAAObm5pg6dSrmzp0LuVyOrl27IiMjA0ePHsWMGTPQpUsXbNiwAf3794ezszM2btyIiIgIjZsMa9eujVOnTqlnArGysoJUKi12LA8ePMCkSZOwatUqtG3bFrt370a7du3QrVs39O/fHwAwceJEKBQKrFu3DmZmZvD19cUHH3yAixcvFnpOS0tLfPHFF5g5cyZq1KiB2rVr44cffkBGRgY+//zzYsdLRESVF3umiUrowXcdEL52rFZ51tNw3OgrQurdsp8dorQsWLAAixYtwpo1a9C4cWN069ZNfUPetGnT0KtXLwwdOhReXl6wsrLC4MGDNfafOnUqqlWrBnd3d1SvXh0XLhR/8Z2srCwMGzYMPXr0UM/M4enpiXnz5mHs2LGIjIzEvn37sHPnTuzZswfm5uYQiUTw9vZGTEwMZs6cWaTz/PDDDxgzZgzGjh2L5s2bIyQkBCdOnOAwDyIiKhb2TBORmkgkwqRJk/K92c/CwgI+Pj5v3N/V1RVnz54t1jnDw8M1HhsbG2sNHwGAmTNnqhNlJycnDBkyRGN7tWrVEB0dXeTzSqVSLF++HMuXLy9WvERERK9iMk1EZADEUglGPd6j8/7eNQaVYjRERPRSpUimlyxZAn9/f9y4cQOPHj2Cs7OzVm8YEZW+xYsXY/HivFlilEql1vYzZ85oPM7Ozoa3tzdGjx4NmUz2xmO3bNmywG09e/bEuXPn8t3m5eVV5IVo9Il920Y40H4ykrjYCxGRXqkUyfTMmTNhY2MDDw8PJCYmCh0OVVKPVn2EZP9jkFjZotFa7ekGK6IvvvhCPRzj1q1bhdbPzs7G1q1bMXz48EKT6TfZunUrMjIy8t0ml8t1Pq6QrOo5IOZMoNBhEBHRaypFMh0WFgZXV1cAQOPGjZGamipwRFQZVevyMezen4RHq0YJHUq5sbGxUc/28eLFi3I7r4ODQ7mdy9AMuroBv7caJ3QYREQVhkHP5hEYGIi+ffvCysoKlpaW6NevH548eQILCwsMGzZMXe9lIm3IHDo1Q58TP2Bk+G4MuroBDT/vLXRI9C8jUyso0pO0yhVpiQAAkTRvoRGLxu1hZG6jVY+oMFZ1ayIptOg3VxKVBL9vqDRUpveRwfZM+/n5oXfv3nB2dsasWbMgl8vh7e2Nnj17IjU1FU2bNhU6xFJT1b0OOntPw+2Nh3Bm3CpUb1YPnss+gyIjGw925L/ABpUfE8e38OLCb1ApFBAZGanL00KuAmIjGNeoK2B0hkUikaBPnz6QSAz2o6lM2Hk2QujeUyU6Rst5o1GjbSPI7aqgz4kfkBQWo7UaKRG/b6g0VLb3kUF+Y8XHx2Po0KHw8PCAr6+vegzkyJEjUbt2bQCoUMl0o89641lAGPwX/woASAqJhnV9JzQZ369CvikNTfWe4xD/1zqErxkD2/cnQWJmjbSQq4jZNRvVOo+BxNxa6BANhomJCWbNmiV0GHrHyFgKZXau+nG3fXMglhrh+IA5wCtLvHfaPg2mNWzwV++ZUOVqrkR5bY43gLxhHoe6flMucZPh4fcNlYbK9j4yyGR62bJlePHiBbZv365xM5GVlRU8PDzg5+cnSDKdm5uL2NjYEh0jJydXq8y21VsI+dVPoyz6VAAaj+sL0xo2SH+SUKJzGrqcnFxERZXuDAc5OXYAirZyn7GtM+ovu4iYXbMQtvB9KNKTILN3hV3/b2D3vvZ8zcWPJQdRUU9LfByhpaWlFVonKysLa9aswcSJE2FsbPzGuqX9mpen/K7zVxnJZVBkZAMApOZyZCdptt35SWvR1+9HNBnfD0FrDwAA3EZ2Rc32b+Nwt2+0Emld4jPk9qWi4fdN8fHa0FTQZ5m+vo8Ke/3s7e11+mXUIJPpPXv2wMvLC25ubvlut7Ozg729vU7HHjduHA4fPoykpCRYWFhg8ODBWL58eZFmFoiNjYWTk5NO531pYdWucJBaapTJba2REZ+oUZYR9+LfbVUq/YdbcHAwhpSw3V/XcO1tyGs1KnJ909ruqDvrcKnG8FJwcDCcujcuk2OXp7FjtVeJfF12djaOHj2KatWqFXrNbd26tbRCK3f5XecAIDISo/nMD6HIzsHNZXlzStds746Ys5ozoaQ/ScCl6VvgtXYCok8FIDcjCy3nfoTr832QFBpT4vjK4poi/cPvm+LjtaGpoM8yfX0fFfb6RUZGwtHRsdjHNbgbEGNjYxEdHY3mzZtrbVMqlQgKCipRr/T48eNx//59JCcnIzAwEIGBgep5colKImzZYNyf5onM6Ae49bEj4o5uEDok0jMqhRI3V+xFjXeaqMtM7W2Q8VR7JpTwQxcRfvgS2q2fiHbrJ+Hp5Xu47328PMMlIiIYYM/0y5+KRSKR1raDBw8iLi6uRMl0w4YN1f9WqVQQi8UICQkp0r729vaIjIzU+dwAcGnIUqQ90hwqkhGXCHl1a40yk38fv/yfXmXm5uaGyH0/l+oxJ9y1Q2RmqR4Sdab9ptN+bm5u+LuE7yt9EBoaWmidtLQ07NixA0OGDIGZmdkb686ZM6e0Qit3+V3nLykyspH5PAlmDtWQFv0MqnwWu3npysytGHxzM6BUwW/kklKLryyuKdI//L4pPl4bmgr6LNPX91Fhr5+uoxoMLpl2cnKCkZGR1sppERERmDBhAoCS33y4dOlSLFy4EGlpaahatSqWLl1apP0kEolOPw+8SirVfknirt5HzQ5NEbjyd3WZQ8emSI2Mq/Q/uQF5bVbSdtc6ZgiAUk6mdSWVSkv9+QnhyZMnhdaRSqUYO3YsrK2tCx3mYchtkt91/qrIEzfg2KU5nt96iGcBYQXWcx3YDiKRCGK5FFXfdkWUn3+h504swgqKZXFNkf7h903x8drQVNBnmb6+j8rq9TO4YR4ymQyjRo3C9evX0bdvX2zevBmzZ89G69atUbVqVQDaybSPjw8WLlyIhQsXIj4+HklJSerHPj4+WueYPn06UlNTcffuXXzxxReoUaNGeTy1At3ZfATVm9VFs+kfwKpuTdQZ3B4NPu6JoHV/ChoXUWmTyWT47LPPSrT6YUUQ5XsDTl2bo1rTOnh2M/9fxqzqOaDF7JG4Mns77m07hrY//g/GNhaFHtt3BIetUcH4fUOlobK9jwyuZxoA1qxZA6lUioMHD+LkyZPw9PTEgQMHMH/+fISGhmrdmLht2zatnuzZs2cDANq3b4+RI0fme54GDRrA3d0dI0eOxKlTJZvjtSSeB4bh5Jjl8JgxHI2/6IOM+ET4L9tdIaeXocotIyMD3377LZYvX26wy36Xhoy4REjN5ZDI85/RRCQxgte6iYg5ewshu3xhZCxFzXZvw3P55zg9dkU5R0sVCb9vqDRUtveRQSbT5ubm2LRpEzZt2qRRfvv2bTRp0gRisWaH++nTp3U+V05ODoKDg3Xev7RE+fkX6SdcIkOmUChw5coVKBQlm9qtIog5E4iUiPynRGz27VCY1agK3+GLAACKrBycG78GvY4uQZ3B7RH225l89yMqCn7fUGmoTO8jgxvmUZDExERERUWVaLx0UlISvL29kZiYCJVKhVu3bmHhwoXo3r176QVKFZIyKx33v/VEwHBrJJzdo7U9ZvdcBI11RsjcHgJER4Yo+Fc/RJ8K0Cq3bfUWGv+vLy5M/QmZz5PV5Ql3whGwYh9aL/gYZg7VyjFSIqLKrcIk00FBQQBKdvOhSCTCzp074erqCgsLC/Tr1w/vvfce1q5dW0pRUkUlkhijzowDsH1/cr7bq3f/HG4LhRsqRIYn4+kL5KZr3wUbd/U+djgNRdSJG1rbgtYewK9vfYS06GflESIREcFAh3nkpzSSaUtLS/j6+pZSRFSZiIyMIK1S8JQ6UpsayHoaXn4BGShjY2PMnDmz0NUPiYiI9EWF6ZkeN24cVCoV2rRpI3QoRKQjqVSKfv36QSot2lLuREREQqswyTQRGb709HQMHToU6enpQodCRERUJEymiUhvKJVKPHr0CMo3rPpHRESkTyrMmGkioYUtHYj0hzchNjFDWvAVWHp0hyIlATbthyP+7814fmoHMqPuI3h2F7hM3gFZ1ZpCh0xEREQlxGSaqJTUmb6/wG3Vu3+G6t0/K8doiIiIqDxwmAcR6Q0TExOsXr0aJiYmQodCRERUJOyZJiK9IZFI4OnpKXQYRERERcaeaSLSG6mpqejYsSNSU1OFDoWIiKhI2DOtZyxcCl74g/JXFm3mYFrqh9SZPsVSHtLS0oQOoczp+3Wu7/FR6eDrXHxsM02G1h5lFa9IpVKpyuTIRESvuHbtWqF1UlNT0alTJ5w8eRLm5uZvrNuyZcvSCo2IiEhnHOZBRERERKQjJtNEpDfkcjl2794NuVwudChERERFwmSaiPSGWCyGnZ0dxGJ+NBERkWHgNxYR6Y20tDR06tSpUtyESEREFQOTaSIiIiIiHTGZJiIiIiLSEZNpIiIiIiIdcZ5pItIbKpUKKSkpsLCwgEgkEjocIiKiQjGZJiIiIiLSEYd5EBERERHpiMk0EREREZGOmEwTEREREemIyTQRERERkY6YTBMRERER6YjJNBERERGRjphMExERERHpiMk0EREREZGOmEwTEREREemIyTQRERERkY6YTBMRERER6YjJNBERERGRjphMExERERHp6P8BPZPBMHhXqUwAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 7, From 63ac13adbd5a22e879136bf914a5cc2531ec4526 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 16:06:18 -0600 Subject: [PATCH 053/128] clean up tutorial --- .../tutorials/04_automatic_cut_finding.ipynb | 39 ++++++++----------- 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index c8d9b26ce..4ff016504 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,9 +21,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 1, @@ -35,8 +35,7 @@ "import numpy as np\n", "from qiskit.circuit.random import random_circuit\n", "from qiskit.quantum_info import PauliList\n", - "\n", - "circuit = random_circuit(7, 6, max_operands=2, seed=54)\n", + "circuit = random_circuit(7, 6, max_operands=2, seed=114)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")" ] @@ -45,7 +44,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Find cut locations, given two QPUs with 4 qubits each" + "#### Find cut locations, given two QPUs with 4 qubits each. This circuit can be separated by a single wire cut." ] }, { @@ -53,18 +52,11 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CircuitElement(name='xx_plus_yy', params=[0.6672202688920147, 0.5661694284168217], qubits=[4, 1], gamma=2.524280188101553) 2\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAGRCAYAAACT7EP6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACIlklEQVR4nOzdeVRU9f/H8ecMM2yyKSogomiKmUtq5lJami2allambdq+WWb9Wr6WltpimZVmq1lpe1ppmpWVa1mamkuu4C4giIoIss/y+4PCEBBQ4N7B1+Mcj8zn3jv3NXfmLvOeez/X4na73YiIiIiIiIiImJjV6AAiIiIiIiIiImVRAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0bEYHEPN65E9IzDI6RYFIf5jU2egUUlkW3foSGXuSjY5RpsDocHp9NLJC02i9OTVmWW5aZhXnSctMREREPJsKGFKqxCzYlWF0CqmJMvYkkxaXYHSMKqH15tRouVWclpmIiIicaXQJiYiIiIiIiIiYngoYIiIiIiIiImJ6KmCIiIiIiIiIiOmpgCEiIiIiIiIipqdOPKVS7Hn9Ng4v/qjggdWKvXYEgW0uIXLoi3iHRhobTkRqjNhRPfAJb0b08PeLtOce2MOme5rQ4sXfCDinm0HpzEnbZxEREakpdAaGVJqAc7rTdkYSbd7fR5NHPydr9zp2Tbje6FgiImc8bZ9FRESkJlABQyqNxeaNvXY43qGRBLa6iHqX30Nm7AqcWelGRxMROaNp+ywiIiI1gQoYUiXyDu/nyB9fg9Wr4J+IiJiCts8iIiLiqdQHhlSajE1LWTc4ALfLhTsvG4CwAY/i5VsLgCMr5pA0c1yRaXLitxB11+vU63N/tecVkZpr9+RbSV/7I7bg+rR6Y5PRcQyn7bOIiIjUBB5dwNiwYQPPPPMMS5cuxe12c8kll/DOO+8QExND3759+fLLL42OeEapFdOZ6Ic/wp2Xw5Hls0jfsJAGNz9fOLx212uo3fWawsdpK78l8ZOnCL3kViPiinicjXdH02baHqNjeIS6l95B2FUj2D15qNFRTEHbZxEREakJPLaAsWjRIvr160fjxo0ZPXo0fn5+zJgxgz59+nDs2DHatWtndMQzjtXbD9+IZgD4NW5NbvJO4t8bTuMHpxUbN+9QAvumPkCzMT9i9fGv7qhiYpGXtOe8J28iuHlDslOOsOWDH9gydb7RscQkvPyDcWYdLdbuzEwDwGL3BSCw9cXkHthTjcnMTdtnEc+Q6YAf42FZcsHftX2gT0PoEQ42XfgtIuKZBYyDBw8yePBgOnTowMKFC/Hz8wNgyJAhNGnSBEAFDBOIuHEsmx9oSd0r7qVW846F7W6Xi92TbiH8upH4R7c1MKGYTei5Z9Frxv/Y9O48lg2bTL32zek64R6c2XnEfvyz0fEME//+I2RsWkJ+6n62PNwO3wYtaPrETKNjGcK34dkc+f0r3E4nFq/j/Tdkbl8FVi98/vmSLien7bOI+Sw/AE/9BVmOgscWwE1BMSPcDyZ3hmZBRiYUETGeR9ZyJ0yYwJEjR5g+fXph8QIgODiYDh06ACpgmIFvg+aEnH8V+z8dVaQ9adbzePkFUb/fcIOSiVm1uqcfh9bvZO34zzm6PZEds5ay9cMfafPgAKOjVQlXbjaJnz3Npvuas/Z6P9bfXIetj55PyndTiowXddckzpm8HnudBpwzef0ZW7wAqNdnGI60A+yZcjuZO/4iN2knqb9+wf7PnqZur9uxBYQYHdEjaPssYi5rDsGjqyDbcbzN/Z/hydlw3x+QmFnt0URETMUjCxhffvkl3bt3JyYmpsThYWFhhIeHA+BwOBgxYgR16tQhJCSEO++8k5ycnOqMe0YLu+Zx0tf/TMbGpQAc2/o7hxd+QPRD0w3NJeZUv9PZJC5ZV6Qtccl6AqLq4x9Rx6BUVWffu/eTuuRjGt42kVZvbiHm+SXUu/IBHP9cDiHF+dRvTIsJf+DMPMLO569iy4i2JH09nrBrHqfRfW8bHc+jaPssYg5uN0zaDC530aLFidLyYPr2aoslImJKHncJSXJyMomJiQwePLjYMJfLxcaNG2nfvn1h2/jx41myZAkbN27E29ubq6++mieeeIIpU6YUm74kDoeD5OTkSsvvSfLzwwB7ucaNHjGjxPaAlhdw3tyC3bHjWBq7Jw0h+qEZ2IJCK5gln4SEAxWaRswrP99RYrtf/RCyD6YVactOOfLPsNpkJaVWdbQi8vMdJCQkVHCa8q83aX9+S4Obnyeky4DCNv8m51ZofifP4jnrTUWWm3+Tc2k2+rsqylHzlpm2zyLmFpdpJ/ZoWDnGdPN9PAwM2U+A7WSlDhERzxAeHo7NVrGShMcVMDIzC86ds1gsxYbNnTuXlJSUIpePvP/++7z88stERkYCMHbsWK6//nomTZqE13+uny5NcnIyUVFRlRPew5zzxib8GrWqtOc7uOAd8o8kEf/hI0XaQ3veSlj/R0qZqkBcXBxRV7SutCxirOdDLyPSbv4LeePi4hhUwfW/IuuNvXYE6WsXUOeim7AFVv4ZJp603lT29mbnhOs5tnU5jvRD/H1HQ8IHPkX9K4eVOd2Zusy0fRYxTr0+95fzDDIL+W7o2HsgmbErqzyXiEhVi4+Pp2HDhhWaxuMKGFFRUXh5ebFs2bIi7Xv37mX48IJrdv8tYKSlpREfH1+koNGhQwcyMjLYs2cPZ511VnXFFiBi4JNEDHzS6BhiYtkpafjVCynS5vvP43/PxKhJGj/4PrtfvYkNQ+vhF9WKWi26EHzelQR37l9ikVbK76z/fWV0BI+i7bOIgSwVvKLbWvYPcCIiNZXHFTC8vb0ZOnQo06dPp3///vTt25f4+HimTZtGWFgYiYmJhQWLjIwMAEJCQgqn//fvf4eVJTw8nPj4+Mp8CR5j+JYw4k3SXUhMTAw/naHvQ020YtBLZO4ufmlWyqptNOjRjg2Tvi5si+zZjmPxKdV++QgUfO7iZ31YoWkqst4EtLyQ1lN3khm3iszYFWRs/pWdEwYSfF4fzho1r1gRwzfqnApl8aT1xizbGy2zivOkZSZiRhvSfRizo3zjWnGz8vtZhNhdVRtKRKQa/NtvZUV4XAEDYMqUKdjtdubOncvixYvp2rUrc+bM4dlnn2XHjh2FnXsGBgYCcPTo0cKFk5aWVmRYWWw2W4VPa6kp7NsBExwcA9jt9jP2faiJ7PaSNz2b35tP3+9eoP3IG9n19TLqtm9Oyzv6sHrsR9WcsIDdXvH1v6LrjcXLRkDLCwhoeQFhAx7l8NJP2TNpCMc2/0pg64uLjNv8mR8qlsWD1huzbG+0zCrOk5aZiBk1cMP7SZCQefJOPAEuaWChdZMG1ZJLRMSMPLKAERAQwNSpU5k6dWqR9k2bNtGmTRus1oJT8UJCQoiKimL9+vW0aNECgHXr1hEYGEh0dHR1xxaRMhzesJPFt79MhydvovV9V5N9MI21E74g9uOfjY5WbXwbtgTAcTTF4CQiIlIdrBa4/2x46i+wUHIRwwLYrXB782oOJyJiMh5ZwChJWloaCQkJ9O3bt0j7XXfdxYsvvkj37t2x2+2MHTuW2267rVwdeIpI9UtYtJaERWuNjlEtYp+6mDrdb8S/WUdswfXITdpB4idP4VUrhMA2PY2OJyIi1eTySEjPgwkbSx7u6wWvdIIWwdWbS0TEbGpMAWPjxoIt/n877AR46qmnOHToEK1atcLlcjFw4EAmTJhgQEIRkaKCO/Qh9dfP2P/FMziz0rEF1yew1UVEPzQdW1Bdo+OJiEg1GtgEOtWD92JhQWJBW6Q/XNMYrm4EdXyMzSciYgY1voBhs9mYMmUKU6ZMMSBVzZe9bzN7374Xi8WKxctG4wffxye8aeHwnS9ei+NYQeeLWdtX0+LlFXj5BbH71Zuw2Oy4nQ4a3f8O/tFtjXoJIoYJHziS8IEjjY5haod+fp9DCz8Eq5XG972DX3SbwmH7vxjL4UXT8W3YkuZjFxSZLicxjs3DW9Hixd8IaNGFlO/f5MjymbhdLnzCzyL6oQ+xeNWYXWCpytpGl7YMM3f8ReInT+J25BPQ8kIib3neiPgiZ5xGAXBj0+MFjPHnQavaxmYSETGTGnP0NmzYMIYNG2Z0jDOOLagezZ/+Hq9awRxdu4Ckmc8RPWJ64fCznpwNQP7Rg8SN7ol/dFvcTgctXlqOxWol/e/FJH81nqaPf2nUSxARk3JkpHJwwTuc/fJKcpN3se/d+4l5fnHh8HpX3Etoz6Hse7f4tj9p1nMEtjreCWrdy++hft8HAdg9aSjpGxYS3KF31b8Ig5W1jS5pGbry89j/6SjOGjkbL78AI2KLiIiIlKiCN54WKcoeUh+vWgUXZFq87KXem/zI8lnUvvD6f8azYfmno1VXVjp+Tc6tnrAi4lEyt68ioHUPLDY7vg1b4Eg/hNt1/NaB9joRYCm+G8uM/RN7SDjedY/fGcNq9wbA7XYDbnwimlV5fjMoaxtd0jLMjF2B1bcWu1+5gbine3Fs24pqyysiIiJyMipgSKVw5Waz/4sxhF01osThqcs+o87FNxc+ztq1nm1PdGXfew8S1LZXdcUUEQ/izEjFFnD83GmrXyDOrKNlTpf01QuEX1f80pzkr19i87AWODJS8a5zZt2GsKxt9H/lp+4ne8/fNHn0C6IfmsHet++phoQiIiIiZVMBQ06b2+lg96s3ET7gsSLXp/8rN3kXbpcT3//84unftB1nv7yCZqPmse+9B6szroh4CK+A2jgz0wofu7Iz8PI/eRf8R9d8X3BXl6DQYsPCB46k1dux+EY049CiGZWc1rzK2kafyCugDgEtL8TLPxDvelF4+dTCmZVeDUlFRERETk4FDDktbrebvW/eRVD7KwjpMqDEcVJ//Zw6F99U+NiVn1v4t5d/MFYf/6qOKSIeqFZMZzI2/4rb6SAnaQe2oLqFl5+VJmvXeo5tWsr2sb1JX/8LCR88Qn5qUuF2x2KxFGx3vP2q4yUYrjzb6BPViulMTmIcbqcDZ+ZRnFnpePkHVW1QERERkXKoMZ14ijHS1/1E6vJZ5KbsIXX5l/g3aUdQh944M1ILixapy2cSM+6XwmmObf2dpC/G/nMttpuoO14zJryImJotsA51L7uL2CcvAquVRve+xdG1Cwq3Lwd/eo/DSz4mJ2EbcU9fSvTDHxMxaBQRg0YBsOf126jb+z7sdSJImP4YmTvWgMuFd1gTwgeNNvjVVY+yttElLUPv0AbU630fsaN64Hbk0/D2iUa/DBEREREALO6CHs1Eihm0BHZlGJ2iQNNAmNXT6BRSWb69+GHS4hKMjlGmkJiGDFg2uULTaL05NWZZblpmFedJy0zEE2w+Arf+VvD3R911G1URkf/SJSQiIiIiIiIiYnoqYIiIiIiIiIiI6amAISIiIiIiIiKmp048pVSRJro5iJmyiJyMmT6rZspSFrNkNUuO8jBLVrPkEBERkZpPBQwp1aTORicQ8Txab06NllvFaZmJiIjImUaXkIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJieChgiIiIiIiIiYnoqYIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJieChgiIiIiIiIiYnoqYIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJieChgiIiIiIiIiYnoqYIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJiezegANc2iW18iY0+y0TEIjA6n10cjT+s5rh7+CzsT0isp0ek5q2EQ8964zOgY5fLIn5CYZXQKiPSHSZ2NTiEiUjaz7DuhcvafJzLT6/MUVfE+iIiI51MBo5Jl7EkmLS7B6BiVYmdCOlt2phkdw+MkZsGuDKNTiIh4jpq07yxJTX99IiIi1UWXkIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJieChgiIiIiIiIiYnrqxNMg3SY/QLPBPQFwOZ1kH0gj6fdNrB3/GVnJqQanExERkZqi9zfjSN+dxB+PvVukPaBhPQaufocf+o8mZdU2g9KJiIiUn87AMFDyyi3MbHsXX3e8n18fmExo62h6vPeo0bFERERERERETEcFDAO58hxkH0wjKzmVAyu3EvvpQuqf3wJ7gJ/R0URERERERERMRQUMk/ALq010vy64HE7cTpfRcURERERERERMRX1gGCj8glbcvOMTLFYrNj8fADa9Mw9Hdi4A/uF1uHL+C8y/4n/kHE7Hy8+b/gtfZfGdE0nbts/I6CIiIlLD9J7zLN4BfljsNlL+3MrKJ9/H7dKPKiIiYh4efQbGhg0b6N+/P8HBwQQFBTFgwACSkpIIDAzkhhtuMDpemQ6u3c68Sx9nfp+RrH/tK1JWx7JuwheFw7OSU9kydT7nj7sNgHaPDmLvj3+qeCEiIiKVbtGQF5l32ePM7fEIPqFBRF/V1ehIZySn+/jf+46B2136uCIiZxqPLWAsWrSILl26EBsby+jRoxk/fjwJCQn06dOHY8eO0a5dO6MjlsmZk0fGnmTSYuNZP3EmGfEpdH7hziLjbP3gR0Jiomh515U0vrIzG179yqC0p276c9355b3eRscwPVduNomfPc2m+5qz9no/1t9ch62Pnk/Kd1OMjiYiYlqXfT6KK+e9gMVa9JCmTpsmDNn7BY376Ut4XnoW3kG1irV7Bxe0OXPzAcg/lg2AxeaFl92GW9+cq1WeE96Phf9bdbzt6XUweCl8u1eFDBER8NBLSA4ePMjgwYPp0KEDCxcuxM+voNPLIUOG0KRJEwCPKGCcaP0rM7nm19eJ/eQXDm/YCYDb5WL1mBn0nj2OxXe8XHh5idQ8+969n4yNS4i663X8mpyLMyudrF3ryDuoM25EREqz/OG36L/4Vdo8dA1/T/4GAC9fby568yF2zf6NvfNXGJzQeEd3JBJ9VVcsVmuRS0Lqtm+Gy+EkY3dSYdsVX48ltHUTEhatZe/8lUbEPSPlOmHEn7DmUPFhuzPg+Q0QexSeaAMWS/XnExExC488A2PChAkcOXKE6dOnFxYvAIKDg+nQoQPgmQWMjN3JxP+yhg4jbyzSHtmrPVnJqdQ+u5FByaQ6pP35LWHXPE5IlwH4hDXBv8m51O11Gw1ueMboaCIippWdksYfj73LuY8MJPTcswA4b9QtWL3t/Dn6Q4PTmcO2jxbgWy+YCyc/QGjbpgQ2DqPJgAtp/8QN7Ji5hLz0rMJxfxo4lpnt7sbLz5vwbq0NTH1meWNLycULgH9PvPhqD8yPr65EIiLm5JEFjC+//JLu3bsTExNT4vCwsDDCw8MBmDVrFt26dSMgIIDo6OhqTHlqNr09j8ge7Qjv2gqAkLMb0ah3J+b3GUnzm3oR0Ki+wQmlqthrR5C+dgGOjFSjo4iIeJR9C1azY9ZSLnrzIaIu70iLoZfx24NTcGTmGB3NFDITDvHDVaPwCa5Fr49GcvXiV2n70LVsenseK0ZOKza+MyePfT+uotEV5xuQ9sxzLB++LcfJlhbgs526lEREzmwedwlJcnIyiYmJDB48uNgwl8vFxo0bad++fWFb7dq1efDBBzlw4ACTJk2q8PwcDgfJycnlHj8/31Gu8ZY//FaJ7QfXxDIjYmDh464T7mH1mBlkJaey7uUv6fzCnSwa8mK5ciQkJJQvdCkc+fmnNX1lcuTnn/brqS75+WGAvcLTNX7wfXa/ehMbhtbDL6oVtVp0Ifi8Kwnu3B/LKZwvmp+fT0LCgQpPVx3Ku54YrTLWIxEpW2VsE1Y/M4OrfplIzw8f5+9J33Dwr7hTzlLZ670ZtnlHtuxl0a0vlTrcHuiP1dtG7uF0LF5Woi7rSPIfm6sxYVFn0vZ3WaofOc7QMsdzAzsyYOWOZKL8jP9MiYicrvDwcGy2ipUkPK6AkZmZCVDiF7q5c+eSkpJS5PKRyy67DIBvv/32lOaXnJxMVFRUucd/PvQyIu1BpzSvEzW/+VJyDh0lYdFaAHZ+tYzmN15Coys7s++HP086bVxcHIMqkLvkAOPAN/L0nqOSxMXFERV1Y9kjmsA5b2zCr1GrCk8X0PJCWk/dSWbcKjJjV5Cx+Vd2ThhI8Hl9OGvUvAoXMeLi4oi6wpyn/1bmelKVKmU9EpEyVcY2wZGdy6Z35tH1pbvZMPnrU36eqljvPWGb5x3sT8/3H8dqt2HxspL06wZiP/nZsDxn0va3fr+HiLr79XKPf/k1gzm2+dcqTCQiUj3i4+Np2LBhhabxuAJGVFQUXl5eLFu2rEj73r17GT58OOCZ/V+UZPtnC9n+2cIibQuuHWNQGqkOFi8bAS0vIKDlBYQNeJTDSz9lz6QhHNv8K4GtLzY6noiIqbn/OdPB7XSVMaacKDPhEPN7/8/oGGckZ3Z6xcbPqtj4IiI1iccVMLy9vRk6dCjTp0+nf//+9O3bl/j4eKZNm0ZYWBiJiYmVWsAIDw8nPr78PSatGPQSmbvLf8lJVYmJiSF+1ul1XtbrvuXE7cuspESnJyYmhkWLPaPnquFbwoivpMuufRu2BMBxNKXC08bExPBTBT671cks60lZKmM9EpGymWmbUBXrvZlen6c4k7a/R/Kt3LXRjZOyzrR0U9/byTfLvsNLdyIRkRrg334rK8LjChgAU6ZMwW63M3fuXBYvXkzXrl2ZM2cOzz77LDt27Ci1c89TYbPZKnRai91ujkVqt1csd0ls9or341BVbHb7ab+e6mLfDpxCASP2qYup0/1G/Jt1xBZcj9ykHSR+8hRetUIIbNOz4jlMvMzMsp6UpTLWIxEpm5m2CVWx3pvp9XmKM2n72xC4LBUWJJY1poUbmtloHHVmLBcRkZJ45B41ICCAqVOnMnXq1CLtmzZtok2bNlitHnlzFTnDBXfoQ+qvn7H/i2dwZqVjC65PYKuLiH5oOragukbHExERkSryWGvYmgZ7T3Li64X14aam1RZJRMSUPLKAUZK0tDQSEhLo27dvkXan00l+fj75+fm43W5ycnKwWCz4+PgYlPTMc/vTvxkdwSOEDxxJ+MCRRscQEfFYO2YtZcespUbHEKmwEB/4oBu8uhl+SQTHf26VWssG10XD/WeDTb/RicgZrsYUMDZu3AgU78Dzk08+4fbbby987OfnR+PGjdmzZ081pjsuoGE9Lnr7YVwOBxYvL1aOnMaRrXsLh0de0p72jw/Gle/k8MZd/DnqA3zrBnPxu49gtXmBBVY9M4PDG3Yakl9EREROT1nHAgABjepz4WvDsNpt7PtxFZvfnVc4LKhpBAOWTuLHAU9zcO32UufT+5txWO02XPkOkldsZv0rs4rOI6o+3aY8CC43zrx8lt37GnnpWfT84HF8QgIACG13Fj/0G1Us34naPTaIJv0vZE73EcWGdX7hTkLbNsXiZWX9xJkkLllPk/4Xcs49/XDm5ZOdfITfRryBK+/MvjVoiA881wH+rxX8kQKZDqjjU3DmhV+NOWIXETk9NWZzWFoB47bbbuO2226r/kClyEw6zA/9R4PbTfiFrWn70LUsu39S4fB2jw5i8Z0Tydp/mEs/G0Xtlo3J2HeAX++fTPbBNIKbNaDLS/fw08Cxxr0IEREROWVlHQsAdBw9hLUvfs7Bv+LoPXsce79fybH4gg6dz31kIMkrtpRrXkvunEj2wbQSh7UYejlxny1k19e/0vqBAZx1fQ+2fvADS+6cCIBPaBC9vx5bZvHCt24wQU0blDgsuHkkwc0b8sNVo/CrF0KvT58kccl6Dq7bzg9Xj8LtdHHeUzfTpP+F7PxqWYnPcaap7QN9z4w7yIqIVFiNORFt2LBhuN1uunTpYnSUk3I7XeAuOC/QO9CP1C17igw/sm0f3kG1sFit2Hy9yT16DEdmTuHBhyvfqdvDiYiIeLCyjgWg4Iv/wb/iAEhYuJawLgV3parbvjnZKWlkJR0uez5uNz2mPcrlXz5N6LlnFRt+JLbgmAPAO9ifnMNHiwxvctUF7PluRZnzOfeRgWx8Y06Jw7IPHMGZm4fFy4p3sD+5qRkAHNuXUng843I4cbt0bCMiImWrMWdgeJI6raLp8tLd1GpQt/BXjn/tnrOcy78YjSMrl6TfN5K1/z8HKBYL54+7jU3vzK3mxCIiIlKZTnYsAGCxHr9PZu7RTHxqBwLQdsS1/P7IW5w/5tYy57H0nlfJTc0g6KwGXPLh43x78SNFhif/sZnLPh9Ni1suxeVwsuG1r4sMb3ptd3576I2TziOwSTj2Wr6lnqWRl57FsX0pXPv7G9j8vFl2/+Qiw4OaRhDZsx1/vzG7zNcjIiJSY87A8CSpm/fww1WjWHTbS3Qef2eRYV1evIv5fUYy+8Lh4IZGvc8vHNb5hTvZ/+vf7F+6oboji4iISCU62bEAFJ6gAYB3kD+5RzJo2KsDhzfsJPfIsXLN49+zHdJ37icnNQOf0KAiwzuOuoW14z9j7iWPsuntuZz31E2FwwIa1cfiZSVjT/JJ59HuscFsmPR1qcMbXHwufvVD+Kbrg8y5+BE6PXcHFq+Cw0+/eiF0e/1Blt03CWd2Xrlek4iInNlUwKhmVu/jJ73kp2cV22G7XS7yjhbcQyvncHrhLy7tHhuE41g22z78sfrCioiISKUr61gA4GhcAnXbNQOgYa8OHPhzK3VaRxN+QSsu+3wUERe15fxxt+FXPwRbLV+8g/yLPYc9wA8o6MvCr15IYUGjkMVCzj9tOYeOH3NAwdkXu+YUvYtYrcjit/QObFSfLi/exWWfj8I/og4dnxl6wjwgN+0YuN3kH8vGy9uG1eaFd5A/Pd5/jD9Hf0jG3gMnWVoiIiLH6RKSalb//LNp99gg3E4XFouFVWNnENmzHd4hAeyes5x1E2dxxddjceblk5eWyd9vzCa4WQPajriOlFXb6P3NOLJT0op19iUiIiKeoaRjAaDI8cBf4z/jwlfvx2LzIv6n1Rzbl8Lfr8/m79cLLrXoNvkBYj/+meyUNJrffCk2X2+2fvDD8ZlYLFzxzVicOXlYbTZWPTMd3G786oVwzr39+Ov5T/l78td0ffneghw2K388PrVw8iZXX8DPg587/nQ2Ly6Z/gTfXf5Ekdfyw1WjCv++5rfXWfPsxwB0evY21r/2NUm/bqTpgG70+fY5vHzsbP3gR5y5+bR7dBCBjepz/j8Fjx0zl+gWuCIiUiaL2/3fkxTldH178cOkxSUYHYOQmIYMWDb5tJ6j1TXfsGVnWqXkOV3nnBXC5jnXGR2jXAYtgV0ZZY9X1ZoGwqyeRqcomVnWk7JUxnokImUz0zahKtb7qn59nZ67nQ2TvyH3cHqVzaP++S2o07oJ26YvqLJ5/Je2vyIiUhKdgSEiIiLiwVY9Pb3K55GyOpaU1bFVPh8REZGTUR8YIiIiIiIiImJ6KmCIiIiIiIiIiOnpEpJKFhgdbnQEoHJynNUwqOyRqomZspQlsnhH8IYwSw4RkbKc7j7L5XCSvisJgKCmEVhtXoZlqa7nrOm0zEREpCTqxFNEqp2ZOuw7GXUiJ+IZMvcf5qvz7gXg+r+mUqtBqMGJREREpCroEhIRERERERERMT0VMERERERERETE9FTAEBERERERERHTUwFDRERERERERExPBQwRERERERERMT0VMERERERERETE9FTAEBERERERERHTUwFDRERERERERExPBQwRERERERERMT0VMERERERERETE9FTAEBERERERERHTUwFDRERERERERExPBQwRERERERERMT0VMERERERERETE9FTAEBERERERERHTsxkdQMxp0a0vkbEn2egYRQRGh9Pro5FGxzDlsjkVZlmeIiJyasyyP/Lk/YlZlqEn8eT3u7o88ickZhmdokCkP0zqbHQKkcqjAoaUKGNPMmlxCUbHMCUtGxERMQPtj06flqFUhcQs2JVhdAqRmkmXkIiIiIiIiIiI6amAISIiIiIiIiKmpwKGiIiIiIiIiJieChgiIiIiIiIiYnoqYIgYpPc347jglfuKtQc0rMdtSV9Tv9PZBqQSEZGaptvkB7gt6WtuS/qaoQkzuf6vqXSbMhz/8DpGRzvj6VhARKRiVMAQERERqeGSV25hZtu7+Lrj/fz6wGRCW0fT471HjY4lIiJSISpgiIiIiNRwrjwH2QfTyEpO5cDKrcR+upD657fAHuBndDQREZFyUwFDRERE5AziF1ab6H5dcDmcuJ0uo+OIiIiUm83oACJSOv8GoXSfMhy/esG4XW7iPlvI1vd/MDqWiIh4mPALWnHzjk+wWK3Y/HwA2PTOPBzZuQD0mPYo+5dtIO7ThQDUad2Ei94ewXeXPY4zN9+w3FKg95xn8Q7ww2K3kfLnVlY++T5ul4pPInLm8egzMDZs2ED//v0JDg4mKCiIAQMGkJSURGBgIDfccIPR8UROm9vhZPW4j/j24kf4vu9TnH3rFQTHNDQ6loiIeJiDa7cz79LHmd9nJOtf+4qU1bGsm/BF4fBVT0+nzfBr8KkTCBYLXV+6mz+f+kDFC5NYNORF5l32OHN7PIJPaBDRV3U1OpKIiCE89gyMRYsW0a9fPxo3bszo0aPx8/NjxowZ9OnTh2PHjtGuXTujI9ZYkZe057wnbyK4eUOyU46w5YMf2DJ1vtGxPE5eehbeQbWKtXsHF7Q5c/PJTkkjOyUNAEdWDkd37Mc/vA5H4xKqM6pUk+Qs+GYvbDoCTjc0qgXXNIZWtY1OJiKezpmTR8aeZADWT5xJYHQ4nV+4kz8eexeArORUNk+dT8enh3Bo3Q6O7koiaflGIyOfEcpzLACQfywbAIvNCy+7DbfbXX0hpdr81d9y0uHe9RvTZtqe6gkjYlIeWcA4ePAggwcPpkOHDixcuBA/v4IOqIYMGUKTJk0AVMCoIqHnnkWvGf9j07vzWDZsMvXaN6frhHtwZucR+/HPRsfzKEd3JBJ9VVcsVmuR00Drtm+Gy+EkY3dSkfEDGtYjtE0TDq3dXt1RpYq53fDONpi+HdzAv4cvaw/Dt/ugWxi8cB7U8sgttoiY0fpXZnLNr68T+8kvHN6wE4Bt0xfQ9/vxRFzYmu/6jDQ44ZmhIscCV3w9ltDWTUhYtJa981caEVeqWNsZx9/vY9v+YNdL19Fy0lrstSMKGq1eBiUTMQ+PvIRkwoQJHDlyhOnTpxcWLwCCg4Pp0KEDoAJGVWl1Tz8Ord/J2vGfc3R7IjtmLWXrhz/S5sEBRkfzONs+WoBvvWAunPwAoW2bEtg4jCYDLqT9EzewY+YS8tKzCse1+fvS44PHWDX2o8JfYaTmmBoLH/5TvICC///729ryA/DYKnDocmcRqSQZu5OJ/2UNHUbeeLzR7Sb2419IWLSW3MPpxoU7g1TkWOCngWOZ2e5uvPy8Ce/W2sDUUlXstcML/9kC6gBgC6p3vD24nsEJRYznkQWML7/8ku7duxMTE1Pi8LCwMMLDw8nNzeXuu++madOmBAYGEhMTwxtvvFHNaWuW+p3OJnHJuiJtiUvWExBVH/+IOgal8kyZCYf44apR+ATXotdHI7l68au0fehaNr09jxUjpxWOZ7F50fODx9j97e/snb/CwMRSFQ7mFJx5UZbVh2BZctXnEZEzx6a35xHZox3hXVsdb3S5cLt0eUJ1Ke+xwL+cOXns+3EVja4434C0IiLG87gTkpOTk0lMTGTw4MHFhrlcLjZu3Ej79u0BcDgchIeH8/PPP9O0aVP+/vtvrrjiCsLCwhg0aFC55udwOEhOPvO+NeTnO0ps96sfQvbBtCJt2SlH/hlWm6yk1CrNlJBgfN8PpS2bU3Fky14W3frSSce58LVhHN2ewOZ35lXafMHY5VmZy7AqVccy+jIpEKc7uBxjuvk0NpcWrkNVmkfEE+UcSCv8OykpCV/XmXGmWnm3pcsffqvE9oNrYpkRMbBScphh/3wqzLA/KutYwB7oj9XbRu7hdCxeVqIu60jyH5urMWFRnvx+V5f8/DDAbnQMAPLz80lIOGB0DJEShYeHY7NVrCThcQWMzMxMACyW4p3czJ07l5SUlMLLR2rVqsVzzz1XOLxdu3ZcffXVLF++vNwFjOTkZKKiok4/uId5PvQyIu1BRscoIi4ujkEmeC+qc9nU73Q2za6/mNQte7n6l4kArJs4k/if15z2cxu5PM34+SpJdSyjs0bNI/j8fiVu04qysP5AHlGXGL8OiJhNbasfr9W/EoBOnTpx5AwpYJhlW2qW/fOpMMsyPBnvYH96vv84VrsNi5eVpF83EPuJcf2OefL7XV3OeWMTfo1alT1iNYiLiyPqCl1yJOYUHx9Pw4YVu8OixxUwoqKi8PLyYtmyZUXa9+7dy/Dhw4HS+7/Iz8/nt99+47HHHqvqmDVWdkoafvVCirT5/vP43zMxpPKkrNpWKb+OiXlZrF4U7brzJNR5l4hUsR2zlrJj1lKjY8h/ZCYcYn7v/xkdQ0TEFDyugOHt7c3QoUOZPn06/fv3p2/fvsTHxzNt2jTCwsJITEwstYDx4IMPEhgYyNChQ8s9v/DwcOLj4yspvedYMeglMncXv3QmZdU2GvRox4ZJXxe2RfZsx7H4lCq9fAQgJiaG+FkfVuk8yqO0ZeNpjFyelbEMu01+gGaDewLgcjrJPpBG0u+bWDv+M7KSK+ezWB3L6MOEYOallKc7Ijcxdex8dwZuj0TKknMgjeX9xgKwatUqfMNCDM1TXcyyPzLL/vlUmGUZehJPfr+ry/AtYcTnGJ2iQExMDD/p2EFMKjw8vMLTeFwBA2DKlCnY7Xbmzp3L4sWL6dq1K3PmzOHZZ59lx44dJXbu+X//93+sWLGCxYsX4+3tXe552Wy2Cp/WUhPY7SV/NDa/N5++371A+5E3suvrZdRt35yWd/Rh9diPqiWTGd6L0paNpzFyeVbWMkxeuYVl97yGxctKYHQYXcbfRY/3HuWHq0dVyvNXxzIaGgLzFpdnTAs3Nvc2xTogYjaZ1uN3JIuIiKBWg1AD01Qfs+yPzLJ/PhVmWYaexJPf7+pi3w6YpIBht9v1fkmN4pFb7YCAAKZOncrUqVOLtG/atIk2bdpgtRb9NfPhhx9m0aJFLF68mLp161Zn1Brn8IadLL79ZTo8eROt77ua7INprJ3wBbEfG3ctppy5XHmOwk5ls5JTif10IV1euBN7gJ/H3G42OgD6NoTvy+gPrUkA9I6snkwiIiIiImbkkQWMkqSlpZGQkEDfvn2LtD/00EMsXryYJUuWUK+e7p1cGRIWrSVh0VqjY4gU4RdWm+h+XXA5nLidLqPjVMiocyHbCYuTSh7eJADe6Aq+NWaLLSIiIicT2KYH583VLY1FTlRjDoc3btwIFO3Ac+/evbzxxhv4+PjQpEmTwvbu3bvz448/VndEEalk4Re04uYdn2CxWrH5+QCw6Z15OLJzAegx7VH2L9tA3KcLAajTugkXvT2CtNj4Etu/u+xxnLn51f46vL1gQkdYfQg+iIO/Dhe0Nw+CW86CSxuAj/rvFBEREZEzXI0uYDRu3Bi3W5VLqTpeft5cMWsMIc0bsuJ/77F77u/Fxom6vCNtH7oWZ76DuE9+Ydfs3wC44JX7CDqrAc6cPH5/9B2y9h8udT4+oUF0eeFOfEODcGTnsWjoi0WGn3N3X5pc0w1XvpPUjbv4c/SH5ZrO0x1cu53lI97Ey8dO9NUX0KB7W9ZN+KJw+Kqnp9Nn7nPs/eFPco8co+tLd/PnUx9wdEdiie1GFC/+ZbFAp3pQywa3FnxEGH0utKptWCQRqQFC2zalw1M3Y7V5kbJ6G+smfFk4rN2jg2h2Q0+Obk/gl5teKDJdUNMIBiydxI8Dnubg2u3VHdsw5dmvR17SnvaPD8aV7+Twxl38OeoDANo9NoiI7m1xO5z8OfpDjmzdW+p8Trbs/6vZ4J50efEuPm1680lzN7+pF81vuAS328WK/00jbdu+IsMvfG0YgdFh2Px92fXNr2yZ9n2pr7W0YwoRETOoMQWMYcOGMWzYMKNjyBnGletgyR0TaTH08pJHsFg4b9TNzO/zJM7cPHrPHkf8L38RcWErnLn5LLjmGULbNuW8Ubfw2wOvlzqf88fcyvpXZnJ0x/4Sh8f/8hdbpn0PwMXvPEJY13M4sGJLmdN5OmdOHhl7CnqPXz9xJoHR4XR+4U7+eOxdoKBfjM1T59Px6SEcWreDo7uSSFpeUOwsrV1EpKaw2m10GHkjS+6YiCOreI+CsZ/8zI6vltL1pbuLDTv3kYEkr9hSHTFNpcz9OgXFh8V3TiRr/2Eu/WwUtVs2xmK1ENqmKT/2H41/eB26TRnOz4PGlfocJ1v2//LysdO4bxcyEw+dNLN3SAAtbr2c7/s+RWDjMLq+dDc/XV903iv+9x6ufAcWLyvX/Po6sZ/+UuprLe2YQkTEDMpz7z4RKYXb5SrsRLIkvnUCyTmUjiMrB7fTxdEd+6nXoTlBTRtweMNOAA7/vYuwzmeX+hwWq5WQFg1p8+A19J49juY39So2zr9f4gFcDgdup6tc09U061+ZSbPBPQk996zCtm3TFxDSIoo2Dw5g9biPymwXEakp6nWMIT8rl4vffYTLZ42h3nlF79KWnZIGruJnqtZt35zslDSykko/M7CmKmu/DnBk2z68g2oVXL7o603u0WMENY3g8N+7gILieUDDuli9S/+dsLRl/18t77yyXJ2k12vfjOQ/NuN2OEnfuR+fOkEFp/X9hyvfAYCXjzcZ8Sk4c/JLfa0lHVOIiJiFChgiVSjncDq+dYPwqx+CrZYvYZ1b4hMSwJFt+2jQox0AkT3b4RcaXOpz+NYNos450Wx6Zx4/3/AczW+4hMDGYSWOW7/T2fiH1yFl1bYKTVdTZOxOJv6XNXQYeePxRreb2I9/IWHRWnIPp5fdLiJSQ/iH1aZOy8Ysu38Syx9+kwsm3luu6dqOuJaNb86p4nSea/ec5Vz+xWiu+e11ju5MJGv/YY7ExhN+YSssNi9CWkQR0LAePsEBpzwP7+BahHU5h4SFf5U9bkgAeUczCx/nH8vGO8i/2HgXv/MI1614g4OrY6Ecl1j/95hCRMQsVMAQqWIr/vceF701govfeYS02HiyDqSSuHgd6bv20/ubcURe0p7Uk1wnm3c0k8z9h0iLjceV5+DAyi2EtIgqNl5w80g6jh7C0ntfq9B0Nc2mt+cR2aMd4V1bHW90uXCX9EtXae0iIjVAbtoxUlZvw5GZQ9b+wziycrEH+J10moa9OnB4w05yjxyrppSep8uLdzG/z0hmXzgc3NCo9/kcjUtg99w/uGLWM7S+/2qObNtHzmkUx9sMv4ZNb39brnHzjmbiHVSr8LE9wI+89Kxi4y27fxJfd36AyEvaExzT8KTPeeIxhYiIWdSYPjBEzOrAyq38dP04bP6+9PzgMQ7+VdAZ2vpXZgEQ0a1NYeeRtlq+WL2sRQ48nLn5ZCYcwj+8DlnJqdRp25QdXy8rMo9akXXp9vqDLLt3ErmpGeWezpMtf/itEtsProllRsTAak4jImI+h9Zup93/DcLiZcXm74s90I/8Y9knnaZO62jCL2hF/fNbEHJ2I4LOasCSOycWXPIgQMFlJv+e8ZBzOB2f2oEAxH70E7Ef/URw80jaPnQtbpcLL19vbLV8K3ymX/BZDahzTmN4CPwj6tD9jeH8NvwNfEODyMvIwpXnKBz34NrttHus4H0OiKpPbmp6sTMsrN42XHkOnDl5OLJzcWbnlTrvko4pRETMQgUMkdPU4/3HCG3dBEdWDnU7NGf1mBlE9myHd0gAu+csp+OYoYS2aYrL4WTti5/jynfgUyeQntMew+Vwkpl4qLAH8yYDumHz9WbrBz8UmceqMTO46O0RWG02Epas42hcAn71Qjjn3n789fyndBw9BN86QXSb/AAAG9+cQ+KS9SVOJyIiZ4a89CxiP/mZ3rPHYbXZWPPsJ0X2TzG3XMpZ119McLNILp/5DL899AZ/vz6bv1+fDUC3yQ8Q+/HPZ1zxoqz9+rqJs7ji67E48/LJS8vk7zcKltfls8ZgsUBOagZ/PvU+UHAZRsNL2rN6bNG+lkpa9tkHjtBtynCWP/QGi29/uXDca357nd+GvwHA+c/ezqY3vy1yh5O8tGNs/3wRfeY8h9vtYuWTBfP+b+ZLP3kKq80Lq7eNPfNXcCw+pdTXWtoxhYiIGVjcus+olODbix8mzWRfdkNiGjJg2WSjY1Tpsun03O1smPxNtfTJYOTyNOPnqyRGLKPNR47fRvWj7rqNqkh5ZO4/zFfnFfTvcP1fU6nVINTgRNXDLNtSs+yfT0VVL8M2w68h/pe/it3W9FRd9NYIfj3JXcuqgye/39Vl0BLYZZKTV5oGwqyeRqcQqTw6A0PERFY9Pd3oCCIiIlJJNr5RuZ2hGl28EBExmjrxFBERERERERHTUwFDRERERERERExPl5CIVFBgdLjRESpFTXkdIiJnqtPZjrscTtJ3JQEQ1DQCq83LkBxG8+TsRtEyK1ukv9EJjjNTFpHKoAKGSAX1+mik0RFEREROa3/0345Pr/hq7BnT8emJtE+XqjCps9EJRGouXUIiIiIiIiIiIqanAoaIiIiIiIiImJ4KGCIiIiIiIiJieipgiIiIiIiIiIjpqYAhIiIiIiIiIqanAoaIiIiIiIiImJ4KGCIiIiIiIiJieipgiIiIiIiIiIjpqYAhIiIiIiIiIqanAoaIiIiIiIiImJ4KGCIiIiIiIiJieipgiIiIiIiIiIjpqYAhIiIiIiIiIqanAoaIiIiIiIiImJ4KGCIiIiIiIiJiejajA4jUNI/8CYlZRqeASH+Y1NnoFCLlo/Wm4hbd+hIZe5KNjkFgdDi9PhppdAwRU9E27cxmlvcf9BmQmkcFDJFKlpgFuzKMTiHiWbTeVFzGnmTS4hKMjiEiJdA27cym91+k6ugSEhERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE+deIoYZM/rt3F48UcFD6xW7LUjCGxzCZFDX8Q7NNLYcCJSY3Sb/ADNBvcEwOV0kn0gjaTfN7F2/GdkJacanE7kzKZjARGRitEZGCIGCjinO21nJNHm/X00efRzsnavY9eE642OJSI1TPLKLcxsexdfd7yfXx+YTGjraHq896jRsUQEHQuIiFSEChgiBrLYvLHXDsc7NJLAVhdR7/J7yIxdgTMr3ehoIlKDuPIcZB9MIys5lQMrtxL76ULqn98Ce4Cf0dFEzng6FhARKT8VMERMIu/wfo788TVYvQr+iYhUAb+w2kT364LL4cTtdBkdR0T+Q8cCIiInpz4wRAyUsWkp6wYH4Ha5cOdlAxA24FG8fGsBcGTFHJJmjisyTU78FqLuep16fe6v9rwi4pnCL2jFzTs+wWK1YvPzAWDTO/NwZOcC0GPao+xftoG4TxcCUKd1Ey56ewTfXfY4ztx8w3KLnAl0LCAiUn4eXcDYsGEDzzzzDEuXLsXtdnPJJZfwzjvvEBMTQ9++ffnyyy+NjlghbjfszIAjueBng7ODwaZzZGq0WjGdiX74I9x5ORxZPov0DQtpcPPzhcNrd72G2l2vKXyctvJbEj95itBLbjUiroh4qINrt7N8xJt4+diJvvoCGnRvy7oJXxQOX/X0dPrMfY69P/xJ7pFjdH3pbv586gMVL0SqgY4FRETKz2MLGIsWLaJfv340btyY0aNH4+fnx4wZM+jTpw/Hjh2jXbt2RkcsN7cb5sfDZzthR8bx9nq+MDAahpwF3jqLsEayevvhG9EMAL/GrclN3kn8e8Np/OC0YuPmHUpg39QHaDbmR6w+/tUdVcR0/upvOelw7/qNaTNtT/WEMTlnTh4Ze5IBWD9xJoHR4XR+4U7+eOxdALKSU9k8dT4dnx7CoXU7OLoriaTlG42MLHLG0LGA/Ev7NZGyeWQB4+DBgwwePJgOHTqwcOFC/PwKOiEbMmQITZo0AfCYAobbDa9sgpm74cRN1qEceGcbrD4Er3cGHxUxaryIG8ey+YGW1L3iXmo171jY7na52D3pFsKvG4l/dFsDE4qYR9sZSYV/H9v2B7teuo6Wk9Zirx1R0Kjrx0u1/pWZXPPr68R+8guHN+wEYNv0BfT9fjwRF7bmuz4jDU4ocubSscCZS/s1kbJ55AUKEyZM4MiRI0yfPr2weAEQHBxMhw4dAM8pYHyfUFC8AHCfMOzfx2sOwRtbqjOVGMW3QXNCzr+K/Z+OKtKeNOt5vPyCqN9vuEHJRMzHXju88J8toA4AtqB6x9uD6xmc0LwydicT/8saOoy88Xij203sx7+QsGgtuYd19wMRo+hY4Myl/ZpI2TyygPHll1/SvXt3YmJiShweFhZGeHg4AMOGDSMqKoqgoCAiIyN5+OGHycvLq864pXK74fOdxc+8KMm3++CYLkU+I4Rd8zjp638mY+NSAI5t/Z3DCz8g+qHphuYSkZpl09vziOzRjvCurY43uly4XSeW00WkuulYQESkZB53CUlycjKJiYkMHjy42DCXy8XGjRtp3759YduDDz7IxIkTqVWrFocOHeL6669n/PjxjB07tlzzczgcJCcnV1b8IhJybMSlh5dr3BwnfLsllR6hWVWS5UT5+Y5qmU9F5Oc7SEhIMDpGmfLzwwB7meNFj5hRYntAyws4b27BFwjHsTR2TxpC9EMzsAWFVjBHPgkJByo0TXUx4+erJEZ85g5k2oGwgr9TDhCceWZULsu73lR9DvOuNycq73q0/OG3Smw/uCaWGREDKyWH0dvmnANphX8nJSXh68o2LoyH0DKrWjoWOLOZZZ8G+gyIuYWHh2OzVawk4XEFjMzMTAAsluLnLcydO5eUlJQil4+cc845hX+73W6sVivbt28v9/ySk5OJioo69cAnEXBOd1q8+Gu5x3/0medImTe5SrKc6PnQy4i0B1XLvMorLi6OQVX0XlSmc97YhF+jVmWPWA4HF7xD/pEk4j98pEh7aM9bCev/SClTFYiLiyPqitaVkqOyVebn65Zdn3Fo3Q4Atrz/Pft+XFU4LOryjrR96Fqc+Q7iPvmFXbN/KxwW1DSCAUsn8eOApzm4tuRtghGfOf9mHWn56moArurXj6wda6p1/kapzPXmdJh5vTmRWbbTZtg217b68Vr9KwHo1KkTR/RlvExaZlVLxwJnNrPs00CfATG3+Ph4GjZsWKFpPK6AERUVhZeXF8uWLSvSvnfvXoYPL7gm8MT+L1566SWef/55MjMzCQ0N5aWXXqquuCflzK7YNcbO7IyyR5IaJWLgk0QMfNLoGKaWmXiIBdeNKT7AYuG8UTczv8+TOHPz6D17HPG//EV+RsFZTOc+MpDkFepcRuS/dsxayo5ZS42OISL/oWMBEZHjPK6A4e3tzdChQ5k+fTr9+/enb9++xMfHM23aNMLCwkhMTCxWwBg5ciQjR45k69atfPbZZ0RERJR7fuHh4cTHx1fyqyjgdMP9mx2k5HlRVk8YVtwsnvosdexjqyTLiVYMeonM3VVz6cypiomJIX7Wh0bHKNPwLWHE5xidomB5/VRFn93TVZmfL7+w2vSePY7sA2n8OfoDcv7pfNC3TiA5h9JxZBW8GUd37Kdeh+bsX7aBuu2bk52ShtvpOulzG/GZi8u080Rswd/fzZ9PTK0z4xISrTcVZ5bttBm2zTkH0ljebywAq1atwjcsxNA8nkDLrGppm3ZmM8v7D/oMiLn9229lRXhcAQNgypQp2O125s6dy+LFi+natStz5szh2WefZceOHaV27tmyZUvOPfdchgwZwpIlS8o1L5vNVuHTWirihlyYUo4fgXs1sNC2SYMqy3Eiu918Hw27vWrfi8pi3w6YYKdlt9tNu7wq8/P1TZcHyE3NoMk13Th/7K38NvwNAHIOp+NbNwi/+iHkZ+YQ1rklSb/+DUDbEdfy+yNvcf6YW8vMWd3L8OgR4J8CRlj9MBrWrtbZG0brTcWZZTtthm1zpvX4HckiIiKo1aBi/QScibTMqpa2aWc2s7z/oM+A1DzmOPqpoICAAKZOncrUqVOLtG/atIk2bdpgtZZ+c5X8/Hzi4uKqOmK53dS04Dapf6SUPk7DWvBEm+rLJOJJclMLLq3aM+8P2j50bZFhK/73Hhe9NQJHdh5psfFkHUilYa8OHN6wk9wjx4yIKyIiIiIip8gjb6NakrS0NBISEopcPnL06FFmzJhBWloabrebv//+m+eff54rrrjCuKAnsFnh1U4w5CzwP6Gc5GWBKyJhejeo7WNMPhEzs/n5YPmnYBnW5Rwy9hQ9nf7Ayq38dP04lt03CZu/Dwf/2k6d1tGEX9CKyz4fRcRFbTl/3G341Q8xIL1UpsA2PThvrhvvuvqVSUREPJ/2ayIl88gzMEqyceNGoGgHnhaLhU8//ZT/+7//Iy8vj/r163Pttdcybtw4g1KWzG6FEa3g7hbw5S54e1tB+2ud4MIwY7NJ1cret5m9b9+LxWLF4mWj8YPv4xPetHD4ntdvI2vP33j5B+Eb2YLGw6ae5NnOPMHNI7nglfvIz8zBle9kxRNTiezZDu+QAHbPWU7HMUMJbdMUl8PJ2hc/x5Xv4O/XZ/P367MB6Db5AWI//pnslDRjX4hIFSrtjjuRl7Sn/eODceU7ObxxF3+O+gCANsOvoVGfTlgsFrZ++CM7v1pW2lOLyGlYe70/tWI6AVC/3whqd72mcNju124hN3kXbpeT+lcOI/SSW8k9sIfdr96ExWbH7XTQ6P538I9ua1R8ERFD1OgCRlBQEAsXLjQoUcX526BzveMFjBBvY/NI1bMF1aP509/jVSuYo2sXkDTzOaJHTC8yTqP73iagRReDEprb4b938d3lTxRp++9ZGGvGfXzS6Zc//FaV5BIxk9LuuNPu0UEsvnMiWfsPc+lno6jdsjHpe5JoNqgHcy56GC8fO/0Xv6oChkgV8a7XiBYvLC1xWMQNY/Bt0BxXfi5bHmpD7e434l23IS1eWo7FaiX978UkfzWepo9/Wb2hRUQMVmMuIRk2bBhut5suXfRFTzyHPaQ+XrWCAbB42cHqVWyc+GkjiH3qYo6uXVDd8UTEw/17x52spMPFhh3Ztg/voFpYrFZsvt7kHj2GMyefzKRUbL7e2Gr5kpeeZUBqkTNDfup+Yp+6mF0TbyA/rWhnaL4NmgNgsXmDxYrFYsHiZSu8bNKVlY5fk3OrPbOIiNFqzBkYIp7MlZvN/i/G0Pi+d4q0N7z9FWxBdclPO0DcqJ7UiumCLSDEmJAi4nFOdsed3XOWc/kXo3Fk5ZL0+0ay9hcUOfYv28A1y6dgsVpY8/wn1R1Z5IzR5r1d2ILqkrrscxKmP0qTR4qvbwdmv0ztrtdhsdkByNq1nn3v3k/eoXjOGjm7uiOLiBiuxpyBIeKp3E4Hu1+9ifABj+EXXfR2M7agugDYQ8Lwb9aR3KTtJT2FiEgxZd1xp8uLdzG/z0hmXzgc3NCo9/kENY2gUe/z+abrA3zT9UFa3t4H37rB1Zxc5Mzw7z6+drdBZO1aV2x46q9fkrVzLQ1ufq6wzb9pO85+eQXNRs1j33sPVltWERGz0BkYIgZyu93sffMugtpfQUiXAcWGOzOP4lUrGFduNtm71+Ndr3H1hxQRj/TvHXfqn9+CkLMbEXRWA5bcObGw01q3y0Xe0UwAcg6n41M7ECwW8o9l48pzAODMd2Cv5UvOoaNGvQyRGsmZk4nV7ovFy4uMzb/iE9GsyPCja3/i0MIPaPb0/OOXjeTnYrUX3JbOyz8Yq49/tecWETGaChgiBkpf9xOpy2eRm7KH1OVf4t+kHUEdeuPMSKXOxTex69UbcWYexe3MJ2zAo9hD6hsdWUQ8REl33KnTKhrvCwvu0rNu4iyu+Hoszrx88tIy+fuN2Tiz8zi8cRdXfvcCFquV/b9uIGPvAYNfiUjNk5Owjb1v3Y2XbwAWm51Gw6ZydO2Cwv3/ntdvxV6nAdvHXgFA08e+JDt+C0lfjP2nvyw3UXe8ZuhrEBExggoYIgYK7tCbDl+V3kle82d+qMY0IlJTlXTHnb3zV7B3/opi7WvHf14dkUTOaLWancc5k9YWafP9z1kY536UfOIk2GuHE9T2kirPJiJiZuoDQ0RERERERERMTwUMERERERERETE9FTBERERERERExPTUB4ZIJYs0SafgZskhUh5m+byaJUd5BEaHGx0BME8OETMxy7bELDnONGZa7mbKIlIZVMAQqWSTOhudQMTzaL2puF4fjTQ6goiUQtu0M5vef5Gqo0tIRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETM9mdAAREZFH/oTELKNTQKQ/TOpsdAoRMdKiW18iY0+y0TFMIzA6nF4fjTQ6hogp1OTtg6es6ypgiIiI4RKzYFeG0SlERCBjTzJpcQlGxxARE9L2wXi6hERERERERERETE8FDBERERERERExPRUwRERERERERMT0VMAQEREREREREdNTAUNERERERERETE93IRERERERERExWLfJD9BscE8AXE4n2QfSSPp9E2vHf0ZWcqrB6cxBZ2CIiIiIiIiImEDyyi3MbHsXX3e8n18fmExo62h6vPeo0bFMQwUMERERERERERNw5TnIPphGVnIqB1ZuJfbThdQ/vwX2AD+jo5mCChgiIiIiIiIiJuMXVpvofl1wOZy4nS6j45iCRxcwNmzYQP/+/QkODiYoKIgBAwaQlJREYGAgN9xwg9HxRERERESq1cBVb9P24euMjiEipyj8glbcvOMTbtn1GYPXTyO8ayu2TPseR3au0dFMwWM78Vy0aBH9+vWjcePGjB49Gj8/P2bMmEGfPn04duwY7dq1MzpihThcsPwAzNx9vG1JEjQNBD8Pe5f+2/nMf+VnZvNZsyEGJBJPEtalJa3uvZo6raMJaFiPtRO+4O/J3xgdS0zor/6Wkw73rt+YNtP2VE8YMUzm/sNsfnde4eM1z39Cq3v6UbddMwNTSU3kUzuA1g8MoNEV5xPQsB55x7I5uiOR7Z8vYtfs38r16+gFr9xHUJMIFlw3pspyftdnJM4sfdHxVFnJqcR9vogDf27Fle8gKDqc5jdfSr0OzbFYTr7fk5rh4NrtLB/xJl4+dqKvvoAG3duybsIXRscyDQ/7alzg4MGDDB48mA4dOrBw4UL8/AquBxoyZAhNmjQB8KgCxq4MeORPSMwq2j5jB3y9B144Dy4MMyTaKUteuYVl97xWpM3tOrXTnqx2G658R2XEEg9g8/clbXs8u+b8Rqdnbzc6jphY2xlJhX8f2/YHu166jpaT1mKvHVHQaPUyKJlUB7fbzYZJX7Ph1a+K7F92z1nO7jnLaXhpBy56+2G8A/0NTCk1hX+DUK6c+zwuh5P1E2dyeNNuXPkO6ndsQav7rubIlr2kbt5jdEwAcg+nn3S4jqvMye12s/HNb1k34YuCYpgFwMKBFVvY/sViGlx8LhdP/T98gmsZHVWqmDMnj4w9yQCsnziTwOhwOr9wJ3889q7ByczBIy8hmTBhAkeOHGH69OmFxQuA4OBgOnToAHhOASMpC+79vXjx4l+ZDvi/VbDmUPXmOl3/dj7z3385/9mhnn1bbwYsm8SQPV8weOMH9Hj/scJhA1e9Tfv/3UCXF+/ihs3T6fPtc0a8BDFI4uJ1rB3/OXvm/YErL9/oOGJi9trhhf9sAXUAsAXVO94eXM/ghFKV/n59Nusnziy1OJ6wcC2Lb5ugL2pSKbq+eDde3ja+u/wJds3+jaNxCWTsTmbnV8v47oonSN+VRO9vxnHBK/cVma7tw9cxcNXbALR7dBAxN19K+AWtuC3pa25L+ppmg3qcdL4R3dowZO8XePl5A+DlY2fI7s/pM/f4sVHERW0ZsvcLbP6+QPFLSEo7rgpt25TLvnyam3d8wg2bPqDnB49Tq2Hd015Wcmo2vzOPteM/O34mjxtwuwuH71+2gUVDxuPM1bHRmWb9KzNpNrgnoeeeZXQUU/DIAsaXX35J9+7diYmJKXF4WFgY4eHhRdqys7Np1qwZAQEB1RGx3D7cDkfySh/uBlxumLy5yDbMo7V7bBDnjb6ZbTN+Yu4l/8cvNz1P6sZdRcZpeeeV5BxK54ernmL5I28ZlFRERMwo+9BR1r86q8zxkv/YzN4fV1VDIqnJvEMCiOzVnq3TF5CfUfwXJ7fDWa5r0ze9M4+ds38jZXUsM9vexcy2d7F73h8nnSZlTSy43IR1bglA/fPPJj8zm7rnNsPm5wNARLfWHFq/E0dWTqnPc+JxVXBMQ3rPHsfBNbHM7/0/Fgwch9vp4vIvn8HLx17ma5HKlXskg7Uvf1nmeCmrY9lTxmdGap6M3cnE/7KGDiNvNDqKKXjcJSTJyckkJiYyePDgYsNcLhcbN26kffv2xYY988wzNG7cmOTk5ArNz+FwVHia8sp0Wvh+XwQF54iVfk2bG9h2FJbEHSCmVvVUXfNP8xerfzuf+a/k3zez7L5JtB7Wn3Uvz2Tb9AWFw1I37i4y7qH1O4sdnObnO0hISDitXGIOp/v5qi5GfOYOZNqBgmvGDqQcIDjzzPilJT8/DDD+oDk/P5+EhANGx5Ay7J7+C26Hs1zjbpg6F3uHRlWcyPPkHEgr/DspKQlfV7ZxYUzmxH1UUHQ4Vi8v0uJOb3/gyMrBmZ2LK7/gLNXycObkcXDtdiK6tWH/0g2Ed2vNvp/WUL9jDGFdWpK4ZD0RF7Zh/7INJ32eE4+ruk1+gIRf1rL+leNtvz74Ojdt+4jInu3Yt2B1YbuOv6re3s+W4CrPmRUW2PDePHy66pd4oxh1DLvp7Xn0/e4Fwru2InnF5iqZhxHrenh4ODZbxUoSHlfAyMzMBCixE5u5c+eSkpJS7PKRv/76iwULFvDqq69y7bXXVmh+ycnJREVFnXLek6kV05mzJ64s9/g3/N+zHPzh7SrJcqLnQy8j0h50ytP/2/nMfzmycwlpEYXNz6ccO9rtxdri4uIYVEXvhVSv0/18VRcjPnP+zTrS8tWCA8er+vUja8eaap2/Uc55YxN+jVoZHYO4uDiirmhtdAwpw4MhXejg06BcHdod+Cu2yvbjnqy21Y/X6l8JQKdOnTiiAkahYvsogztOTPp9E1GXdwQg4sLWbP3wR5y5+YRf2JqU1bGEtm3KXy98etLnOPG4KrRdM4Kiw4v92OTlYyewSUSRNh1/Vb17gzvRxa8cy9gNRzbu1jbNQFV9DLv84ZLPPD+4JpYZEQOrbL5gzLoeHx9Pw4YNKzSNxxUwoqKi8PLyYtmyZUXa9+7dy/Dhw4Gi/V84HA7uvvtu3nrrLVyn2IlklaloB3Me1CHdfzuf+a9aEaHlmt6h3rNFRKQU1pOctXg644qUJH13Ei6nk5CYhuz74c9Sx3O7XMWKHVbb6R+7Jf2+iXP/byC1IusS2rYpycs34crLp83wawvvVJGyJvakz3HicZXFamHn18vY+Oa3xcbNPZJx2pmlYiqynbJgwULBGdoiZyKPK2B4e3szdOhQpk+fTv/+/enbty/x8fFMmzaNsLAwEhMTixQwJk6cSPv27bnoootYunRphecXHh5OfHx85b2A/0jLt3LHRjeucm60PpjwNO3feaJKspxoxaCXyNxd+ZfOpMUl4MjOpcHF53Jk694KTRsTE0P8rA8rPZNUv6r6fFU2Iz5zcZl2nvjnOPS7+fOr7bIxow3fEkZ86ZdvV5uYmBh+qqJtvlSe7W98x96PF5U9ogVqN48ifo3e0xPlHEhjeb+xAKxatQrfsBBD85jJifuovLRjJC5eT8vbe7P1gx+L9YNhsXnhZbeRcygd//A6RYaFtmla5LEr34HFq2Jd0B1aux1nbj7nPjKQ9N3JZB9MI+n3zVz8ziM0vrIzKWvicOVV7LT2wxt2UvucxiX+2HQiHX9VvZ3v/sDuD34ue0QLBDQOY5+2aYbxlGPYU2HEun5iv5Xl4XEFDIApU6Zgt9uZO3cuixcvpmvXrsyZM4dnn32WHTt2FHbuuWPHDt59913WrVt3yvOy2WwVPq2lvBoCPQ7B4qSTj2cBIvyhb8t6WKvphyS7/fQ+GlZvG371Qoq1Zx9MY/PU72j32PU4c/LY/+sGvHy9adirAxvfmFNmpqp6L6R6nezzZfP3JahJwcbMai/4HNVpFU1+Zk65DrQqkxGfuaNHgH8KGGH1w2hYu1pnbxj7dsAEBQy73a7tjAcIuv+a8hUw3ND6zr56T0uQaT1+F7eIiAhqNSjfGZJngpL2USufnMaVc5/nqp8msG7iTFI378GV56Deec1pfX9/lo94k/2//U3Xl+6mcb+upG7aTXS/LoR1bkleembh82TsSyH6qq6ExDQk+9BR8o9ll1l8cOU7SFkdS7NBPYj9uOBLbl7aMY5si+es6y4qV4e2J/p7ymz6/fAS3d8awdZp35NzOJ2AqHo06tOJLdO+59i+lCLLQ+tQ1Qq59xp2T/+loOf+k9E2zXCn+x3JzDxlXffIdyAgIICpU6cyderUIu2bNm2iTZs2WK0Fle3ly5dz4MCBwoJGfn4+mZmZ1K1bl9mzZ3PRRRdVe/YT3dEclh+AfFfpp4K5gfvPptqKF5UhvMs5DP77/WLtX7S6nXUTviTncDot7+zD+eNuJe9oJgdWbjUgpZhR3XPPovfscYWPW97Rh5Z39CH5j80suG6MgclExCyCosNpfuMlbP9i8UnHC2wSwVkDjd/Xi+fLTDzEvCueoM0DA2j36CACIuuSdyybo9sT2PTOXI5s28eR2Hhqnx1FlxfvwstuY+fs39jywQ80u/7iwufZ/sViIi5szZXfvYB3UC2Wj3iTHbOWljn/5N83EXnxuST9vqmwLen3jYS2aULS8k0nmbJkR7cn8v1Vo+jwvxu57IvRePnYyUpOJen3TeSlF7/TilStgKh6tLjlssICVanjNapPs8E9qieUiElZ3O6acXPOtLQ0ateuzb333su7774LQFZWFqmpqYXjrFixgttuu43Y2Fjq1auHj4+PUXGLWJECj6+GHCfFrmmzAP/XGm5sWsrEVeTbix8+7d62K1tITEMGLJtsdAypBGb8fJXEiM/c5iNw628Ff3/UHVqdIWdgDFoCu0xw2XXTQJjV0+gUUh7OvHx+e3AKe75bUXTAPzvSoKYRXPbl0wRG1Tckn9ll7j/MV+fdC8D1f03VGRj/4Sn7qOqi46/q4cp3sHzEm+yas7zogH+2aYGNw7jsy6cJiq74KfdSeWry9sFT1nWPPAOjJBs3bgSKduDp7++Pv79/4eN69ephsVhMd2pM1/rwbS/4dh/8EA+puVDLBj0iYGA0NAk0OqGIiIi5eHnbuXjq/xEzZCPbpi8gZU0srnwnwU0jiBlyGU2uvhCbvzl+qBARKYvVbqP7WyNofsulbH57HgmL1gJQ+5xoWt7emybXdMPu72twShHj1egCxol69OjBsWPHqilRxdT1hbtiCv6JiIhI2SwWCw26t6VB97ZGRxE5JU2v7U7Xl+8pdfi3Fz9CZuKhakwkRrJYLERc0Jqg6IjCM6Qu/fhJnSFlUl5+3lwxawwhzRuy4n/vsXvu78XGibq8I20fuhZnvoO4T35h1+zfCIlpSNeJ9+J2uXE7nPz+6DtF+p05Uei5Z9Hp2duxWC1s/fBHdp9wlk5AVH26TXkQXG6cefksu/c18tKz6Db5AWqf05j8jGyO7kxkxRPvAXDLrs84tG4HAFve/559P66qxKVS9WpMAWPYsGEMGzbM6BgiIiIiIuWy76fVHFy7vdThWcmppQ4TEWO5ch0suWMiLYZeXvIIFgvnjbqZ+X2exJmbR+/Z44j/5S9yDqez8JYXyc/IIrJnO859ZCC/P/J2qfPp/NwdLLt/EjmHjtJ3/njif1qDI+t4z+cthl5O3GcL2fX1r7R+YABnXd+DrR/8AMDKkdOKbWMyEw95dL9yNaaAISIiIiLiSRyZOWRk1sxbMorUdG6Xi+yDaaUO960TSM6h9MJiw9Ed+6nXoTn7l20oHMeV78TtdJX6HF4+dqzetsIzsVLWxBJ6blMOrNhSOM6R2H14B9UCwDvYnyOJBwuHdXruDpy5eWx8Yw6JS9YD4BdWm96zx5F9II0/R39AzuH0Cr92I6mAISIiIiIiIlKJcg6n41s3CL/6IeRn5hDWuSVJv/5dONzL15t2jw9ixf+mlfoc3iEB5B09fivm3KOZ+IQEFBkn+Y/NXPb5aFrccikuh5MNr30NwOpnPyY3NQPfusH0/mYsB/+KIy89i2+6PEBuagZNrunG+WNv5bfhb1TyK69aVqMDiIiIiIiIiNQ0K/73Hhe9NYKL33mEtNh4sg4UXBZm8bJy0dsj2PzOPNK27St1+ryjmXgH1yp87B1Ui9y0on06dhx1C2vHf8bcSx5l09tzOe+pmwDITS24vVvOoaMc2rCLwCYRRdr3zPuDOq2bVN6LrSYqYIiIiIiIiIhUsgMrt/LT9eNYdt8kbP4+HPyroD+KC1+9n/1LN7BvwerCcW21fPEO8i8yvTMnD1eeA//wOli9bdTvGMPhv3cVnYnFQk5hsSIdn9oFt7C0BxY8l5evN3VaRZOZcBCbnw8Wa0EJIKzLOWTs8bxL2HQJiYiIiIiIiEgF9Xj/MUJbN8GRlUPdDs1ZPWYGkT3b4R0SwO45y+k4ZiihbZricjhZ++LnuPIdRPZsR/TVFxAQVZ8m/S8kdfNuVj0zgyYDumHz9S7sgPNfq56ZzsVT/w+L1cLmqd/hyMzBr14I59zbj7+e/5S/J39N15fvxe10YbFZ+ePxqQBc/M7D2AP9sdq92PzuPHIOpxPatikXvHIf+Zk5uPKdrHhiqhGL7bSogCEiIiIiIiJSQUvveqVY27+dZQKsGfdxicM/bXpzsfbaZ0exYfI3xdoPrd/Bj/1HF2nLPpjGX89/CkBaXAI/Dni62HQLbxlfrO3w37v47vInir8QD6IChoiIiIiIiIiBVj093egIHkF9YIiIiIiIiIiI6amAISIiIiIiIiKmp0tIRKTaBUaHGx2hXDwlZ00Q6V/2ONXBLDlExDja9hel5SFyXE1eHzzltamAISLVrtdHI42OICYzqbPRCURECmgfJSKl0fbBeLqERERERERERERMTwUMERERERERETE9FTBERERERERExPRUwBARERERERER01MBQ0RERERERERMTwUMERERERERETE9FTBERERERERExPRUwBARERERERER01MBQ0RERERERERMTwUMERERERERETE9FTBERERERERExPRUwBARERERERER01MBQ0RERERERERMTwUMERERERERETE9FTBERERERERExPRsRgeoaR75ExKzjE4Bkf4wqbPRKc5Mi259iYw9yUbHIDA6nF4fjTQ6hpzBzLIuVBWtYyIi5lGT9jkuh7Pw75+uH4vV5mVgmspTk/ebnvT58/T3QQWMSpaYBbsyjE4hRsrYk0xaXILRMUQMp3VBRESqS03d56TvSjI6gpRDTf38mZEuIRERERERERER01MBQ0RERERERERMTwUMERERERERETE9FTBERERERERExPTUiaeIQbpNfoBmg3sC4HI6yT6QRtLvm1g7/jOyklMNTiciIiIiImIuKmCYyJ7Xb+Pw4o8KHli98A6NJKhDHyJveQFbUKix4aRKJK/cwrJ7XsPiZSUwOowu4++ix3uP8sPVo4yOJuIRVAgUEZGaovc340jfncQfj71bpD2gYT0Grn6HH/qPJmXVNoPSiZiDLiExmYBzutN2RhJtpu0h6u4ppK34ht2ThxodS6qIK89B9sE0spJTObByK7GfLqT++S2wB/gZHU3EYySv3MLMtnfxdcf7+fWByYS2jqbHe48aHUtEREREKpnOwDAZi80be+1wALzrNiR77yb2f/EMrtxsrD76UluT+YXVJrpfF1wOJ26ny+g4Ih7j30IgQFZyKrGfLqTLC3diD/Aj/1i2seFEREREpNLoDAyTs/r4gcuF2+kwOopUgfALWnHzjk+4ZddnDF4/jfCurdgy7Xsc2bkA+IfXYeCad/ANDQLAy8+ba39/g5CzGxkZW8S0VAgUERERqbk8uoCxYcMG+vfvT3BwMEFBQQwYMICkpCQCAwO54YYbjI532rL3bSHlh7eoFdMZL/9Ao+NIFTi4djvzLn2c+X1Gsv61r0hZHcu6CV8UDs9KTmXL1PmcP+42ANo9Ooi9P/5J2rZ9BiWWqpb9n1rlkVzjcniSsgqBIiIiIlIzeOwlJIsWLaJfv340btyY0aNH4+fnx4wZM+jTpw/Hjh2jXbt2Rkc8JRmblrJucABulxN3fi6BbXvReNhUo2NJFXHm5JGxJxmA9RNnEhgdTucX7izSedPWD36k34IJtLzrShpf2Zl5vR4zKq5UoQPZ8EEczI8/3vbIKugWBnfGQOvaxmUzu4Nrt7N8xJt4+diJvvoCGnRvW6QQKCIiImKEyEvac96TNxHcvCHZKUfY8sEPbJk63+hYHs0jCxgHDx5k8ODBdOjQgYULF+LnV9A3xJAhQ2jSpAmAxxYwasV0Jvrhj7BYbdjrNMBq9zY6klSj9a/M5JpfXyf2k184vGEnAG6Xi9VjZtB79jgW3/GyflWugfYdg3t+h0MnvLVu4LcDsCIFXuoIPSIMiWd65SkEioiImF1eehbeQbWKtXsHF7Q5c/OrO5KchtBzz6LXjP+x6d15LBs2mXrtm9N1wj04s/OI/fhno+N5LI+8hGTChAkcOXKE6dOnFxYvAIKDg+nQoQPguQUMq7cfvhHN8AmLVvHiDJSxO5n4X9bQYeSNRdoje7UnKzmV2ur7osZxueH/VhUvXvyX0w1P/QVJWdWXy5Otf2UmzQb3JPTcs4yOIiIiUm5HdyQS2rYpFmvRr2h12zfD5XCSsTvJoGRyKlrd049D63eydvznHN2eyI5ZS9n64Y+0eXCA0dE8mkcWML788ku6d+9OTExMicPDwsIIDy+4k8dtt92Gt7c3AQEBhf8WLFhQnXFFKmTT2/OI7NGO8K6tAAg5uxGNendifp+RNL+pFwGN6hucUCrTyoOw59jJx3EDeS6YvbdaInm80gqBIiIiZrbtowX41gvmwskPENq2KYGNw2gy4ELaP3EDO2YuIS9dv2R4kvqdziZxyboibYlL1hMQVR//iDoGpfJ8HncJSXJyMomJiQwePLjYMJfLxcaNG2nfvn2R9nvuuYc333zzlObncDhITk4u9/j5+WGA/ZTmVZny8/NJSDhwGtOb764n+fkOEhISjI5RpvIuu+UPv1Vi+8E1scyIGFj4uOuEe1g9ZgZZyamse/lLOr9wJ4uGvFiuHJ6wvM503+ypDRQ/XbQ4N9/tcdI/sPzbI6MZuR3Z9PY8+n73AuFdW5G8YnOVzEPrmHiynANphX8nJSXh69Ith8WzmfHYtaIyEw7xw1Wj6PC/G+n10UjsQf4c23uATW/PY8v73xsd77TV5P1mSZ8/v/ohhbd5/1d2ypF/htUmKym1OqIVY6b3ITw8HJutYiUJjytgZGZmAmCxWIoNmzt3LikpKZV6+UhycjJRUVHlHv+cNzbh16jVKc0resSMU5quJHFxcURd0fqUp38+9DIi7UGVlqcyxMXFMagC74VRKnPZNb/5UnIOHSVh0VoAdn61jOY3XkKjKzuz74c/TzqtpyyvM12zMT8S1O7yYqeLFmchJdNRoe2R0apjO1LeQmBV0Domnqy21Y/X6l8JQKdOnTiiAoZ4ODMeu56KI1v2sujWl4yOUSVq8n7Tkz5/Znof4uPjadiwYYWm8bhLSKKiovDy8mLZsmVF2vfu3cvw4cOB4v1ffPbZZ9SpU4eWLVvywgsv4HB4foVWzgzbP1vIkjsnFmlbcO2YMosX4jlc2RlQQkH2RG63G2d2RjUkEhEREZHTlZ2Shl+9kCJtvv88/vdMDKk4jzsDw9vbm6FDhzJ9+nT69+9P3759iY+PZ9q0aYSFhZGYmFikgPHQQw/x8ssvU7duXdauXcuNN95ITk4Ozz33XLnmFx4eTnx8fNkj/mP4ljDicyr6qipfTEwMP1Ug94lWDHqJzN3mOlU9JiaG+FkfGh2jTGZZdp6yvM50Sw/7M3lv2QUMi8XClU39+P401uvqZpZ1oapoHRNPlnMgjeX9xgKwatUqfMNCDM0jcrpq+j6nJqjJ+82SPn8pq7bRoEc7Nkz6urAtsmc7jsWnGHb5CJjrffi338qK8LgCBsCUKVOw2+3MnTuXxYsX07VrV+bMmcOzzz7Ljh07inTu+e9dSQA6duzIuHHjGDNmTLkLGDabrUKntdi3AyYoYNjt9gqfjlN0evN9NOz2ir0XRjHLsvOU5XWmuz4CPkqCtLyCzjpP5rbWATQMDqiWXJXBLOtCVdE6Jp4s03r8Lm4RERHUahBqYBqR01fT9zk1QU3eb5b0+dv83nz6fvcC7UfeyK6vl1G3fXNa3tGH1WM/MiDhcZ7+Pnjkmh4QEMDUqVOZOnVqkfZNmzbRpk0brCe5ltxqteJ2l/U1QUSkevh4wYsd4aGVBXcaOZGFgsLG8JbQIri604mIiIjIqTi8YSeLb3+ZDk/eROv7rib7YBprJ3xB7Mc/Gx3No3lkAaMkaWlpJCQk0Ldv3yLtM2fOpHfv3gQFBbFx40bGjRvH9ddfb1BKEZHiOtaFdy+ASZth4wmXRIb7wT0t4KpGxmQTERERkVOTsGhtYWf8UjlqTAFj48aNQPEOPN9++23uu+8+8vPziYiIYMiQITz55JMGJCwqJzGOzcNb0eLF3who0aWwPTd5F3veuBO3I4+QLtcQfs1jAKy93p9aMZ0AqN9vBLW7XmNIbjl1zW/qRfMbLsHtdrHif9NI27avcFi3yQ9Q+5zG5Gdkc3RnIiueeA8vP2+umDWGkOYNWfG/99g99/ciz9fusUE06X8hc7qPqO6XIlWgbR2Y3h22HYVNR8DhgsYB0KkeeJXdRYbpBTSsx0VvP4zL4cDi5cXKkdM4snVv0XEa1efC14ZhtdvY9+MqNr87r8z14ESh555Fp2dvx2K1sPXDH9k9Z3mR4VGXd+S80bdQq0EonzUbUtje+5txWO02XPkOkldsZv0rs6h3Xgznj7kVV74Dt9vNb8OnGHrNqoiIVExITEO6TrwXt8uN2+Hk90ff4di+lCLjePl50/m5OwhoFIbVy8rCW8YT0iKKjk8X7CNsAb5YLBa+u/yJEudh8bJy6adPYfP3wWK1suG1r0hcsr7EcUs6drPYvLhm2WS2f7GIjW9+W+Zr6vb6g/jVC+aXm14ocXj4Ba3o/c04Zra9i+yDaVisVs4bfQt1WkVjtXnx+6PvkLGn5L5CmvS/kHPu6YczL5/s5CP8NuINXHlFb37QZvg1NOrTCYulYD+786vjN1Y4cd4iVaHGFzBOvFuJWSTNeo7AVhcXa0/46H9EDhlPrRZdiBvVg9oXXIdPWBO86zWixQtLqz+oVArvkABa3Ho53/d9isDGYXR96W5+un5ckXFWjpzGwbXbCx+7ch0suWMiLYZeXuz5fOsGE9S0QZXnlup3dnDBv5omM+kwP/QfDW434Re2pu1D17Ls/klFxuk4eghrX/ycg3/F0Xv2OPZ+v5LMxEOlrgcl6fzcHSy7fxI5h47Sd/544n9agyPreMdEKau38d1lj3P1wleKTbvkzolFDrgO/72LH64eBUCzGy6h5e19+Gv8Z6fw6kVExAg5h9NZeMuL5GdkEdmzHec+MpDfH3m7yDjt/m8Qu+YsJ/n3TYVth9bvYMF1YwA45+6+ePl6lzoPt8vNypHTyNh7AJ/aAfSe81yJBYzSjt1aDLmMozsSy/V6ardsjHdQrZOO0+reqzi0fkfh45hbLiUtLoE1z35c5vMfXLedH64ehdvp4rynbqZJ/wuLFCi8/LxpNqgHcy56GC8fO/0Xv1pk+InzFqkKHncb1dIMGzYMt9tNly5dyh7ZYJmxf2IPCce7bvHOU3ISthJwdlcsFgvBHftybPOvAOSn7if2qYvZNfEG8tNSik0n5lavfTOS/9iM2+Ekfed+fOoEFbt1Zqfn7qD37HFE9mwHgNvlKrV6fe4jA9n4xpwqTi1SedxOF/zT/5B3oB+pW/YUGye4eSQH/4oDIGHhWsK6tDzpenAiLx87Vm8bmYmHcObmk7ImltBzmxYZJ/fIMZy5+cXzud30mPYol3/5NKHnngWAK//4r06lZRYREfPKOZxOfkYWAK58Z8G+6AThF7ai0RUd6f3NONo+fF2x4U2u6VbsbL4i3G4y9h4AwJmTX7ivO1FJx242f18iL2nP3u9Xluv1nPvIQP6eMrvU4dFXdSVx6XocWblF2gKjw7ji67F0evY2LF6lf/07ti+lcBm5HE7crqLLy5mTT2ZSKjZfb2y1fMlLzzrpvEWqQo0pYHiSpK9eIPy6kSUP/M+GwiugNo6MgtOV27y3ixbjlxHS6WoSpj9aHTGlEnmHBJB3NLPwcf6xbLyD/Asfr372Y77v+yRL73mN88feWmTYiQKbhGOv5Vvs9HsRs6vTKporv3uBzi/cRdJvG4sNt1iPF/Vyj2biUzuwQs9/4nqWezQTn5Dy3bVl6T2v8uOAp1k56gO6T3mwsD2yZzv6/fgSLYZezqH1OyuUR0REzMHL15t2jw9iy/s/FBtW55xoEpesZ8HAsYS2aUp411aFw4KaRuDKd3As4WC55tNxzNAS51HasVvrYVezZdr35Xru8K6tOLprPzmlFPUtNi+a33wpcZ8uLNLuH16HrP2H+WngWADOuu6iMucV1DSCyJ7t2PvDn0UHuN3sX7aBa5ZPof/CV9gybf5J5y1SFVTAqGZH13yPf7OO2IJKuV3Zf36Vdx5LwxZYBwBbUF0AancbRNaudVWeUypX3tHMIqf82QP8ilStc1MzAMg5dJRDG3YR2CSi1Odq99jgIveTFvEUqZv38MNVo1h020t0Hn9nseH//dHKO8if3CMZFXr+vKOZeAcfX8+8g2qRm3asXNP+uw6m79xPTmoGPqFBACQuWc/8PiP568XP6fDkTRXKIyIixrN4Wbno7RFsfmdekf7H/pWTmk7i0g2FX85rn9O4cFjTa7uza/ZJzr74j9bD+uPIzmX7Z8W/xJd07OZbN5g6rZuQ9Ovf5Xr+NsMHsPntuaUOb3HLZez65tciZw8C5KYdI3FxwXeHxCXri7y+kvjVC6Hb6w+y7L5JOLPzigwLahpBo97n803XB/im64O0vL0PvnWDS523SFVQAaOaZe1az7FNS9k+tjfp638h4YNHyE9NKhzuG3UOmXGrcLvdHP3rBwLO6Y4zJxO30wlAxuZf8YloZlR8OUUH124nrEtLLF5WAqPDyU1NL/JtzR5YcMaFl683dVpFk3mSSn9go/p0efEuLvt8FP4Rdej4zNAqzy9yuqzex7tcyk/PKnZQBHA0LoG67Qq2bw17deDAn1tLfT5bLd9iZyo5c/Jw5TnwD6+D1dtG/Y4xHP57V7ny2QP8APAJDcKvXgi5qRlFMucdzcSZUzyziIiY24Wv3s/+pRvYt2B1icMPrNxKaNuCyw1D2zYlfffx4/Loqy9gz3d/FD4uad8DBf0k1WkVzZpxJfczUdKxW+2WjfANDeKyz0fR6r6raDa4Jw16nIvFy4pf/ZAi09tq+eJXL4SL332EblMeJLRtU1rdf3WRcULOjqLpdRdx2eejqN2yERe9PQIsFpJXbC68NDL03LNI313QgWetyLrFcnoH+dPj/cf4c/SHhZfFFGGxkH8sG1eeA2dOHs58B/ZavqXOWyqm2+QHuC3pa25L+pqhCTO5/q+pdJsyHP/wOkZHM5Ua04mnp4gYNIqIQQWdwu15/Tbq9r6PrD0bcG5cQp2LbyJy6IvsffMu3I58Qjr3xye8KZk7/mLvW3fj5RuAxWan0bCpBr8Kqai8tGNs/3wRfeY8h9vtYuWT7xPZsx3eIQHsnrOci995GHugP1a7F5vfnUfO4XQAerz/GKGtm+DIyqFuh+asHjODH64aVfi81/z2erk6ZRIxWv3zz6bdY4NwO11YLBZWjZ0BUGQ9+Gv8Z1z46v1YbF7E/7S6sKf4ktaDJgO6YfP1ZusHRU/VXfXMdC6e+n9YrBY2T/0OR2YOfvVCOOfefvz1/KfUbd+cDiNvxL9BKJfPfIbNU78jccl6rvhmLM6cPKw2G6uemQ5uN9H9uhJzy6W4XW5cDicrHnu3uhebiIichsie7Yi++gICourTpP+FpG7ezapnZpyw7/mUC1+5Hy9fb9Ji4wvPVqjbvjkZew8UnqEHlLjvsfn7csHEezm0bge9vynooH3BdWOK7HtKO3b793LKZoN64Fc/hP1LNxDYJJyOo4ew5M6JhdM4MnOYd9njQMFdvbq+fA+b35kHQLcpw1n+0BusHDmtcPze34zj12Gvg9vNprfm0m3yA7S8ow85h9P5bfgUAC795EnmXlL0svQ2D15DYKP6nP/Pj2M7Zi5hx6yltHlwAPt+XsPRuAQOb9zFld+9gMVqZf+vG8jYe6DUeUvFJa/cwrJ7XvvnR88wuoy/ix7vPVrYqbiAxe3Wp6syDVoCuyp21nOVaBoIs3qe+vTfXvwwaXEJlReoEoTENGTAsslGxyiTWZadpywvqbmqcl3o9NztbJj8Dbn/FPuMoHVMPFnm/sN8dd69AFz/11RqNSjl0lYRD1Edx1/Vse9pem138tKzSFj4V5XNwz+8Dufc3Zc1z31SZfMoSU3eb1bG56/b5Afwjwjl58HPFradfUcfurxwJ581H0L+sezTjQl4/vugMzBERMTjrHp6utERRETkDFMd+55ds3+r8nlkJadWe/FCKs4vrDbR/boU3BGmhDvonKlUwBARERERERExWPgFrbh5xydYrFZsfj4AbHpnHo7sgtvTNurTiXb/d32RaYJjGrLq6enE/7yGK+e/wPwr/kfO4XS8/Lzpv/BVFt85scQObD2VChgiIiIiIiIiBju4djvLR7yJl4+d6KsvoEH3tqyb8EXh8H0/rmLfj6sKHzfqfT4dnryJHV8txZmdx5ap8zl/3G389uAU2j06iL0//lmjihegAkaliyzeMbEhzJLjTBQYHW50BMA8OeTMVdM/gzX99YmIeBJtk81P71HZnDl5ZOwpuFPM+okzCYwOp/MLd/JHCR2J+0fUofP4u1h48/jCu7tt/eBH+i2YQMu7rqTxlZ2Z1+uxas1fHVTAqGSTOhudQIzW66ORRkcQMQWtCyIiUl20z5GaaP0rM7nm19eJ/eQXDm/YeXyAxcJFb45g45vfcmTr3sJmt8vF6jEz6D17HIvveLnw0pOaxGp0ABEREREREREpKmN3MvG/rKHDyBuLtJ/78HXkZWSx7cMfi00T2as9Wcmp1D67UXXFrFYqYIiIiIiIiIiY0Ka35xHZox3hXVsBUP/8FjS/qRe/P/JWsXFDzm5Eo96dmN9nJM1v6kVAo/rVHbfK6RISEREREREREQMtf7h4QQLg4JpYZkQMBMA7yJ/ubzzE8hFvknvkWLFxu064h9VjZpCVnMq6l7+k8wt3smjIi1Wau7qpgCEiIiIiIiJici1uvQK/+iF0GndbkfYdXy0jPzOHnENHSVi0FoCdXy2j+Y2X0OjKzuz74U8D0lYNFTBERERERERETG7jG3PY+MacUodv/2xhkccLrh1T1ZGqnfrAEBERERERERHTUwFDRERERERERExPBQwRERERERERMT0VMERERERERETE9FTAEBERERERERHTUwFDRERERERERExPBQwRERERERERMT0VMERERERERERMwMvPmyu/e4Gbtn1Ek/4Xljj8glfu4/JZY+j9zThsfj5lTlOT2IwOICIiIiIiIiLgynWw5I6JtBh6eYnD2/3fIHbNWU7y75sK2yxW60mnqUlUwBARERERERExAbfLRfbBtFKHh1/YCi8fG+3+73r2//Y3f0/+psxpahIVMEQq2aJbXyJjT7LRMQiMDqfXRyONjlEuj/wJiVlGp4BIf5jU2egUIiJiRmbZv1cVTzpuEDmT1TknmvUTZ7JqzEf0fP8xwru2InnFZqNjVRsVMEQqWcaeZNLiEoyO4VESs2BXhtEpRERESqf9u4iYQU5qOolLN4Dbzf5lG6h9TuMzqoChTjxFREREREREPMCBlVsJbdsUgNC2TUnfnWRwouqlMzBERERERERETKLH+48R2roJjqwc6nZozv6l6/EOCWD3nOX8Nf5TLnzlfrx8vUmLjSdx8boSp1k9ZoaxL6KKqIAhIiIiIiIiYhJL73ql1GGZCYf4+YbnKjRNTaJLSERERERERETE9HQGhohBuk1+gGaDewLgcjrJPpBG0u+bWDv+M7KSUw1OJyIiIiIiYi4qYIgYKHnlFpbd8xoWLyuB0WF0GX8XPd57lB+uHmV0NI+x5/XbOLz4o4IHVi+8QyMJ6tCHyFtewBYUamw4ERGRCtCPGyIiJ6dLSEQM5MpzkH0wjazkVA6s3Erspwupf34L7AF+RkfzKAHndKftjCTaTNtD1N1TSFvxDbsnDzU6loiISIUlr9zCzLZ38XXH+/n1gcmEto6mx3uPGh1LRMQUdAaGiEn4hdUmul8XXA4nbqfL6DgexWLzxl47HADvug3J3ruJ/V88gys3G6uPikEiIuI5/v1xAyArOZXYTxfS5YU7sQf4kX8s29hwIiIG0xkYIgYKv6AVN+/4hFt2fcbg9dMI79qKLdO+x5GdC4B/eB0GrnkH39AgALz8vLn29zcIObuRkbFNz+rjBy4XbqfD6CgiIiKnTD9uiIgU5dEFjA0bNtC/f3+Cg4MJCgpiwIABJCUlERgYyA033GB0PJEyHVy7nXmXPs78PiNZ/9pXpKyOZd2ELwqHZyWnsmXqfM4fdxsA7R4dxN4f/yRt2z6DEptf9r4tpPzwFrViOuPlH2h0HBERkQop68cNEZEzmcdeQrJo0SL69etH48aNGT16NH5+fsyYMYM+ffpw7Ngx2rVrZ3TEGiusS0ta3Xs1dVpHE9CwHmsnfMHfk78xOpZHcubkkbEnGYD1E2cSGB1O5xfu5I/H3i0cZ+sHP9JvwQRa3nUlja/szLxejxkV17QyNi1l3eAA3C4n7vxcAtv2ovGwqUbHEhExJUdWLru/XV74eOWT04i5+VIie7XH6uVlYDKBgh83lo94Ey8fO9FXX0CD7m2L/LghIp5D35sqn0cWMA4ePMjgwYPp0KEDCxcuxM+v4Br3IUOG0KRJEwAVMKqQzd+XtO3x7JrzG52evd3oODXK+ldmcs2vrxP7yS8c3rATALfLxeoxM+g9exyL73hZv8CUoFZMZ6If/giL1Ya9TgOsdm+jI4mImFLikvUsu+818tKzCtvif15D/M9rCGwSwaUfjyS4WaSBCaU8P26IiGfQ96bK55GXkEyYMIEjR44wffr0wuIFQHBwMB06dABUwKhKiYvXsXb85+yZ9weuvHyj49QoGbuTif9lDR1G3likPbJXe7KSU6mtvi9KZPX2wzeiGT5h0SpeiIiUIvmPzSwc+iJ5GSV3BJmxO4kF144hM/FQNSeTk1n/ykyaDe5J6LlnGR1FRCpI35sqn0cWML788ku6d+9OTExMicPDwsIIDw8vfPz999/ToUMHatWqRXh4OBMnTqyuqCIVtunteUT2aEd411YAhJzdiEa9OzG/z0ia39SLgEb1DU4oIiKexu12s2rsDNxOJ7jdpY6XfTCNv6fMrsZkUpbSftwQETkTedwlJMnJySQmJjJ48OBiw1wuFxs3bqR9+/aFbT///DP33HMPH3/8MRdffDFZWVns21f+DhAdDgfJycmVkt2T5Oeb7+4N+fkOEhISjI5RpvIuu+UPv1Vi+8E1scyIGFj4uOuEe1g9ZgZZyamse/lLOr9wJ4uGvFiuHJ6wvADy88MAu9ExyM/PJyHhgNExREQq3dHNe0nduLtc426ftYSI2y/BFuBbxak8i5HHRpvenkff714gvGsrkldsrpJ5eNJxg4jZmPG7U2nMtK6Hh4djs1WsJOFxBYzMzEwALBZLsWFz584lJSWlyOUjTz/9NE8//TS9evUCICgoiNatW5d7fsnJyURFRZ1eaA/0fOhlRNqDjI5RRFxcHIM84L2ozGXX/OZLyTl0lIRFawHY+dUymt94CY2u7My+H/486bSesrwAznljE36NWp3StNEjZlRajri4OKKuKP/2QUTEU/TyP4tbgtqVa1xXTj692nZiV/6Rqg3lYarj2Ki8P25UBU86bhAxGzN+dyqNmdb1+Ph4GjZsWKFpPO4SkqioKLy8vFi2bFmR9r179zJ8+HDgeP8XmZmZrF69muTkZM4++2zCwsK4+uqr2b27fL9AiBht+2cLWXJn0UueFlw7pszihYiIyH9ZKf7DT2WOLyIiUh087gwMb29vhg4dyvTp0+nfvz99+/YlPj6eadOmERYWRmJiYmEB48iRI7jdbr755hsWLFhA/fr1efjhh7n22mtZu3ZtiWdxnCg8PJz4+PgqflXms2LQS2TuNtelMzExMcTP+tDoGGUyy7LzlOUFMHxLGPE5RqcoWGY/nYHru4jUfIdXbGXdQ+W8vbTVwoLVy/EJDazaUB7GLPv3quJJxw0iZuNJ2wczrev/7beyvDyugAEwZcoU7HY7c+fOZfHixXTt2pU5c+bw7LPPsmPHjsLOPQMDC3a8I0aMIDo6GoDx48dTr1494uPjadSo7Ds62Gy2Cp/WUhPY7aV/NGz+vgQ1KfiwWe02/OqFUKdVNPmZOYW3/aqqTJ7wXpxs2VUnT1leAPbtgAkKGHa73WOWmYhIRTS4NoK4l2cX3GHkJJ14AjS+sjNnnduympJ5DrPs36uKJx03iJhNadsHo743nYynr+seuSUOCAhg6tSpTJ1a9JeETZs20aZNG6zWgitjgoODady4cbnOtJDyq3vuWfSePa7wccs7+tDyjj4k/7GZBdeNMTCZiIiIlMTq5UX7xwezfMSbYAFKqmFYLFjtNtoOv7a644mI1Ej63lT5PLKAUZK0tDQSEhLo27dvkfb77ruP119/ncsvv5x69erx9NNPc95555Xr7AspWfKKzVXekZSIiIhUrmaDepCTms6acR8XHfBPQcPL15ue7z9GaNumhuQTEalp9L2p8tWYAsbGjRsBityBBOCJJ57gyJEjdOjQAZfLRbdu3Zg9W/c3FxERkTNP6/uuJrJne2I/+ol9P64i/1g2vvWCOWvgxcTc1Av/8DpGRxQRESlVjS9gWK1WJkyYwIQJEwxIJVK2W3Z9xqF1OwDY8v737PtxVeGw7m8+RGCjMCxeVrbNWMDOr5aV9jQ1yqGf3+fQwg/BaqXxfe/gF92mcFhu8i72vHEnbkceIV2uIfyaxwDI3PEXiZ88iduRT0DLC4m85fnCafZ/PobU5TNp/fY23E4HO57tizM3E1xOIm4YQ3CH3tX+GkVEjFK7RRRdxt9Fl/F3GR3FozW/qRfNb7gEt9vFiv9NI23bviLDoy7vSNuHrsWZ7yDuk1/YNfs3vPy8uWLWGEKaN2TF/95j99zfATj3kYFEdCvY1wU2CWfTW3PZ+sEPJc633nkxnD/mVlz5DtxuN78Nn0JWUmqRcULPPYtOz96OxWph64c/snvO8sJh4Re0ovc345jZ9i6yD6ZV4hIREal6NaaAMWzYMIYNG2Z0DJEKy0w8VOo1cOtfnUXG7mSs3jb6L36N3d/+jivfUc0Jq5cjI5WDC97h7JdXkpu8i33v3k/M84sLhyd89D8ih4ynVosuxI3qQe0LrsNeJ5L9n47irJGz8fILKPJ8+WkHyNkfd7zBYqXRfW/jE3EWjvTDxD51kQoYIiJSId4hAbS49XK+7/sUgY3/v727DY6quuM4/tsHdpPNJuSBkNgEm6TkiWK1lBooQxKsMKFKdbQyVh0cHB9QOqIt05qhFhimQhEndSpSWqf4ooW2I9hp0Yq1Rag1GTQ0MlKbBAORBEINaTbJLpvN3r19kXbDDuFBp2Tvhu/nVe6cM/f+z525c3Z+956THM3e8ID23DGyzl02m7606m7tXlgrYzCkml1rdfxPjQr7g9p739MqXbIg5nzv1b2k9+pekiQten2j2l9pOO+1Tx9q06tfXyVJmnrnDSpfulCNT/0qpk/Fuvu07+E6Bbt9umn3Uzq+512FA8O7ZX/+oUXqbjry/7gNADDm7PEuALjSJedkqGbXWlVteVxJWWkxbf3//XdMkVBYMk2ZF9k5fjzwtx6Qd3q1bM4JSsovVbivW2YkEm0Pdnwgb9ls2Ww2TZx5kwYO75e/uV72pBQd3XSnWp78qgb+WR/tf/I365T7jdrosc1ul/uqzw3/7UqS2OQXAPAJZX9xqrrePiwzbKjvwxNyZ6bFzCdJmakKdvcpHAjKNCLyHTmh7BnFMiORC371kF6Sr5DPr0BXz3n7nP0iw5WarJ5/HItpd7gnyO5yyt/ZLWNwSP96t1lZ1w7va1KwaLY632xSODD46QYOAHFGgAHE2c5Zy/Xabav10evv6Mtr7h21z/Tlt+rYKw0yw8YYVzf2jP4eOb0Z0WN7cqqMgG+kw1lhhsOboXB/j4Z6TujMsUMq/M4OFTz6otqff1CSFDzRqkhwQJ6CL4x6rY5tKzV50YrLMxAAwLjlSvcq5PNHj4cGzsiV5okeB0/3KWlSmpInp8uZkqScinK5072jnSpG0e2Vajtrucf55M27Tjf/cYNKlyxQd9OHF6xt0OeXO90rm9Oh4rtvVMsv37iUIQKAJRFgAHE22NMvSTr2+7eVOb3wnPbCW+Yo65pC/f1Hvx7r0uLC4c2Q4e+NHkfO9MvhmTjS4aw3XMZAr5ypmXJ4M+UtnyOHJ1Wu7ClyuFNkBPp0cscaXbX4yVGv07Vro+xuj7IXPHC5hgIAGKdCPr9caSnR4wneZIX6AjF96r/3M1VuXqGqLY+rt/m4AqfO/1XF/3z2axVq311/0X6de5u0e+ETaly/XTNq7zq3tokjtbnSUjTYO6DSe+arbef+cb8UFcD4RoABxJEz2S2bffgxzJk1Tf3HumLaP1N9rYq/eYP++uhPpCtg+YgkpZRUqP/wfplGWMGTR+RMmxS9R5KUNGWa/C0HZJqmfI2vyjttrlJKKhTsbJFphGX4fTICfXJ40jR4qk0fbV2u1jU1GjrdoY5twxt+dr/xCwWONil/6aZ4DRMAkMA+PtiqnFnlsjnsSi3I1WBP3znz9KmGD7TnjrXat6xOTo9bHze2XvCck68vU29rR0wQ4snNjJkDJcnuGtnCLuTzywiGYtqNYEiRUFie3EzZXU5Nnlmi04falF42RUW3V2r+9lXKKL9alc+vYBklgIQzbjbxBBLRxOI8fWXTMg35g4oMGar/7lblzbtOrnSvjr78luY++y0FTv1bC3YMf0Wwb1nduN8x3JmaqUnz71dzbaVkt+vqhzbLd/A1Gf09yqy6S3lL1qv9uftlhoeUXnGL3LnD63qza5apeVW1zPCQ8pc+LUkq2zjyFuv9R8qUv3STjDMDat/8oFKKr1fL9+dJkkp/+OaYjxMAkLhCvQNq3f5nLXx5nUwzoobaFyQpZg6fuXqJsq4pUiRs6OD67dEvH6pfWKms6YUKB4KaNKNY76x+UZJUdNtcte2KXT5SueUx/eXeDTGhRsHNs1Vyz40yI6YiYUP1K38qSZq6uFoDnd3q+tv7OvCDbara+m3Z7DYd3voHhf1BNTzx8+g5anau1f5Hnr1iXo4AGD9s5pWwKyA+sd9VPabelo54lxEjvSRft+77cbzLuCir3LtEuV+StHiv1NYf7yqkolTpt/PiXQUAwIrGen63OR2a88zDemvFc2NyvUT63QBYjVV+/1+KRH/WWUICAAAAWIwZNsYsvACAREGAAQAAAAAALI8AAwAAAAAAWB6beGJUqQW58S7hHFasaTRWqdMqdVyKPE+8KxhmlToAANaTSPPqpzHexwdcTon0/CRSraNhE08AAAAAAGB5LCEBAAAAAACWR4ABAAAAAAAsjwADAAAAAABYHgEGAAAAAACwPAIMAAAAAABgeQQYAAAAAADA8ggwAAAAAACA5RFgAAAAAAAAyyPAAAAAAAAAlkeAAQAAAAAALI8AAwAAAAAAWB4BBgAAAAAAsDwCDAAAAAAAYHkEGAAAAAAAwPIIMAAAAAAAgOURYAAAAAAAAMsjwAAAAAAAAJZHgAEAAAAAACyPAAMAAAAAAFgeAQYAAAAAALA8AgwAAAAAAGB5BBgAAAAAAMDy/gOE/27mp0NlSQAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "execution_count": 2, @@ -99,9 +91,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 3, @@ -133,7 +125,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 42953.992531378535\n" + "Sampling overhead: 16.0\n" ] } ], @@ -154,7 +146,8 @@ { "data": { "text/plain": [ - "{0: PauliList(['III', 'IZI', 'IIZ']), 1: PauliList(['ZIII', 'IIII', 'IIII'])}" + "{0: PauliList(['IIII', 'IZII', 'IIIZ']),\n", + " 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, "execution_count": 5, @@ -173,9 +166,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 6, @@ -194,9 +187,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 7, @@ -224,7 +217,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "72 total subexperiments to run on backend.\n" + "16 total subexperiments to run on backend.\n" ] } ], From c746e593bbdcad3fbfeccf8cd49c020b81297dfc Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 16:18:12 -0600 Subject: [PATCH 054/128] clean up tutorial --- .../tutorials/04_automatic_cut_finding.ipynb | 54 +++++++++---------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 4ff016504..4d6764711 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -16,17 +16,17 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 1, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -35,7 +35,7 @@ "import numpy as np\n", "from qiskit.circuit.random import random_circuit\n", "from qiskit.quantum_info import PauliList\n", - "circuit = random_circuit(7, 6, max_operands=2, seed=114)\n", + "circuit = random_circuit(7, 6, max_operands=2, seed=1242)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")" ] @@ -44,22 +44,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Find cut locations, given two QPUs with 4 qubits each. This circuit can be separated by a single wire cut." + "#### Find cut locations, given two QPUs with 4 qubits each. This circuit can be separated in two by making a single wire cut and cutting one `CRZGate`" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 2, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -86,17 +86,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -118,14 +118,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sampling overhead: 16.0\n" + "Sampling overhead: 127.06026169907257\n" ] } ], @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -150,7 +150,7 @@ " 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -161,17 +161,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAD2CAYAAADbCP0bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGPklEQVR4nO3deVhUZf/H8fcMM2yyqSAgouCCuaCIuVUuWZZLJZppaS49aT9TMX3IMpdSU9M2EbMel9LUcstMszITl7JMLcEUFVcUEMQN2deZ3x/k2ATK4sCZGb6v6+K64D7LfA7nzM2Xc+45R6XX6/UIIYQQQlgRtdIBhBBCCCFMTQocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1ZECRwghhBBWRwocIYQQQlgdKXCEEEIIYXWkwBFCCCGE1dEoHaA6m3gAErOUTgE+jrCgg9IplBc5fB7pcclKx7grZz8vHvl8crmWMZfjDExzrJnL9ljTtoD0A8L6SIGjoMQsOJeudApxS3pcMqmnEpSOYXLWdpxZ0/ZY07YIYW7kEpUQQgghrI4UOEIIIYSwOlLgCCGEEMLqSIEjhBBCCKsjg4wtQNzCEVzb9XnRD2o12preOAd2x2fYO9jW9lE2nBBmLHZqN+y8GuMXutyoPfdyHMde8qfpO7/g1PwhhdKVj/QDQpSPnMGxEE7NO9NqZRKByy/iH/YlWeejODf/GaVjCSGqkPQDQpSdFDgWQqWxRVvTC9vaPji36ILHYy+RGbufwqw0paMJIaqI9ANClJ0UOBYo79olbvz2Fahtir6EENWO9ANC3J3Vj8HR6XQsXLiQJUuWEBcXh4eHBwMHDmTWrFnUqFFD6Xhlln5sD1GDnNDrdOjzsgHwDAnDxr5oG27s30zS+plGy+TEH8d35EI8er1c5XmFsCTnw4eTdvgHNK51aLHomNJx7kj6ASHKzuoLnIkTJxIREUG/fv0ICwvjxIkTREREEBUVxc6dO1GrLeMkVo2ADvhN+Bx9Xg439m0g7chO6g6ZbZhes1M/anbqZ/g59fdvSFw9hdrdhysRV1QTR0f5EbgsTukY98z90f/g+eQrnA8fpnSUu5J+QCglPgOSs8HWBpq6gr0FnDS06gInJiaGRYsW0b9/fzZt2mRo9/f3Z/z48axbt47BgwcrmLDs1LYO2Hs3BsChQUtyk88SvzSUBuOWFZs372oCF5eMpfFbP6C2c6zqqFbHp3sb2r4xGNcm9chOucHxT7/n+JJtSscSZWDj6Eph1s1i7YWZqQCotPYAOLfsSu7luCpMVjHSD4iqtu8yfH4aoq7fbnPWQkh9+E9A0ffmyjJOX5TgyJEj9O3bF1dXV1xcXAgJCSEpKQlnZ2eeffZZANauXYter2fChAlGy44aNQpHR0fWrFmjQHLT8H5uBlcjV5B5+g+jdr1Ox/kFz+P19GQc/VoplM561G7diEdWvk7C7ii29niV6Pc30HbyYJoOe0zpaIqKXz6R4xOCyL9+ieMTgjj37iClI5XIvt59ZJ39E31hoVF75umDoLbB7u9iwVJJPyAq09pzMOGAcXEDkJ4Pq8/Cf36BG7nKZCsLiyxwIiMj6dixI7GxsUybNo25c+eSkJBAr169yMjIICgoCIBDhw6hVqtp37690fL29vYEBQVx6NAhBdKbhn3dJri1e5JLa6YatSdtmI2Ngwt1nghVKJl1afHSE1yNPsvhuV9y83QiZzbs4cRnPxA4LkTpaJVCl5tN4hfTOTa6CYefcSB6SC1OhLUj5dsIo/l8Ry6geXg02lp1aR4eTcPX1iuU+O48eo2hIPUycREvkHnmT3KTznL957Vc+mI67o+8gMbJTemI90T6AVFZoq/BB6UMRzufATOiqiZPRVjcJaorV64waNAggoOD2blzJw4ODgAMHToUf39/AEOBc+nSJdzd3bGzsyu2Hh8fH3777Tfy8vKwtbWtsvym5NlvErGTHyT96B6cA7uRceJXru38lGYfHlY6mtWo0/4+Tn8ZadSWuDualmP64uhdi6yk63dY0jJd/N/LpB/dje/IhTj4t6YwK42sc1HkXbmodLQKsavTgKbzf+PSF9M4O/tJCrNuYuvVEM9+k/B88hWl45mE9AOiMqw7X7b5fk2BuAzwc6rcPBVhcQXO/PnzuXHjBitWrDAUNwCurq4EBwcTGRlpKHCysrJKLG6g6CzOrXlMVeAUFBSQnJxc5vnz8z2B0i9g+r2yssR2p2YP0HaLvui1M1I5v2AofuNXonGpXeYMRTnySUi4XK5lrFF+fkGxNoc6bmRfSTVqy0658fe0mlVe4OTnF5CQkFDOZcp2nAGkHviGukNm49YxxNDm6N+6XK939yz3fqyVZ3ugKH/jad/e02uWnKNqt0X6AVFVcnUqdl2qC6jKNP/G42k8V7dy78Xk5eWFRlO+ksXiCpx169bRuXNnAgICSpzu6emJl5cXAI6OjqSkpJQ4X05OjmGeWwoKCggLC2P16tXodDqefvppFi9ebCiGSpOcnIyvr2+Zt6X5omM41G9R5vnv5sr2T8i/kUT8ZxON2ms/PBzPvhPvsFSRU6dO4ft4S5PksGSza/fAR+uidIy7OnXqFAPLcYxB+Y4zbU1v0g5vp1aXwWica1Uk4l2Z4lgz5fvmlrPznyHjxD4K0q7y13/q4TVgCnV6j7nrMua4LdIPCFPQ1vKm1YpLZZ5/0WereW3JuEpMBPHx8dSrV69cy1hUgZOcnExiYiKDBhUf0KjT6Th69Cht2rQxtNWtW5fjx4+Tm5tb7ExOYmIi7u7uRmdv5s6dy+7duzl69Ci2trY89dRTvPbaa0REGI8/MEfeA97Ae8AbSsewOtkpqTh4uBm12f/9860zOdakwbjlnP9gMEeGeeDg24IaTTvi2rY3rh36olKV7b85S9To9Y1KRzAJ6QeEKRRmp5drfl05568qFlXgZGZmApTY0W7ZsoWUlBTD5SmAdu3asWPHDg4ePEjnzp0N7Tk5OURHR9OlSxejdSxfvpx3330XH5+iB9fNmDGDZ555hgULFmBjU/qH/r28vIiPjy/z9oQe9yQ+p8yzV5qAgAB+LEdua7V/4DwyzxtfYkw5eJK63YI4suArQ5vPw0FkxKcoMv4mICCA+A2flWuZ8hxnTs0epOWSs2SeOkhm7H7SY37m7PwBuLbtRaOpW4u99+x9m5criymONWt635jLtoD0A8LYm6dz+CvdjrJcplo15T8EzHm+UvPcujJTHhZV4Pj6+mJjY8PevXuN2i9cuEBoaNGnBf5Z4AwaNIi5c+cSHh5uVOAsW7aMrKwshgwZYmhLTU0lPj7eaPng4GDS09OJi4ujUaNGpebTaDTlOoWmPQ2YQeem1WrLferPGmm1xd8OMUu30efbObSZ/BznvtqLe5smNPtPLw7N+FyBhEUZy7uvynucqWw0ODV7AKdmD+AZEsa1PWuIWzCUjJifcW7Z1WjeJm9+X74sJjjWrOl9Yy7bAtIPCGPDbODVMnzQ+D5XeDigDuZ4gteiChxbW1uGDRvGihUr6Nu3L3369CE+Pp5ly5bh6elJYmKiUYESGBjI2LFj+eijj+jfvz+9e/c23Mm4a9euRjf5S08vOsXm5uZmaLv1/a1povq5duQsu154l+A3BtNy9FNkX0nl8Py1xK7aoXS0KmNfrxkABTdLHs8mhLA+Xb3g6Qaw6cKd53HVwuy2mGVxAxZW4ABERESg1WrZsmULu3btolOnTmzevJlZs2Zx5syZYoOPw8PD8fPzY+nSpXz33Xe4u7sTGhrKrFmzjB7T4OzsDMDNmzcNp8JSU1ONponqKSHyMAmR1eMjt7FTulKr83M4Nr4fjasHuUlnSFw9BZsabjgHPqx0PCFEFVGpYHIr8KkBq8/AjTzj6Q/UgUktwdcMPx5+i8UVOE5OTixZsoQlS5YYtR87dozAwMBiz5aysbEhLCyMsLCwu67Xzc0NX19foqOjadq0KQBRUVE4Ozvj5+dn0m0Qwly5Bvfi+s9fcGntmxRmpaFxrYNziy74jV+BxsVd6XhCiCqkUsGwxvBcQ1h3DhYeL2p/937oXlfZbGVhcQVOSVJTU0lISKBPnz73tJ6RI0fyzjvv0LlzZ7RaLTNmzGDEiBFlGmBcWbIvxnDh4/9DpVKjstHQYNxy7LwaGqaffac/BRlFg12zTh+i6bv7sXFw4fwHg1FptOgLC6j/8idyu3ZRJl4DJuM1YLLSMSrs6o7lXN35GajVNBj9CQ5+gYZpl9bO4FrkCuzrNaPJjO1Gy+UkniImtAVN3/kFp6YdSfnuI27sW49ep8POqxF+4z9DZaNMd1laH3Cn7co88yeJq99AX5CPU7MH8Xl+dkmrF6JUWjUE/+O2Sp4Od57XnFhFgXP06FHAeIBxRUyZMoWrV6/SokULdDodAwYMYP78+SZIWHEaFw+aTP8Omxqu3Dy8naT1b+P3ygrD9EZvfA1A/s0rnJr2MI5+rdAXFtB03j5UajVpf+0ieeNcGk5ap9QmCFElCtKvc2X7J9z37u/kJp/j4v9eJmD2LsN0j8f/j9oPD+Pi/4rf3yZpw9s4t7g9gNr9sZeo06fovh7nFwwj7chOXIN7Vv5GlKC0PqCk7dLl53FpzVQaTf4aGwczvoYgRCWSAucfNBoNERERZnXfG61bHcP3KhstqEs+m3Rj3wZqPvjM3/Pd3q26rDQcTHgnWiHMVebpgzi17IZKo8W+XlMK0q6i1+lQ/X3ZWlvLu8QnhmfGHkDr5oXqH+8ttbbo/lh6vR7QK/pQztL6gJK2KzN2P2r7Gpx//1l0ednUHTIbp/s6VUVcIcyGRT5s89/GjBmDXq+nY8eOSkepNLrcbC6tfeuOz8+5vvcLanW9/bH3rHPRnHytExeXjsOl1SNVFVMIxRSmX0fjVNPws9rBmcKsm6Uul7RxDl5PF78sl/zVPGLGNKUg/Tq2tZQfcFBaH/BP+dcvkR33F/5ha/Ebv5ILH79UBQmFMC9WUeBYO31hAec/GIxXyKtGYwpuyU0+h15XiP0//st0bBjEfe/up/HUrVxcWrm30BbCHNg41aQwM9Xwsy47HRtH17suc/OP74o+MVbCc5u8Bkymxcex2Hs35mrkShOnLZ/S+oB/s3GqhVOzB7FxdMbWwxcbuxoUZlXus4KEMDdS4Jg5vV7PhY9G4tLmcaMHIP7T9Z+/pFbX2/f00eXnGr63cXRFbedY0mJCWJUaAR1Ij/kZfWEBOUln0Li4Gy5P3UnWuWgyju3h9IyepEX/RMKnE8m/nmR4D6lUqqL3kK1yoyrL0gf8W42ADuQknkJfWEBh5k0Ks9KwcTTv56wJYWpWMQbHmqVF/cj1fRvITYnj+r51OPoH4RLck8L064ai5vq+9QTM/MmwTMaJX0laO+Pva/V6fP/zoTLhhahCGudauPcYSewbXUCtpv7/Lebm4e2G98qVH5dybfcqchJOcmr6o/hNWIX3wKl4D5wKQNzCEbj3HI22ljcJK14l88wfoNNh6+mP18Bpim1XaX1ASdtlW7suHj1HEzu1G/qCfOq98J5i+YVQikpfNIpOKGDgbjhnBjdJbugMG+QebnzTdQKppxKUjnFXbgH1CNkbXq5lzOU4A9Mca+ayPda0LSD9gLi7mBsw/Jei7z/vDC1q3n1+cyCXqIQQQghhdaTAEUIIIYTVkTE4CvIxk7G/5pJDVA5z2r+myGIu22NN2wLmlUUIU5ACR0ELOiidQFQH1nacWdP2WNO2CGFu5BKVEEIIIayOFDhCCCGEsDpS4AghhBDC6kiBI4QQQgirIwWOEEIIIayOFDhCCCGEsDpS4AghhBDC6kiBI4QQQgirIwWOEEIIIayOFDhCCCGEsDpS4AghhBDC6kiBI4QQQgirIwWOEEIIIayOFDhCCCGEsDpS4AghhBDC6miUDlCdRQ6fR3pcstIxcPbz4pHPJ9/TOp4K/YmzCWkmSnRvGtVzYeuiHkrHMBsTD0BiltIpivg4woIOSqcwH+bSB4Bp+oF/M6ftsySVsS+qIylwFJQel0zqqQSlY5jE2YQ0jp9NVTqGKEFiFpxLVzqFKIk19QElsfbtE+ZNLlEJIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwurIp6gswEPhY2k86GEAdIWFZF9OJenXYxye+wVZydcVTieEEOap56aZpJ1P4rdX/2fU7lTPgwGHPuH7vtNIOXhSoXSisskZHAuR/Ptx1rcayVf3v8zPY8Op3dKPbkvDlI4lhBBCmCUpcCyELq+A7CupZCVf5/LvJ4hds5M67ZqidXJQOpoQQghhdqpFgaPT6ViwYAH33Xcf9vb2+Pr6EhYWRmZmptLRKsTBsyZ+T3REV1CIvlCndBwhhBDC7FSLMTgTJ04kIiKCfv36ERYWxokTJ4iIiCAqKoqdO3eiVpt/nef1QAuGnFmNSq1G42AHwLFPtlKQnQuAo1ctem+bw7bHXyfnWho2Drb03fkBu158j9STF5WMLoQQZq3n5lnYOjmg0mpIOXCC399Yjl4n/zxaOqsvcGJiYli0aBH9+/dn06ZNhnZ/f3/Gjx/PunXrGDx4sIIJy+bK4dPse+UjbOy0+D31AHU7tyJq/lrD9Kzk6xxfso12M0fwy7gIgsIGcuGHA1LcCCFEKSKHvkN+RjYA3Za/it+TnTi/5VeFU5kHvR7+vAarztxu+z4BfGqAm61yucrC/E9d3MWRI0fo27cvrq6uuLi4EBISQlJSEs7Ozjz77LMArF27Fr1ez4QJE4yWHTVqFI6OjqxZs0aB5OVXmJNX9FyX2Hii31tPenwKHea8aDTPiU9/wC3Al2Yje9OgdweOfLBRobQVt+Ltzvy0tKfSMcTfdLnZJH4xnWOjm3D4GQeih9TiRFg7Ur6NUDpatdfjy6n03joH1b/OQNcK9GfohbU0eKKTQsnMR15aFrYuNYq127oWtRXm5gMYihuVxgYbrQa9Xl91Ic3Y1RwY8QuM/g1+S7ndvv489NoBmy8ol60sLLbAiYyMpGPHjsTGxjJt2jTmzp1LQkICvXr1IiMjg6CgIAAOHTqEWq2mffv2Rsvb29sTFBTEoUOHFEh/76LfX0/jQQ9Tu3UjQ5tep+PQWyvp8PZ/+OPt1YbLV0JU1MX/vcz13auoN+I9Wnx0nIDZu/HoPZaCzFSlo1V7+yYsxqWhF4Hj+xnabOxt6fLReM59/QsXtu1XMJ15uHkmkdqtGhYrAt3bNEZXUEj6+SRD2+NfzeC5Y5+Rn5HNhW2/V3VUs5ORD2P2Q0xqydMLdDDnCGyLr9JY5WKRBc6VK1cYNGgQwcHBREVFMWnSJMaNG0dkZCQXLxZdkrlV4Fy6dAl3d3fs7OyKrcfHx4erV6+Sl5dXlfFNIv18MvE//UHw5OeM2n0eaUNW8nVq3ldfoWTCmqQe+AbPfpNw6xiCnac/jv6tcX9kBHWffVPpaNVedkoqv736P1pPHGD4R6ft1OdR22o5MO0zhdOZh5Ofb8few5UHw8dSu1VDnBt44h/yIG1ee5Yz63eTl5ZlmPfHATNYHzQKGwdbvB5qqWBq8/D1BTiXfufpekAFhMdAXmFVpSofixyDM3/+fG7cuMGKFStwcLj9MWlXV1eCg4OJjIw0FDhZWVklFjdQdBbn1jy2tvd+MbGgoIDk5OQyz5+fX3BPr3fs4630+XYOXp1akLw/Brf76lO/Z3u29ZpM72/ncHbTz2RcTCl1Pfn5BSQkJNxTloL8/Hta3pQK8vMrtD33uj+qQkX2VX6+J6Ct0Otpa3qTdng7tboMRuNcq0LrMM6ST0LC5Xtej7W412Pu4vZDnNmwhy4fjeePt1fTdFgPtvd/i4LMnApludd+oKR1Kikz4SrfPzmV4Nef45HPJ6N1cSTjwmWOfbyV48u/KzZ/YU4eF384SP3H25H0818KJC5SGfuiPHR6WH/GCxU26FHdcT49kJoHG2Ou0bVWdqVm8vLyQqMpX8mi0lvgxcZ69erRuHFj9uzZU2zao48+yrFjxwyFRmBgICkpKVy+XLxTHThwIBs3biQ3N9dQ4GzYsIGIiAiio6Nxd3cnLi6uzLkSEhLw9fUt8/yza/fAR+tS5vlL02vLbI5GfE1C5GEaPdMVv6ceIHLoO6Uul5ifxrRrP93bizeZCfY+97YOisbg1POsQY+Xtld8JTmJcPqtci9m6v1RGSqyr5ovOoZD/RYVer2ME79y/oPB5F1LwMG3BTWadsS1bW9cO/RFpbpzx3cn2RdjOB4q/x3fYopjTuNgx5M/vYeznyd/LdhE9AcbKrQek/QD/2IJ7ymtsyNqWw2519JQ2ajp+slEkn+L4eTKe+iD7lFl7IvysHGuTdCaq2We//LWBSR8+t9KTATx8fHUq1evXMtY3CWq5ORkEhMTadu2bbFpOp2Oo0ePGs7eANStW5erV6+Sm1t8PEpiYiLu7u5GZ29q1qzJuHHjmDNnTqXkryxNhjxKztWbJEQeBuDsxr1oa9hTv3cHhZMJS+bU7EFaLjlL07m/ULv7cPJTL3N2/gDOznlKBmKaiYLsXI59shX0cCT8K6XjWBxbV0d6fDGVpyI/4KnID8hKvkbs6h1Kx1KUSm1TqfNXFYu7RHXr5nwl/fe4ZcsWUlJSjAqcdu3asWPHDg4ePEjnzp0N7Tk5OURHR9OlSxejdfTo0QOAb775ptzZvLy8iI8v+4ir/QPnkXm+7Je07ub0Fzs5/cVOo7bt/ct2FiMgIID4Dfd2zf6R0fs4ddE8bpwYEBBA5K7yj3wz5f6oLBXZV6HHPYkv/xULA5WNBqdmD+DU7AE8Q8K4tmcNcQuGkhHzM84tu5ZrXQEBAfxYjveItTPVMaf/+1LQvdz40xT9wL9ZwnsqM+Eq23q+rnQMI5WxL8qjUA8j/iokvVANd7lEdcu0l4fS+83+lZrJy8ur3MtYXIHj6+uLjY0Ne/fuNWq/cOECoaGhAEYFzqBBg5g7dy7h4eFGBc6yZcvIyspiyJAhJsum0WjKdQpNqzWPX79WW77cJdFoKzbGozJotNoKbY+57I+7qci+0p4G7qHA+Tf7es0AKLhZ+viuYlkquG+slTkdc6boB0papyi/ytgX5fV0Oqw8U/p89jYwuGVNnLQ1Kz9UOVnc0Wdra8uwYcNYsWIFffv2pU+fPsTHx7Ns2TI8PT1JTEw0KnACAwMZO3YsH330Ef3796d3796GOxl37drVIm7yJ4RSYqd0pVbn53BsfD8aVw9yk86QuHoKNjXccA58WOl4QohKMtAfvrkIN/OKBhPfybDG4GQ+/98asbgCByAiIgKtVsuWLVvYtWsXnTp1YvPmzcyaNYszZ84QEBBgNH94eDh+fn4sXbqU7777Dnd3d0JDQ5k1a5ZFPKZBCKW4Bvfi+s9fcGntmxRmpaFxrYNziy74jV+BxsVd6XhCiEpSxwEWd4LQ3+F6btGFqn8XOs81hFEBJS1tHiyywHFycmLJkiUsWbLEqP3YsWMEBgYWK1psbGwICwsjLCysKmOKCnhh+i9KRxD/4DVgMl4DJisdQ5TizIY9nNmwR+kYwso0dYVN3eG7eNh6EZKywU4NHTzgGX9oaX5XpYxYZIFTktTUVBISEujTp889raewsJD8/Hzy8/PR6/Xk5OSgUqnueC+dyuRUz4MuH09AV1CAysaG3ycv48aJ2/fG9unehjaTBqHLL+Ta0XMcmPop9u6udP3fRNQaG1DBwTdXcu3I2SrPLoQQ/1ZanwbgVL8OD344BrVWw8UfDhLzv62GaS4NvQnZs4AfQqZz5fDpO75Oz00zUWs16PILSN4fQ/T7xh+dd/Ktw0MR40CnpzAvn73/9yF5aVk8/Okk7NycAKgd1Ijvn5haLN+/Bb06EP++D7K58yvFpnWY82LRnZRt1ES/t57E3dH4932Q5i89QWFePtnJN/jllUXo8sz3HlzOWni2YdGXpbGaAufo0aOA8QDjili9ejUvvPCC4WcHBwcaNGhQrvvhmEpm0jW+7zsN9Hq8HmxJq/H92fvyAsP0oLCB7HrxPbIuXePRL6ZSs1kD0i9e5ueXw8m+kopr47p0nPcSPw6YUeXZhRDi30rr0wDunzaUw+98yZU/T9Hz65lc+O53MuKLBrS3njiA5P3Hy/Rau198j+wrqSVOazrsMU59sZNzX/1My7EhNHqmGyc+/Z7dL74HgF1tF3p+NaPU4sbe3RWXhnVLnObaxAfXJvX4/smpOHi48ciaN0jcHc2VqNN8/9RU9IU62k4Zgn/fBzm7cW+J6xD3xmoGoJiqwBkxYgR6vd7oS4niBv7+yOff9xqxdXbg+nHjHDdOXsTWpQYqtRqNvS25NzMoyMwxvKl1+YX39LFRIYQwpdL6NCgqDK78eQqAhJ2H8exY9Kk99zZNyE5JJSvpWumvo9fTbVkYj62bbvS8vltuxF40PITT1tWRnGs3jab7P/kAcd+W/iyv1hMHcHTR5hKnZV++QWFuHiobNbaujuReL3ruQcbFFEO/rCsoRK+TPrqyWM0ZnDFjxjBmzBilY5hcrRZ+dJw3ihp13Q3/XdxyfvM+Hls7jYKsXJJ+PUrWpX+88VUq2s0cwbFPtlRxYiGEuLO79WkAKvXt+67k3szErqYzAK1e6c+vExfT7q3hpb7Gnpc+IPd6Oi6N6tL9s0l803Wi0fTk32Lo8eU0mj7/KLqCQo58aHyDxIb9O/PL+EV3fQ1nfy+0NezveJYnLy2LjIsp9P91ERoHW/a+HG403aWhNz4PB/HXoq9L3R5RMVZzBsdaXY+J4/snpxI5Yh4d5r5oNK3jOyPZ1msyXz8YCnqo37OdYVqHOS9y6ee/uLTnSFVHFkKIO7pbnwaGEzwA2Lo4knsjnXqPBHPtyFlyb2SU6TVunS1JO3uJnOvp2NU2flzE/VOf5/DcL9jSPYxjH2+h7ZTbtwtxql8HlY2a9Li736Aw6NVBHFlw5ztH1+3aGoc6bmzqNI7NXSfS/u3/oLIp+pPr4OHGQwvHsXf0AgqzLe9hz5ZCChwzpra9fYItPy2r2BtBr9ORd7Po7sE519IM/+kEvTqQgoxsTn72Q9WFFUKIUpTWpwHcPJWAe1BjAOo9EszlAyeo1dIPrwda0OPLqXh3aUW7mSNwqOOGpoY9ti6OxdahdSp6CLNdbRccPNwMBY+BSkXO3205V2/3nVB09ubcZuNPc9bwKX5LBOf6dej4zkh6fDkVR+9a3P/msH+9BuSmZoBeT35GNja2GtQaG2xdHOm2/FUOTPuM9Avy4NnKZDWXqKxRnXb3EfTqQPSFOlQqFQdnrMTn4SBs3Zw4v3kfUe9t4PGvZlCYl09eaiZ/Lfoa18Z1afXK06QcPEnPTTPJTkktNohPCCGUUFKfBhj1a3/O/YIHP3gZlcaG+B8PkXExhb8Wfs1fC4su5TwUPpbYVTvITkmlyZBH0djbcuLT72+/iErF45tmUJiTh1qj4eCbK0Cvx8HDjeb/9wR/zl7DX+Ff0end/yvKoVHz26Tbtxzxf+oBdgx6+/bqNDZ0X/Ea3z72mtG2fP/kVMP3/X5ZyB+zVgHQftYIoj/8iqSfj9Iw5CF6ffM2NnZaTnz6A4W5+QSFDcS5fh3a/V0QnVm/Wz7iX0ks8mni1uKbrhNIPZWgdAzcAuoRsjf8ntbRot8mjp9NNUmee9W8kRsxm58u93Lmsj/upiL7auBuOJde+nxVoaEzbJAbIBuY0zFnin7g3yp7+9q//QJHwjeRey2t0l6jTrum1Grpz8kVVfd08crYF9WRnMERQghhkQ5OX1Hpr5FyKJaUQ7GV/jrC9GQMjhBCCCGsjhQ4QgghhLA6colKQc5+XkpHAEyTo1E9l9JnqiLmlMUc+BT/kIlizCmLObjX956uoJC0c0lA0X1V1BobxbJU1TqrA/m9mYYMMhbib+Y04PNOZPCh+KfMS9fY2Pb/AHjmzyXUqFtb4URCmA+5RCWEEEIIqyMFjhBCCCGsjhQ4QgghhLA6MshYCBN5KHwsjQcV3cVOV1hI9uVUkn49xuG5X5CVfF3hdEIIUb3IGRwhTCj59+OsbzWSr+5/mZ/HhlO7pR/dloYpHUsIIaodKXCEMCFdXgHZV1LJSr7O5d9PELtmJ3XaNTU8/E8IIUTVkAJHiEri4FkTvyc6oisoRF+oUzqOEEJUKzIGRwgT8nqgBUPOrEalVqNxsAPg2CdbKcjOBaDbsjAu7T3CqTU7AajV0p8uH79Camx8ie3f9phEYW6+MhsjhBAWTAocIUzoyuHT7HvlI2zstPg99QB1O7ciav5aw/SD01fQa8vbXPj+ALk3Mug0bxQHpnzKzTOJJbZLcSOEEBUjBY4QJlSYk0d6XDIA0e+tx9nPiw5zXuS3V/8HQFbydWKWbOP+6UO5GnWGm+eSSNp3FOCO7UIIIcpPxuAIUYmi319P40EPU7t1I0PbyRXbcWvqS+C4EA7N/LzUdiGEEOUnBY4QlSj9fDLxP/1B8OTnbjfq9cSu+omEyMPkXksrvV0IIUS5SYEjRCU79vFWfLoF4dWpxe1GnQ69roTn3N6pXQghRLnIGBwhTGTfhMUltl/5I5aV3gOqOI0QQlRvcgZHCCGEEFZHzuAIk5h4ABKzlE5RxMcRFnRQOsXdndmwhzMb9pS5/V5Y276JHD7P8Ek1JTn7efHI55OVjlEtmcsxbQl9zS3V8XcmBY4wicQsOJeudApREmvbN+lxyaSeSlA6hlCQtR3TVaE6/s7kEpUQQgghrI4UOEIIIYSwOlLgCCGEEMLqSIEjhBBCCKsjg4xFlYtbOIJru/5+FIFajbamN86B3fEZ9g62tX2UDSesykPhY2k86GEAdIWFZF9OJenXYxye+wVZydcVTicqm/Q11ZucwRGKcGremVYrkwhcfhH/sC/JOh/FufnPKB1LWKHk34+zvtVIvrr/ZX4eG07tln50WxqmdCxRRaSvqb6kwBGKUGls0db0wra2D84tuuDx2Etkxu6nMEuewSRMS5dXQPaVVLKSr3P59xPErtlJnXZN0To5KB1NVAHpa6ovKXCE4vKuXeLGb1+B2qboS4hK4uBZE78nOqIrKERfqFM6jqhi0tdUL9ViDI5Op2PhwoUsWbKEuLg4PDw8GDhwILNmzaJGjRpKx6uW0o/tIWqQE3qdDn1eNgCeIWHY2Bftjxv7N5O0fqbRMjnxx/EduRCPXi9XeV5hubweaMGQM6tRqdVoHOwAOPbJVgqycwHotiyMS3uPcGrNTgBqtfSny8ev8G2PSRTm5iuWW5iG9DXVV7UocCZOnEhERAT9+vUjLCyMEydOEBERQVRUFDt37kSttswTWfEZcDkH7G2gqStoLWgzagR0wG/C5+jzcrixbwNpR3ZSd8hsw/SanfpRs1M/w8+pv39D4uop1O4+XIm4woJdOXyafa98hI2dFr+nHqBu51ZEzV9rmH5w+gp6bXmbC98fIPdGBp3mjeLAlE+luLES0tdUX1Zf4MTExLBo0SL69+/Ppk2bDO3+/v6MHz+edevWMXjwYAUTlt+eJFh9Bo7cuN1W0xZCGsCIJlDDAvaq2tYBe+/GADg0aElu8lnil4bSYNyyYvPmXU3g4pKxNH7rB9R2jlUdtdr6s6/qrtNt6zQgcFlc1YS5B4U5eYZnV0W/tx5nPy86zHmR3179HwBZydeJWbKN+6cP5WrUGW6eSyJp31ElIwsTkr6m4iy9D7Cg//mLO3LkCH379sXV1RUXFxdCQkJISkrC2dmZZ599FoC1a9ei1+uZMGGC0bKjRo3C0dGRNWvWKJC84ladgVcPGRc3ADfyYMVpeOlXSLfAfzy9n5vB1cgVZJ7+w6hdr9NxfsHzeD09GUe/Vgqlq55arUwyfDWcXPTPQbMFhw1t971/SOGEFRP9/noaD3qY2q0bGdpOrtiOW1NfAseFcGjm5wqmE5VN+pqys/Q+wGILnMjISDp27EhsbCzTpk1j7ty5JCQk0KtXLzIyMggKCgLg0KFDqNVq2rdvb7S8vb09QUFBHDpk3jvonw5egYjjd58n9ibMjq6SOCZlX7cJbu2e5NKaqUbtSRtmY+PgQp0nQhVKVn1pa3oZvjROtQDQuHjcbnf1UDhhxaSfTyb+pz8Invzc7Ua9nthVP5EQeZjca/LpGmsmfU3ZWXofYJEFzpUrVxg0aBDBwcFERUUxadIkxo0bR2RkJBcvXgQwFDiXLl3C3d0dOzu7Yuvx8fHh6tWr5OXlVWX8Clt7rmzz7UqCpKzKzVIZPPtNIi16B+lH9wCQceJXru38FL/xKxTNJazPsY+34tMtCK9OLW436nTodXrlQokqI31N9WABozWKmz9/Pjdu3GDFihU4ONy+l4WrqyvBwcFERkYaCpysrKwSixsoOotzax5bW9t7zlVQUEBycvI9r6ckGQUq9l2uC9z9miiAHth4PJX+XhmVkqUk+fmegLZM8/q9srLEdqdmD9B2S9EfmIKMVM4vGIrf+JVoXGqXM0s+CQmXy7VM0XIF5V6mquXnF5CQkFDOZcq+bypbRfeN8TrKvp/2TVhcYvuVP2JZ6T3gnnOUd1+YWs7lVMP3SUlJ2OuylQtThcp6TJtrX6MEc+kHKvo78/LyQqMpX8likQXOunXr6Ny5MwEBASVO9/T0xMvLCwBHR0dSUlJKnC8nJ8cwD0Bubq7hTNCVK1fw9vYmNDSU0NCynbJMTk7G19e3vJtTJrZeDQlccrbM87+7eDmvrJxUKVlK0nzRMRzqtyh9xjK6sv0T8m8kEf/ZRKP22g8Px7PvxDssVeTUqVP4Pt6y3K85u3YPfLQu5V6uKp06dYqB5TzGTL1v7kVF980/mct+qsi+MLWaagc+rNMbgPbt23OjmhQ4pjymlehrlGAu/UBFf2fx8fHUq1evXMtYXIGTnJxMYmIigwYNKjZNp9Nx9OhR2rRpY2irW7cux48fJzc3t9iZnMTERNzd3Q1nbwoKCvDy8mLHjh00bNiQv/76i8cffxxPT08GDhxYuRtWCl0577qpy06vpCRVw3vAG3gPeEPpGKIaObNhD2c27FE6hqhi0tdYL4srcDIzMwFQqYpfqtmyZQspKSmGy1MA7dq1Y8eOHRw8eJDOnTsb2nNycoiOjqZLly6Gtho1avD2228bfg4KCuKpp55i3759ZSpwvLy8iI+Pr8hmlcnrsbnEZtpSlstU62aNoeH7oyoty7+FHvckPqfKXu6uAgIC+LEC+2H/wHlknq+cS4ymEhAQQPyGz8q1jDXsm38yl/1UkX1hajmXU9n3xAwADh48iL2nm6J5qoq5HNOmOJ6riqX/zm5dlSkPiytwfH19sbGxYe/evUbtFy5cMFxK+meBM2jQIObOnUt4eLhRgbNs2TKysrIYMmTIHV8rPz+fX375hVdffbVM2TQaTblPoZXH88D0w6XP17omdAnwrLQcJdGeBszgzQOg1WortB+0WvN/O2i15T/GrGHfGK/DPPZTRfaFqWWqb49B9Pb2pkbd8o0hsVTmckyb4niuKtXxd2YePUU52NraMmzYMFasWEHfvn3p06cP8fHxLFu2DE9PTxITE40KnMDAQMaOHctHH31E//796d27t+FOxl27dr3rTf7GjRuHs7Mzw4YNq4ItK11PH/g9Bb5LKDqHU9LnPWrawszgqk4mhBBCmBeLK3AAIiIi0Gq1bNmyhV27dtGpUyc2b97MrFmzOHPmTLHBx+Hh4fj5+bF06VK+++473N3dCQ0NZdasWXd8TMN///tf9u/fz65du0zyCStTUKngrTbg6wRfnoW0f93Q7yFPmNQSfOTxWsLEnAO7GT51IoSofiyxD7DIAsfJyYklS5awZMkSo/Zjx44RGBhYrGixsbEhLCyMsLCwMq1/woQJREZGsmvXLtzd3U2W2xTUKhgZAEMbFd0X56MTRe3vt4Nu3spmE0IIIcyFRRY4JUlNTSUhIYE+ffrc03rGjx/Prl272L17Nx4e5nuXRjsbaPeP2svDXrksFZF9MYYLH/8fKpUalY2GBuOWY+fV0DA9buEIsuL+wsbRBXufpjQYs+QuaxOiOJeG3oTsWcAPIdO5cvi0od2nexvaTBqELr+Qa0fPcWDqpwAEhvajfq/2qFQqTnz2A2c37r3TqoUFOPyMIzUCiu5gX+eJV4weqHn+w+fJTT6HXldInd5jqN19OLmX4zj/wWBUGi36wgLqv/yJPLLBwllNgXP0aNHD8f45/qa8Lly4wKJFi7Czs8Pf39/Q3rlzZ3744Yd7jSj+QePiQZPp32FTw5Wbh7eTtP5t/F4xvoto/dEf49S0o0IJhaVrPXEAyfuLP9skKGwgu158j6xL13j0i6nUbNaAtLgkGg/sxuYuE7Cx09J31wdS4Fg4W4/6NJ2zp8Rp3s++hX3dJujyczk+PpCanZ/D1r0eTeftQ6VWk/bXLpI3zqXhpHVVG1qYlBQ4/9CgQQP0esu6xmiptG51DN+rbLSgtik2T/yyV1Db2uM14A1cg3tWZTxh4dzbNCE7JRV9oa7YtBsnL2LrUoPs5Bto7G3JvZlBYU4+mUnX0djbYuNoR16aBT7rRBjJv36J2Cld0db0xndUhFGfY1+3CQAqjS2o1KhUKlQ2t/8c6rLScPBvXeWZhWlZTYEzZswYxowZo3QMUU663GwurX2LBqM/MWqv98L7aFzcyU+9zKmpD1MjoCMaJzdlQgqL0+qV/vw6cTHt3hpebNr5zft4bO00CrJySfr1KFmXrgFwae8R+u2LQKVW8cfs1VUdWZhY4NJzaFzcub73SxJWhOE/sfg+vfz1u9Ts9DQqTdEjDLLORXPxfy+TdzWeRpO/rurIwsQs8mGbwjroCws4/8FgvEJexcEv0GiaxqVogJHWzRPHxveTm3S6pFWYpefPfUHPTTPpuWkm9XsZP8Xe97H76bNtLj03z6Jh/85G01waejPs4jo8gptUZVyrU++RYK4dOUvujZKfxdbxnZFs6zWZrx8MBT3U79kOl4be1O/Zjk2dxrKp0ziavdALe3fXKk4uTOlWH1LzoYFknYsqNv36z+vIOnuYukNu39zVsWEQ9727n8ZTt3Jx6bgqyyoqh9WcwRGWRa/Xc+Gjkbi0eRy3jiHFphdm3sSmhiu63Gyyz0dj69Gg6kNWUGbiVbY//VbxCSoVbacOYVuvNyjMzaPn1zOJ/+lP8tOLLofcacyIKJ9aLf3weqAFddo1xe2++rg0qsvuF98jOyUVAL1OR97Nojui51xLw66mM6hU5Gdko8srepBnYX4B2hr25Fy9qdRmiHtQmJOJWmuPysaG9JifsfNubDT95uEfubrzUxpP34bq70/d6vJzUWuLHudj4+iK2s6xynML05ICRygiLepHru/bQG5KHNf3rcPRPwiX4J4Upl+nVtfBnPvgOQozb6IvzMczJMzo+rm5c/CsSc+vZ5J9OZUD0z4l51rRc8TsazmTczWNgqyi24nePHMJj+AmXNp75K5jRkT5/LXwa/5aWHR54aHwscSu2kGtFn7YPujE+c37iHpvA49/NYPCvHzyUjP5a9HXFGbnce3oOXp/OweVWs2ln4+QfsEynhItistJOMmFxaOwsXdCpdFSf8wSbh7ebuhf4hYOR1urLqdnPA5Aw1fXkR1/nKS1M/4eD6jH9z8fKroN4t5JgSMU4Rrck+CNdx7I2eTN76swjWlt6jiW3Ovp+Pd7iHYzhvNL6CKg6GyBvbsLDnXcyM/MwbNDM5J+/gu4+5gRUXH7Jiwu1nZh234ubNtfrP3w3C+rIpKoAjUat6X5AuPn2tj/4yxO68+LP8tMW9MLl1bdKz2bqDpS4AhhYrnXi57kHrf1N1qN7280bf/rS+my+BUKsvNIjY0n6/L1UseMCCGEKD8ZZCyECWkc7AzX9D07Nic9zvg/xcu/n+DHZ2ayd/QCNI52XPnztGHMSI8vp+LdpRXtZo7AoY6bAumFEMJ6yBkcYRI+ZjQeT8ksrk18eOD90eRn5qDLL2T/a0vweTgIW7ei8R/3vzWM2oEN0RUUcvidL9HlF5Q4ZuTWgFhTsLZ94+znde8rMQFzyVEdmcsxbS45ysJcslZlDpVe7mxnsWJuwPBfir7/vDO0qKlsHkv3TdcJpJ5KUDrGXbkF1CNkb7jSMYSZyLx0jY1t/w+AZ/5cQo26tRVOJIT5kEtUQgghhLA6UuAIIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQwK48++igjRoxQOkaVOnDgAA888AD29vZ4e3vzxhtvUFhYqHQsiyYFjhBCCKGg+Ph4evToQdOmTfnzzz/55JNPWLJkCVOnTlU6mkXTKB1ACFG5Jh6AxCylUxTxcYQFHZROIarC4sWLWbx4MWfPnsXV1ZXOnTuzadMm/Pz8GDlyJNOmTTPMO3LkSM6cOcOePXsYMWIEkZGRAHz++ecA7N69m27dut319fz8/Bg6dChXr15l7dq12Nra8uabbzJq1CheffVV1qxZg6OjI2+88Qbjxo0zLJeUlMTEiRPZvn07ubm5dOjQgffff5/7778fnU6Hn58fo0ePZsqUKYZlcnNz8fLy4r333mPkyJEALFq0iMWLFxMXF4evry8jRozg9ddfR6Mp/c/sJ598gouLC59++ilqtZoWLVqQmJjIa6+9xvTp06lRo0aZf+/iNilwhLByiVlwLl3pFKI6eeutt/jggw+YN28ejz32GBkZGfzwww9lWnbhwoWcO3cOb29vFi5cCECtWrXKtOyiRYt48803+eOPP1i3bh2hoaF8//33PProoxw6dIiNGzcyfvx4unfvTvPmzdHr9YSEhJCbm8u2bdtwdXVl9uzZ9OjRg9OnT+Pu7s7zzz/P6tWrjQqcLVu2kJOTwzPPPAPAjBkzWLFiBeHh4QQFBXHixAlGjx5NTk4Ob7/9dqm5f/31Vx577DHU6tsXVXr27Mm4ceOIiorioYceKtP2C2NyiUoIIYTJZGZm8u677zJjxgzGjRtHQEAAwcHBZb7c4urqiq2tLQ4ODnh5eeHl5YWtrW2Zlu3WrRv//e9/ady4MVOmTMHZ2RkbGxtD2+uvv46rqyu7du0CYNeuXRw8eJAvv/yShx56iMDAQFatWoW9vT0ff/wxAMOGDePkyZMcOnTI8DqrVq0iJCQEV1dXsrKyePfdd1myZAn9+vXD39+f3r17M3v2bBYtWlSm3ElJSXh5eRm13fo5KSmpTOsQxckZHCGEECYTExNDTk4Ojz32WJW/duvWrQ3fq9VqPDw8aNWqlVFbnTp1SElJMWStXbs2zZs3N8xjZ2dHhw4diImJAeC+++6jffv2rF69mnbt2pGSksKPP/7I1q1bDevIzs7m6aefRqVSGdZTWFhITk4OV65cwcPDo1K3W5RMChwhhBBVRq1Wo9frjdry8/NNsm6tVmv0s0qlKrFNp9OVa73Dhg1j5syZfPDBB3z55Ze4u7sbCrhb69q4cSMBAQHFli3L5TVvb2+Sk5ON2i5fvmyYJipGLlEJIYQwmebNm2Nvb8+OHTtKnF6nTh0uXbpk1BYVFWX0s62tbZV8RLpFixZcu3aN48ePG9pyc3M5cOAALVu2NLQ999xz3Lx5k+3bt7Nq1SqGDBmCjY2NYR329vacO3eOxo0bF/u6Nd/dPPjgg/z0009Ghdf27dtxdHSkTZs2Jtzi6kUKHCGEECbj5OREWFgYM2bMYPHixZw6dYojR47wzjvvAEX3uFm/fj07duwgNjaWiRMncuHCBaN1+Pv78+eff3L27FmuXr1qsjM8/9a9e3fat2/P4MGD+fXXXzl27BjDhg0jJyeHl19+2TBfrVq16NOnD2+++SZRUVEMHz7caHunTJnClClTWLx4MbGxscTExLBu3Tpef/31MuV4+eWXuXnzJqNGjSImJoatW7cyffp0QkND5RNU90AKHCGEECb19ttvM2fOHCIiImjZsiWPPfYYhw8fBuD111+nT58+DBo0iM6dO+Pq6mr4NNItYWFhuLu707p1azw8PPj1118rJadKpeKbb77hvvvuo0+fPrRr147k5GR++ukn3N3djeYdPnw40dHRBAUFERgYaDRt+vTpfPjhhyxbtozWrVvz0EMPsWDBAvz8/MqUw9fXlx07dnDixAnatm3LSy+9xEsvvcScOXNMtanVkkr/74uhwmLE3IDhvxR9/3lnaFFT2TyW7puuE0g9laB0jLtyC6hHyN7wci0zcLf5fEy8oTNseFjpFNYj89I1Nrb9PwCe+XMJNerWVjiREOZDzuAIIYQQwupUi09R6XQ6Fi5cyJIlS4iLi8PDw4OBAwcya9Ysub4phBBmbu7cucydO/eO0zMyMgzf//N+NXeSl5fHypUrGTFiRJnusdOuXbuyBS3BL7/8Qq9eve44/YcffqBz584VXr+4s2pR4EycOJGIiAj69etHWFgYJ06cICIigqioKHbu3Gl090ghhBDmZfTo0QwcONBk68vLy2P58uUMHjy4zDcRrKj777+f6OjoO0738fGp1Nevzqy+wImJiWHRokX079+fTZs2Gdr9/f0ZP34869atY/DgwQomLD+9Hv64CqvP3m7bkQj1ncBZe+flhBDWI+daGrGrfjT8fGjm5zR7sTd12jU1uuGcNahVq1aZH9dgbhwcHGjcuLHSMaoliz51ceTIEfr27YurqysuLi6EhISQlJSEs7Mzzz77LABr165Fr9czYcIEo2VHjRqFo6Mja9asUSB5xaVkw7Cf4eX98FvK7fYvzkHPH+EH8x4ja5E8Ozaj+4rXGXDoE0YkfUWrCU8rHalK/NlXddevo6P8lI5YbZ38/Ec2BL/EXwu/NrTFbf2NH/pOY3v/N8m5lqZgOiHMg8WewYmMjOSJJ56gQYMGTJs2DQcHB1auXEmvXr3IyMggKCgIKLoeq1arad++vdHy9vb2BAUFlel6rblIy4PRv8HFzJKn5+lg+mHQquHRulWbzZppHO1JPR3Puc2/0H7WC0rHqTKtVt5+Bk7Gyd84N+9pmi04jLbm33dWVZd+AzNheqe+2Mnvk5fBHU7SXP79BDuee5te37yN1tG+asNZCI1Gw1NPPVWmJ30Ly2WRe/fKlSsMGjSI4OBgdu7ciYODAwBDhw7F398fwFDgXLp0CXd3d+zs7Iqtx8fHh99++428vLxKvw5rCuvP37m4AdBT1Od9cAy6eYHGos/PmY/EXVEk7iq60+r9055XOE3V0da8/fA/jVPR5QGNi4dRu6haBVm5HJq5quiNfpcbfFw/ep4z63bT7D93Htxandnb2zNt2jSlY4hKZpEFzvz587lx4wYrVqwwFDdQ9BTa4OBgIiMjDQVOVlZWicUNFB3kt+YxRYFTUFBQ7HkiplKoh43nvCm6qnjn6+t64EoOfHP8Kh3dcioli7XKzy9QOkKp8vMLSEgo33XI/HxPwDwGZ+Xn55OQcFnpGBYrcevv5KdnlT6jCo4u24ZTj5ZWNx6nNJmZd/kv8G+5ublEREQwfvz4O/59+KfyvueE6Xl5eZX7jJtFFjjr1q2jc+fOJT7YDMDT09PwqHlHR0fDk2P/LScnxzDPLWPGjOHbb7/l5s2bODs788wzz/Duu++WqQBKTk7G19e3vJtTJlr3erT6NL7M878yfymX1kytlCzWanbtHvhoXZSOcVenTp1iYDmPseaLjuFQv0UlJSqfU6dO4ft4y9JnFCUa5tKGhx0blj6jHrLiLtOkgT+5+sp/ppM5GTlyZKnz5OXl8f333+Pu7l6mvn358uWmiCbuQXx8PPXq1SvXMhZ3ESM5OZnExETatm1bbJpOp+Po0aOGszcAdevW5erVq+Tm5habPzExsdgBPm7cOE6ePElaWhpHjhzhyJEjd73/QlVRlXO8Q3nnF0KYP/Vdzt6aYn4hrInFncG5dfqxpNOuW7ZsISUlxajAadeuHTt27ODgwYNGN1PKyckhOjqaLl26GK2jefPmhu/1ej1qtZrTp0+XKZuXlxfx8WU/y1IeeToY/peObJ2Ku12iumXOf0fxyJwhlZLFWu0fOI/M85VzidFUAgICiN/wWbmWCT3uSbyZXK0MCAjgx0p6j1QHF9bs5vTCLaXPqALbWs7EHjiLqprd5+vMmTOlzpOZmcmqVasYOHBgmW72+tZbb5kimrgHt67KlIfFFTi+vr7Y2Niwd+9eo/YLFy4QGhoKYFTgDBo0iLlz5xIeHm5U4CxbtoysrCyGDCleBMybN4/Zs2eTmZlJ7dq1mTdvXpmyaTSacp9CK4+nbhYNNC5NDQ0MbFELB41l3jdCKVqt+b8dtNryH2Pa04CZFDharbZS3yPWzn1UX85+8h26vFLGi+mh2Yie+NavXzXBzEhSUlKp82i1WkaOHImbm1uZLlHJMWuZLK60t7W1ZdiwYfzxxx/07duXpUuXMn36dDp06EDt2kUPmvtngRMYGMjYsWP5+uuv6d+/P8uXLycsLIz//ve/dO3atcSb/E2ePJmMjAyOHz/O6NGj8fb2rqrNu6vBDcFJU/r5mxeagIP5/622GBpHe2q18KNWCz/UWg0OHm7UauGHs598mkhULfvaLjQf1efuM6nAwcON+4Y/XjWhLJCtrS0vvfSSRXx6VlScxRU4ABEREbz00kscOHCAsLAwDhw4wObNm6lbty6Ojo7FBh+Hh4fz/vvvExMTw9ixY1m3bh2hoaFs27btro9paNasGa1bt2bo0KGVvUll4lMDPuoELn9/IKakQmdoIxguN800KffWjXhq5/s8tfN9HL1q0ew/vXhq5/s8+MHLSkcT1VDwG4MJGPJo8Ql/dwgOdWry2PrpOHi4VWkuS5KdnU1oaCjZ2dlKRxGVSKXX6+9yNwXL4uvri4+PD7///rvJ1vnll18yadIkEhMTTbbOe5WaB9suwtZ4uJwNdjbwYB0Y4ActaiqdznJ903UCqafM++OgbgH1CNkbXq5lBu6Gc+mVk6e8GjrDhoeVTmH59Ho9KQdPcvLzH0n65SiFufk41a9DwOBHaDSgC7Yu1fchwmW5eWtGRgbdu3dn165dODk5lTr/vTxsUyjHai5kpKamkpCQQJ8+pZy+vYubN2+yefNmQkJCcHV15ejRo8yePZvHHzevU71utvB846IvIUT1o1Kp8OzQDM8OzZSOIoTZsshLVCU5evQoYDz+prxUKhVr1qyhYcOGODs7ExISQu/evVm0aJGJUgohhBCiKljNGRxTFDguLi7s3LnTRImEEEKYIzs7O6ZMmVKmuxgLy2U1Z3DGjBmDXq+nY8eOSkcRQghhxrRaLSEhIWi15vEIE1E5rKbAEUIIIcoiKyuLQYMGkZVVhud6CYslBY4QQohqRafTcf78eXQ6ndJRRCWSAkcIIYQQVkcKHCGEEEJYHSlwhBBCVCv29vYsXLgQe3t7paOISmQ1HxMXQgghykKj0dCpUyelY4hKJmdwhBBCVCsZGRk8/PDDZGRkKB1FVCI5gyPE3yzh6eAVyejjWAlBKsicsojqLTMzU+kIopJJgSPE3x75fLLSESrFgg5KJxBCiKonl6iEEEIIYXWkwBFCCFGtODg4sHbtWhwcHJSOIiqRFDhCCCGqFbVajaenJ2q1/Am0ZrJ3hRBCVCuZmZl0795dBhpbOSlwhBBCCGF1pMARQgghhNWRAkcIIYQQVkel1+v1SocQQgghqoperyc9PR1nZ2dUKpXScUQlkQJHCCGEEFZHLlEJIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwupIgSOEEEIIqyMFjhBCCCGsjhQ4QgghhLA6UuAIIYQQwur8Pyr8sT8jbN+qAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -182,17 +182,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -210,21 +210,21 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "16 total subexperiments to run on backend.\n" + "96 total subexperiments to run on backend.\n" ] } ], "source": [ "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", - "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=10_000)\n", + "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=1_000)\n", "print(f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\")" ] } From 8cd851bc82f6473d4489de4d76cf942d7491d481 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Wed, 24 Jan 2024 16:19:23 -0600 Subject: [PATCH 055/128] clean up tutorial and print statement --- circuit_knitting/cutting/cut_finding/circuit_interface.py | 1 - docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 799b6be5d..af188d0a0 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -277,7 +277,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): gate_pos = self.new_gate_ID_map[gate_ID] new_gate_spec = self.new_circuit[gate_pos] - print (new_gate_spec, input_ID) # Gate inputs are numbered starting from 1, so we must decrement the index to qubits assert src_wire_ID == new_gate_spec.qubits[input_ID-1], ( diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 4d6764711..05e1693c2 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -44,7 +44,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Find cut locations, given two QPUs with 4 qubits each. This circuit can be separated in two by making a single wire cut and cutting one `CRZGate`" + "#### Find cut locations, given two QPUs with four qubits each. This circuit can be separated in two by making a single wire cut and cutting one `CRZGate`" ] }, { From 33a48fbb52d1583aba2ef145b11d80b529b36457 Mon Sep 17 00:00:00 2001 From: Edwin Pednault Date: Thu, 25 Jan 2024 10:07:36 -0600 Subject: [PATCH 056/128] Add Ed Pednault as author From 6be5b1d25305375a2d6c03a41d9f502042ba0e9c Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Thu, 25 Jan 2024 14:50:58 -0600 Subject: [PATCH 057/128] Set gamma UP and LB both to gamma until bell pair cutting is supported in CKT --- .../cutting/cut_finding/cutting_actions.py | 86 +++---------------- 1 file changed, 13 insertions(+), 73 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index e849416ce..5af95d18c 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -126,77 +126,6 @@ def __init__(self): lowerBoundGamma is computed from gamma_LB using the DisjointSubcircuitsState.lowerBoundGamma() method. """ - self.gate_dict = { - "cx": (1, 1, 3), - "cy": (1, 1, 3), - "cz": (1, 1, 3), - "ch": (1, 1, 3), - "cp": (1, 1, 3), - "cs": (1, 2, 7), - "csdg": (1, 3, 15), - "csx": (1, 2, 7), - "swap": (1, 2, 7), - "iswap": (1, 2, 7), - "dcx": (1, 2, 7), - "ecr": (1, 1, 3), - "crx": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), - 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), - ) - ), - "cp": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), - 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), - ) - ), - "cp": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), - 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), - ) - ), - "cry": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), - 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), - ) - ), - "crz": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1] / 2)), - 0, - 1 + 2 * np.abs(np.sin(t[1] / 2)), - ) - ), - "rxx": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), - 0, - 1 + 2 * np.abs(np.sin(t[1])), - ) - ), - "ryy": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), - 0, - 1 + 2 * np.abs(np.sin(t[1])), - ) - ), - "rzz": ( - lambda t: ( - 1 + 2 * np.abs(np.sin(t[1])), - 0, - 1 + 2 * np.abs(np.sin(t[1])), - ) - ), - } - def getName(self): """Return the look-up name of ActionCutTwoQubitGate.""" @@ -247,8 +176,19 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def getCostParams(self, gate_spec): - return lookupCostParams(self.gate_dict, gate_spec, (None, None, None)) + @staticmethod + def getCostParams(gate_spec): + """ + Get the cost parameters. + + This method returns a tuple of the form: + (gamma_lower_bound, num_bell_pairs, gamma_upper_bound) + + Since CKT only supports single-cut LO, these tuples will be of + the form (gamma, 0, gamma). + """ + gamma = gate_spec[1].gamma + return (gamma, 0, gamma) def exportCuts(self, circuit_interface, wire_map, gate_spec, args): From bb803fa4de55eafefbf346f9cbb43ac0ff9e7256 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Thu, 25 Jan 2024 14:56:56 -0600 Subject: [PATCH 058/128] Remove redundant CircuitElement class --- .../cutting/cut_finding/circuit_interface.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index af188d0a0..d0a04267a 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -30,17 +30,6 @@ class CircuitElement(NamedTuple): gamma: float | int - - -class CircuitElement(NamedTuple): - """Named tuple for specifying a circuit element.""" - - name: str - params: list - qubits: tuple - gamma: float | int - - class CircuitInterface(ABC): """Base class for accessing and manipulating external circuit From 43840dd85a5c09f220860612b969519b9e174538 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Thu, 25 Jan 2024 15:01:59 -0600 Subject: [PATCH 059/128] Remove unnecessary init --- .../cutting/cut_finding/cutting_actions.py | 25 +------------------ 1 file changed, 1 insertion(+), 24 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 5af95d18c..b5c5f9eeb 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -114,17 +114,7 @@ def nextStatePrimitive(self, state, gate_spec, max_width): class ActionCutTwoQubitGate(DisjointSearchAction): - - """Action class that implements the action of - cutting a two-qubit gate. - - TODO: The list of supported gates needs to be expanded. - """ - - def __init__(self): - """The values in gate_dict are tuples in (gamma_LB, num_bell_pairs, gamma_UB) format. - lowerBoundGamma is computed from gamma_LB using the DisjointSubcircuitsState.lowerBoundGamma() method. - """ + """Action of cutting a two-qubit gate.""" def getName(self): """Return the look-up name of ActionCutTwoQubitGate.""" @@ -203,19 +193,6 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): disjoint_subcircuit_actions.defineAction(ActionCutTwoQubitGate()) -def lookupCostParams(gate_dict, gate_spec, default_value): - gate_name = gate_spec[1].name - params = gate_spec[1].params - if len(params) == 0: - return gate_dict[gate_name] - - else: - if gate_name in gate_dict: - return gate_dict[gate_name]((gate_name, *params)) - - return default_value - - class ActionCutLeftWire(DisjointSearchAction): """Action class that implements the action of From b185c0d1af0fda4e1fd413eea0ecafa9093eb531 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 26 Jan 2024 11:39:57 -0500 Subject: [PATCH 060/128] Add partial type hints for a few modules --- .../cutting/cut_finding/circuit_interface.py | 84 ++++++++----------- .../cut_finding/optimization_settings.py | 19 +++-- .../cut_finding/quantum_device_constraints.py | 2 +- .../cut_finding/search_space_generator.py | 48 +++-------- .../tutorials/LO_circuit_cut_finder.ipynb | 48 ++++++----- 5 files changed, 88 insertions(+), 113 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index dad85daa4..53cfa5615 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -15,23 +15,13 @@ import copy import string -from typing import NamedTuple +from array import array from abc import ABC, abstractmethod +from typing import NamedTuple, Hashable import numpy as np -class CircuitElement(NamedTuple): - """Named tuple for specifying a circuit element.""" - - name: str - params: list - qubits: list - gamma: float | int - - - - class CircuitElement(NamedTuple): """Named tuple for specifying a circuit element.""" @@ -105,8 +95,6 @@ def insertGateCut(self, gate_ID, cut_type): will be added. """ - assert False, "Derived classes must override insertGateCut()" - @abstractmethod def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): """Derived classes must override this function and insert a wire cut @@ -120,8 +108,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): for "LOCCWithAncillas" and "LOCCNoAncillas" will be added. """ - assert False, "Derived classes must override insertWireCut()" - @abstractmethod def defineSubcircuits(self, list_of_list_of_wires): @@ -187,8 +173,16 @@ class SimpleGateList(CircuitInterface): subcircuits (list) is a list of list of wire IDs, where each list of wire IDs defines a subcircuit. """ + circuit: list[CircuitElement | None] + new_circuit: list[CircuitElement] + cut_type: None + qubit_names: NameToIDMap + num_qubits: int + new_gate_ID_map: array[int] + output_wires: array[int] + - def __init__(self, input_circuit, init_qubit_names=[]): + def __init__(self, input_circuit: list, init_qubit_names: list =[]): self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() @@ -216,27 +210,19 @@ def __init__(self, input_circuit, init_qubit_names=[]): # Initialize the list of subcircuits assuming no cutting self.subcircuits = list(list(range(self.num_qubits))) - # Initialize the graph of strongly connected subcircuits - # assuming LO decompositions (i.e., no communication between - # subcircuits) - self.scc_subcircuits = [(s,) for s in range(len(self.subcircuits))] - self.scc_order = np.zeros( - (len(self.scc_subcircuits), len(self.scc_subcircuits)), dtype=bool - ) - - def getNumQubits(self): + def getNumQubits(self) -> int: """Return the number of qubits in the input circuit.""" return self.num_qubits - def getNumWires(self): + def getNumWires(self) -> int: """Return the number of wires/qubits in the cut circuit.""" return self.qubit_names.getNumItems() - def getMultiQubitGates(self): + def getMultiQubitGates(self) -> list[int|CircuitElement]: """Extract the multiqubit gates from the circuit and prepends the index of the gate in the circuits to the gate specification. @@ -257,7 +243,7 @@ def getMultiQubitGates(self): return subcircuit - def insertGateCut(self, gate_ID, cut_type): + def insertGateCut(self, gate_ID: int, cut_type: str) -> None: """Mark the specified gate as being cut. The cut type in this release can only be "LO". """ @@ -265,7 +251,7 @@ def insertGateCut(self, gate_ID, cut_type): gate_pos = self.new_gate_ID_map[gate_ID] self.cut_type[gate_pos] = cut_type - def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): + def insertWireCut(self, gate_ID: int, input_ID: int, src_wire_ID: int, dest_wire_ID: int, cut_type: str) -> None: """Insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. Gate inputs are numbered starting from 1. The @@ -307,14 +293,14 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): self.output_wires[qubit] = dest_wire_ID - def defineSubcircuits(self, list_of_list_of_wires): + def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: """Assign subcircuits where each subcircuit is specified as a list of wire IDs. """ self.subcircuits = list_of_list_of_wires - def getWireNames(self): + def getWireNames(self) -> list[str | tuple[str, str]] : """Return a list of the internal wire names used in the circuit, which consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. @@ -322,7 +308,7 @@ def getWireNames(self): return list(self.qubit_names.getItems()) - def exportCutCircuit(self, name_mapping="default"): + def exportCutCircuit(self, name_mapping: str ="default") -> list[CircuitElement]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -339,7 +325,7 @@ def exportCutCircuit(self, name_mapping="default"): return out - def exportOutputWires(self, name_mapping="default"): + def exportOutputWires(self, name_mapping: str ="default") -> dict: """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. If None is provided as the name_mapping, then the original qubit names are @@ -356,7 +342,7 @@ def exportOutputWires(self, name_mapping="default"): out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] return out - def exportSubcircuitsAsString(self, name_mapping="default"): + def exportSubcircuitsAsString(self, name_mapping: str ="default") -> str: """Return a string that maps qubits/wires in the output circuit to subcircuits per the Circuit Knitting Toolbox convention. This method only works with mappings to numeric qubit/wire names, such @@ -372,7 +358,7 @@ def exportSubcircuitsAsString(self, name_mapping="default"): out[wire_map[wire]] = alphabet[k] return "".join(out) - def makeWireMapping(self, name_mapping): + def makeWireMapping(self, name_mapping: None | str) -> list: """Return a wire-mapping array given an input specification of a name mapping. If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. If "default" @@ -396,7 +382,7 @@ def makeWireMapping(self, name_mapping): return wire_mapping - def defaultWireNameMapping(self): + def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]],int]: """Return a dictionary that maps wire names in self.qubit_names to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric names that are adjacent to the numeric @@ -414,7 +400,7 @@ def defaultWireNameMapping(self): return name_map - def sortOrder(self, name): + def sortOrder(self, name: Hashable) -> int|float: if isinstance(name, tuple): if name[0] == "cut": x = self.sortOrder(name[1]) @@ -424,7 +410,7 @@ def sortOrder(self, name): return self.qubit_names.getID(name) - def replaceWireIDs(self, gate_list, wire_map): + def replaceWireIDs(self, gate_list: list, wire_map: list): """Iterate through a list of gates and replaces wire IDs with the values defined by the wire_map. """ @@ -438,7 +424,11 @@ class NameToIDMap: """Class used to map hashable items (e.g., qubit names) to natural numbers (e.g., qubit IDs)""" - def __init__(self, init_names=[]): + next_ID: int + item_dict: dict + ID_dict: dict + + def __init__(self, init_names: list =[]): """Allow the name dictionary to be initialized with the names in init_names in the order the names appear in order to force a preferred ordering in the assigment of item IDs to those names. @@ -451,7 +441,7 @@ def __init__(self, init_names=[]): for name in init_names: self.getID(name) - def getID(self, item_name): + def getID(self, item_name: Hashable) -> int: """Return the numeric ID associated with the specified hashable item. If the hashable item does not yet appear in the item dictionary, a new item ID is assigned. @@ -466,7 +456,7 @@ def getID(self, item_name): return self.item_dict[item_name] - def defineID(self, item_ID, item_name): + def defineID(self, item_ID: int, item_name: Hashable): """Assign a specific ID number to an item name.""" assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" @@ -477,7 +467,7 @@ def defineID(self, item_ID, item_name): self.item_dict[item_name] = item_ID self.ID_dict[item_ID] = item_name - def getName(self, item_ID): + def getName(self, item_ID: int) -> Hashable|None: """Return the name associated with the specified item ID. None is returned if item_ID does not (yet) exist. """ @@ -487,12 +477,12 @@ def getName(self, item_ID): return self.ID_dict[item_ID] - def getNumItems(self): + def getNumItems(self) -> int: """Return the number of hashable items loaded thus far.""" return len(self.item_dict) - def getArraySizeNeeded(self): + def getArraySizeNeeded(self) -> int: """Return one plus the maximum item ID assigned thus far, or zero if no items have been assigned. The value returned is thus the minimum size needed to construct a Python/Numpy @@ -504,12 +494,12 @@ def getArraySizeNeeded(self): return 1 + max(self.ID_dict.keys()) - def getItems(self): + def getItems(self)-> Hashable: """Return an iterator over the hashable items loaded thus far.""" return self.item_dict.keys() - def getIDs(self): + def getIDs(self) -> Hashable: """Return an iterator over the hashable items loaded thus far.""" return self.ID_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index b7e62d8e3..0208cc397 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -16,6 +16,7 @@ from dataclasses import dataclass + @dataclass class OptimizationSettings: """Class for specifying parameters that control the optimization. @@ -98,34 +99,34 @@ def __post_init__(self): if self.engine_selections is None: self.engine_selections = {"CutOptimization": "BestFirst"} - def getMaxGamma(self): + def getMaxGamma(self) -> int: """Return the max gamma.""" return self.max_gamma - def getMaxBackJumps(self): + def getMaxBackJumps(self) -> int: """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def getRandSeed(self): + def getRandSeed(self) -> int: """Return the random seed.""" return self.rand_seed - def getEngineSelection(self, stage_of_optimization): + def getEngineSelection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" return self.engine_selections[stage_of_optimization] - def setEngineSelection(self, stage_of_optimization, engine_name): + def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: """Return the name of the search engine to employ.""" self.engine_selections[stage_of_optimization] = engine_name - def setGateCutTypes(self): + def setGateCutTypes(self) -> None: """Select which gate-cut types to include in the optimization. The default is to include LO gate cuts. """ self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas - def setWireCutTypes(self): + def setWireCutTypes(self) -> None: """Select which wire-cut types to include in the optimization. The default is to include LO wire cuts. """ @@ -134,7 +135,7 @@ def setWireCutTypes(self): self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas - def getCutSearchGroups(self): + def getCutSearchGroups(self) -> list[str]: """Return a list of search-action groups to include in the optimization for cutting circuits into disjoint subcircuits. """ @@ -157,5 +158,5 @@ def getCutSearchGroups(self): return out @classmethod - def from_dict(cls, options: dict[str, int]): + def from_dict(cls, options: dict[str, int]) -> OptimizationSettings: return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index dca339d34..f40187899 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -44,7 +44,7 @@ def __post_init__(self): "qubits_per_QPU and num_QPUs must be positive definite integers." ) - def getQPUWidth(self): + def getQPUWidth(self) -> int: """Return the number of qubits supported on each individual QPU.""" return self.qubits_per_QPU diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 1e6dd54b9..ae53f7abe 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -16,9 +16,7 @@ from typing import Callable -from .cutting_actions import DisjointSearchAction -@dataclass class ActionNames: """Class that maps action names to individual action objects @@ -32,14 +30,15 @@ class ActionNames: group_dict (dict) maps group names to lists of action objects. """ - # def __init__(self): - # self.action_dict = dict() - # self.group_dict = dict() + action_dict: dict + group_dict: dict + + def __init__(self): + self.action_dict = dict() + self.group_dict = dict() - action_dict: dict[str, DisjointSearchAction] - group_dict: dict[str, DisjointSearchAction] - def copy(self, list_of_groups=None): + def copy(self, list_of_groups: list[str] = None) -> ActionNames: """Return a copy of self that contains only those actions whose group affiliations intersect with list_of_groups. The default is to return a copy containing all actions. @@ -53,7 +52,7 @@ def copy(self, list_of_groups=None): return new_container - def defineAction(self, action_object): + def defineAction(self, action_object) -> None: """Insert the specified action object into the look-up dictionaries using the name of the action and its group names. @@ -77,7 +76,7 @@ def defineAction(self, action_object): self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) - def getAction(self, action_name): + def getAction(self, action_name: str): """Return the action object associated with the specified name. None is returned if there is no associated action object. """ @@ -86,7 +85,7 @@ def getAction(self, action_name): return self.action_dict[action_name] return None - def getGroup(self, group_name): + def getGroup(self, group_name: str) -> (list | None): """Return the list of action objects associated with the group_name. None is returned if there are no associated action objects. """ @@ -95,7 +94,7 @@ def getGroup(self, group_name): return self.group_dict[group_name] return None -def getActionSubset(action_list, action_groups): +def getActionSubset(action_list: list, action_groups: list) -> list : """Return the subset of actions in action_list whose group affiliations intersect with action_groups. """ @@ -180,29 +179,11 @@ class SearchFunctions: is None is likewise equivalent to an infinite min-cost bound. """ - # def __init__( - # self, - # cost_func=None, - # stratum_func=None, - # greedy_bound_func=None, - # next_state_func=None, - # goal_state_func=None, - # upperbound_cost_func=None, - # mincost_bound_func=None, - # ): - # self.cost_func = cost_func - # self.stratum_func = stratum_func - # self.greedy_bound_func = greedy_bound_func - # self.next_state_func = next_state_func - # self.goal_state_func = goal_state_func - # self.upperbound_cost_func = upperbound_cost_func - # self.mincost_bound_func = mincost_bound_func - cost_func: Callable = None, stratum_func: Callable = None, greedy_bound_func: Callable = None, next_state_func: Callable = None, - oal_state_func: Callable = None, + goal_state_func: Callable = None, upperbound_cost_func: Callable = None, mincost_bound_func: Callable = None @@ -223,10 +204,5 @@ class SearchSpaceGenerator: functions by a search engine. """ - - # def __init__(self, functions=None, actions=None): - # self.functions = functions - # self.actions = actions - functions: SearchFunctions = None actions: ActionNames = None diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index b7115b2dd..2db0c85e4 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -85,14 +85,14 @@ "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=(2, 3), gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=(2, 3), gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=(1, 2), gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=(1, 2), gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", "Subcircuits: AABB \n", "\n" ] @@ -207,29 +207,37 @@ "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=(3, 6), gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - "CircuitElement(name='cx', params=[], qubits=(3, 5), gamma=3.0) 1\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "Input wire ID 3 does not match new_circuit wire ID []", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 27\u001b[0m\n\u001b[1;32m 21\u001b[0m interface \u001b[38;5;241m=\u001b[39m SimpleGateList(circuit_ckt_wirecut)\n\u001b[1;32m 23\u001b[0m op \u001b[38;5;241m=\u001b[39m LOCutsOptimizer(interface, \n\u001b[1;32m 24\u001b[0m settings, \n\u001b[1;32m 25\u001b[0m constraint_obj)\n\u001b[0;32m---> 27\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m Gamma =\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m (out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;28;01melse\u001b[39;00m out\u001b[38;5;241m.\u001b[39mupperBoundGamma(),\n\u001b[1;32m 30\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, Min_gamma_reached =\u001b[39m\u001b[38;5;124m'\u001b[39m, op\u001b[38;5;241m.\u001b[39mminimumReached())\n\u001b[1;32m 31\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py:154\u001b[0m, in \u001b[0;36mLOCutsOptimizer.optimize\u001b[0;34m(self, circuit_interface, optimization_settings, device_constraints)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m min_cost \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbest_result \u001b[38;5;241m=\u001b[39m min_cost[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m--> 154\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbest_result\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 156\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbest_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py:447\u001b[0m, in \u001b[0;36mDisjointSubcircuitsState.exportCuts\u001b[0;34m(self, circuit_interface)\u001b[0m\n\u001b[1;32m 444\u001b[0m wire_map \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_wires)\n\u001b[1;32m 446\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m action, gate_spec, cut_args \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mactions:\n\u001b[0;32m--> 447\u001b[0m \u001b[43maction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexportCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgate_spec\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcut_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 449\u001b[0m root_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgetSubCircuitIndices()\n\u001b[1;32m 450\u001b[0m wires_to_roots \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgetWireRootMapping()\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cutting_actions.py:367\u001b[0m, in \u001b[0;36mActionCutLeftWire.exportCuts\u001b[0;34m(self, circuit_interface, wire_map, gate_spec, cut_args)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexportCuts\u001b[39m(\u001b[38;5;28mself\u001b[39m, circuit_interface, wire_map, gate_spec, cut_args):\n\u001b[1;32m 363\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Insert an LO wire cut into the input circuit for the specified\u001b[39;00m\n\u001b[1;32m 364\u001b[0m \u001b[38;5;124;03m gate and cut arguments.\u001b[39;00m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 367\u001b[0m \u001b[43minsertAllLOWireCuts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit_interface\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgate_spec\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcut_args\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cutting_actions.py:382\u001b[0m, in \u001b[0;36minsertAllLOWireCuts\u001b[0;34m(circuit_interface, wire_map, gate_spec, cut_args)\u001b[0m\n\u001b[1;32m 380\u001b[0m gate_ID \u001b[38;5;241m=\u001b[39m gate_spec[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 381\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m input_ID, wire_ID, new_wire_ID \u001b[38;5;129;01min\u001b[39;00m cut_args:\n\u001b[0;32m--> 382\u001b[0m \u001b[43mcircuit_interface\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minsertWireCut\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 383\u001b[0m \u001b[43m \u001b[49m\u001b[43mgate_ID\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minput_ID\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m[\u001b[49m\u001b[43mwire_ID\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwire_map\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnew_wire_ID\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLO\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 384\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/circuit_interface.py:266\u001b[0m, in \u001b[0;36mSimpleGateList.insertWireCut\u001b[0;34m(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type)\u001b[0m\n\u001b[1;32m 263\u001b[0m new_gate_spec \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnew_circuit[gate_pos]\n\u001b[1;32m 264\u001b[0m \u001b[38;5;28mprint\u001b[39m (new_gate_spec, input_ID)\n\u001b[0;32m--> 266\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m src_wire_ID \u001b[38;5;241m==\u001b[39m new_gate_spec[input_ID], (\n\u001b[1;32m 267\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput wire ID \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msrc_wire_ID\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m does not match \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnew_circuit wire ID \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnew_gate_spec[input_ID]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 269\u001b[0m )\n\u001b[1;32m 271\u001b[0m \u001b[38;5;66;03m# If the new wire does not yet exist, then define it\u001b[39;00m\n\u001b[1;32m 272\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqubit_names\u001b[38;5;241m.\u001b[39mgetName(dest_wire_ID) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "\u001b[0;31mAssertionError\u001b[0m: Input wire ID 3 does not match new_circuit wire ID []" + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABABB \n", + "\n", + "\n", + "\n", + "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, CircuitElement(name='cx', params=[], qubits=[3, 4], gamma=3.0)]}, 'Input wire': 1}]\n", + "Subcircuits: AAAABBBB \n", + "\n", + "\n", + "\n", + "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 16.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "Subcircuits: AABABCBCC \n", + "\n", + "\n", + "\n", + "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + " Gamma = 243.0 , Min_gamma_reached = True\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, CircuitElement(name='cx', params=[], qubits=[1, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", + "Subcircuits: ABCDDEF \n", + "\n" ] } ], From 195308211a3f7b4a5ee5d7b2ffa1b9f36259dbb5 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 26 Jan 2024 20:52:24 -0500 Subject: [PATCH 061/128] Remove unused code and add roundtrip tests. --- .../cut_finding/disjoint_subcircuits_state.py | 95 +++++++------------ .../tutorials/LO_circuit_cut_finder.ipynb | 16 ++-- .../cut_finding/test_cut_finder_roundtrip.py | 20 +++- 3 files changed, 59 insertions(+), 72 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 47f114491..c430bb0fd 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -117,6 +117,7 @@ def __init__(self, num_qubits=None, max_wire_cuts=None): self.no_merge = None self.actions = None self.level = None + self.cut_actions_list = None else: max_wires = num_qubits + max_wire_cuts @@ -133,6 +134,7 @@ def __init__(self, num_qubits=None, max_wire_cuts=None): self.no_merge = list() self.actions = list() + self.cut_actions_list = list() self.level = 0 def __copy__(self): @@ -150,6 +152,7 @@ def __copy__(self): new_state.no_merge = self.no_merge.copy() new_state.actions = self.actions.copy() + new_state.cut_actions_list = self.cut_actions_list.copy() new_state.level = None return new_state @@ -158,42 +161,46 @@ def copy(self): """Make shallow copy.""" return copy.copy(self) - - def print(self, simple=False): - """Print the various properties of a DisjointSubcircuitState.""" + + def CutActionsList(self): + """Create a formatted list containing the actions carried out on a DisjointSubcircuitState + along with the locations of these actions which are specified in terms of + gate and wire references.""" cut_actions = PrintActionListWithNames(self.actions) - cut_actions_sublist = [] # Output formatting for LO gate and wire cuts. for i in range(len(cut_actions)): if (cut_actions[i][0] == "CutLeftWire") or ( - cut_actions[i][0] == ("CutRightWire") + cut_actions[i][0] == "CutRightWire" ): - cut_actions_sublist.append( + self.cut_actions_list.append( { "Cut action": cut_actions[i][0], - "Cut location": { + "Cut location:": { "Gate": [cut_actions[i][1][0], cut_actions[i][1][1]] }, "Input wire": cut_actions[i][2][0][0], } ) elif cut_actions[i][0] == "CutTwoQubitGate": - cut_actions_sublist.append( + self.cut_actions_list.append( { "Cut action": cut_actions[i][0], "Cut Gate": [cut_actions[i][1][0], cut_actions[i][1][1]], } ) - if not cut_actions_sublist: - cut_actions_sublist = cut_actions - - if simple: # print only a subset of properties. - # print(self.lowerBoundGamma(), self.gamma_UB, self.getMaxWidth()) - # print('Actions:', PrintActionListWithNames(self.actions)) - # print(self.no_merge) - print(cut_actions_sublist) + if not self.cut_actions_list: + self.cut_actions_list = cut_actions + + return self.cut_actions_list + + def print(self, simple=False): # pragma: no cover + """Print the various properties of a DisjointSubcircuitState.""" + + cut_actions_list = self.CutActionsList() + if simple: + print(cut_actions_list) else: print("wiremap", self.wiremap) print("num_wires", self.num_wires) @@ -329,28 +336,13 @@ def checkDoNotMergeRoots(self, root_1, root_2): ) for clause in self.no_merge: - if isinstance(clause[0], tuple) or isinstance(clause[0], list): - constraint = False - for pair in clause: - r1 = self.findWireRoot(pair[0]) - r2 = self.findWireRoot(pair[1]) - if r1 != r2 and not ( - (r1 == root_1 and r2 == root_2) - or (r1 == root_2 and r2 == root_1) - ): - constraint = True - break - if not constraint: - return True - - else: - r1 = self.findWireRoot(clause[0]) - r2 = self.findWireRoot(clause[1]) - - assert r1 != r2, "Do-Not-Merge clauses must not be identical" - - if (r1 == root_1 and r2 == root_2) or (r1 == root_2 and r2 == root_1): - return True + r1 = self.findWireRoot(clause[0]) + r2 = self.findWireRoot(clause[1]) + + assert r1 != r2, "Do-Not-Merge clauses must not be identical" + + if (r1 == root_1 and r2 == root_2) or (r1 == root_2 and r2 == root_1): + return True return False @@ -358,22 +350,10 @@ def verifyMergeConstraints(self): """Return True if all merge constraints are satisfied.""" for clause in self.no_merge: - if isinstance(clause[0], tuple) or isinstance(clause[0], list): - constraint = False - for pair in clause: - r1 = self.findWireRoot(pair[0]) - r2 = self.findWireRoot(pair[1]) - if r1 != r2: - constraint = True - break - if not constraint: - return False - - else: - r1 = self.findWireRoot(clause[0]) - r2 = self.findWireRoot(clause[1]) - if r1 == r2: - return False + r1 = self.findWireRoot(clause[0]) + r2 = self.findWireRoot(clause[1]) + if r1 == r2: + return False return True @@ -388,13 +368,6 @@ def assertDoNotMergeRoots(self, wire_1, wire_2): self.no_merge.append((wire_1, wire_2)) - def assertDoNotMergeRootPairs(self, pair_list): - """Add a constraint that at least one of the pairs of - subcircuits defined in pair_list should not be merged. - """ - - self.no_merge.append(pair_list) - def mergeRoots(self, root_1, root_2): """Merge the subcircuits associated with root wire IDs root_1 and root_2, and updates the statistics (i.e., width) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 2db0c85e4..e336f7e39 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -78,21 +78,21 @@ "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", + "None\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", "Subcircuits: AABB \n", "\n" ] @@ -200,7 +200,7 @@ "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", + "None\n", "Subcircuits: AAAAAAA \n", "\n", "\n", @@ -214,28 +214,28 @@ "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [10, CircuitElement(name='cx', params=[], qubits=[3, 4], gamma=3.0)]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [10, CircuitElement(name='cx', params=[], qubits=[3, 4], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, CircuitElement(name='cx', params=[], qubits=[1, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}]\n", "Subcircuits: ABCDDEF \n", "\n" ] diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 9298a738b..8288c1520 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -55,11 +55,9 @@ def test_no_cuts(gate_cut_test_setup): output = optimization_pass.optimize(interface, settings, constraint_obj) - # assert optimization_pass.best_result == None #no cutting. - print(optimization_pass.best_result) - assert PrintActionListWithNames(output.actions) == [] + assert PrintActionListWithNames(output.actions) == [] #no cutting. assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" @@ -77,6 +75,12 @@ def test_GateCuts(gate_cut_test_setup): output = optimization_pass.optimize() + cut_actions_list = output.CutActionsList() + + assert cut_actions_list == [ + {"Cut action": "CutTwoQubitGate", "Cut Gate": [9, ["cx", 1, 2]]} + ] + best_result = optimization_pass.getResults() assert output.upperBoundGamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. @@ -104,6 +108,16 @@ def test_WireCuts(wire_cut_test_setup): output = optimization_pass.optimize() + cut_actions_list = output.CutActionsList() + + assert cut_actions_list == [ + { + "Cut action": "CutLeftWire", + "Cut location:": {"Gate": [10, ["cx", 3, 4]]}, + "Input wire": 1, + } + ] + best_result = optimization_pass.getResults() assert output.upperBoundGamma() == best_result.gamma_UB == 4 # One LO wire cut. From 119ce294c87788590469ad6f01eb7f333b1e3f02 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 29 Jan 2024 16:12:26 -0500 Subject: [PATCH 062/128] Update BFS test and remove unused code. --- .../cutting/cut_finding/circuit_interface.py | 2 +- .../cutting/cut_finding/cutting_actions.py | 10 +++---- .../cut_finding/optimization_settings.py | 29 +++++-------------- .../cut_finding/quantum_device_constraints.py | 2 +- .../cut_finding/search_space_generator.py | 4 +-- .../tutorials/LO_circuit_cut_finder.ipynb | 2 +- .../cut_finding/test_best_first_search.py | 2 ++ .../cut_finding/test_cutting_actions.py | 2 +- 8 files changed, 21 insertions(+), 32 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 040dc848b..1e442f2b9 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -182,7 +182,7 @@ class SimpleGateList(CircuitInterface): output_wires: array[int] - def __init__(self, input_circuit: list, init_qubit_names: list =[]): + def __init__(self, input_circuit: list[NamedTuple], init_qubit_names: list =[]): self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index b5c5f9eeb..f34825414 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -69,7 +69,7 @@ def getName(self): def getGroupNames(self): """Return the group name of ActionApplyGate.""" - return [None, "TwoQubitGates", "MultiqubitGates"] + return [None, "TwoQubitGates"] def nextStatePrimitive(self, state, gate_spec, max_width): """Return the new state that results from applying @@ -77,10 +77,10 @@ def nextStatePrimitive(self, state, gate_spec, max_width): specification: gate_spec. """ gate = gate_spec[1] # extract the gate from gate specification. - if len(gate.qubits) > 2: - # The function multiqubitNextState handles - # gates that act on 3 or more qubits. - return self.multiqubitNextState(state, gate_spec, max_width) + # if len(gate.qubits) > 2: + # # The function multiqubitNextState handles + # # gates that act on 3 or more qubits. + # return self.multiqubitNextState(state, gate_spec, max_width) r1 = state.findQubitRoot( gate.qubits[0] diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 0208cc397..0e39aa4e3 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -25,30 +25,18 @@ class OptimizationSettings: max_gamma (int) is a constraint on the maximum value of gamma that a solution to the optimization is allowed to have to be considered feasible. - All other potential solutions are discarded. engine_selections (dict) is a dictionary that defines the selections of search engines for the various stages of optimization. In this release - only "BestFirst" or Dijkstra's best-first search is supported. In future - relesases the choices "Greedy" and "BeamSearch", which correspond respectively - to bounded-greedy and best-first search and beam search will be added. + only "BestFirst" or Dijkstra's best-first search is supported. max_backjumps (int) is a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. This constraint - does not apply to beam search. - - beam_width (int) is the beam width used in the optimization. Only the B - best partial solutions are maintained at each level in the search, where B - is the beam width. This constraint only applies to beam search algorithms. - - greedy_multiplier (float) is a multiplier used to compute cost bounds - for bounded-greedy best-first search. + operations that can be performed by the search algorithm. rand_seed (int) is a seed used to provide a repeatable initialization - of the pesudorandom number generators used by the optimization, which - is useful for debugging purposes. If None is used as the random seed, - then a seed is obtained using an operating-system call to achieve an - unrepeatable randomized initialization, which is useful in practice. + of the pesudorandom number generators used by the optimization. + If None is used as the random seed, then a seed is obtained using an + operating-system call to achieve an unrepeatable randomized initialization. gate_cut_LO (bool) is a flag that indicates that LO gate cuts should be included in the optimization. @@ -72,7 +60,6 @@ class OptimizationSettings: ValueError: max_gamma must be a positive definite integer. ValueError: max_backjumps must be a positive semi-definite integer. - ValueError: beam_width must be a positive definite integer. """ max_gamma: int = 1024 @@ -116,19 +103,19 @@ def getEngineSelection(self, stage_of_optimization: str) -> str: return self.engine_selections[stage_of_optimization] def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: - """Return the name of the search engine to employ.""" + """Set the name of the search engine to employ.""" self.engine_selections[stage_of_optimization] = engine_name def setGateCutTypes(self) -> None: """Select which gate-cut types to include in the optimization. - The default is to include LO gate cuts. + The default is to only include LO gate cuts. """ self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas def setWireCutTypes(self) -> None: """Select which wire-cut types to include in the optimization. - The default is to include LO wire cuts. + The default is to only include LO wire cuts. """ self.wire_cut_LO = self.LO diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index f40187899..7784075f2 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -49,5 +49,5 @@ def getQPUWidth(self) -> int: return self.qubits_per_QPU @classmethod - def from_dict(cls, options: dict[str, int]): + def from_dict(cls, options: dict[str, int]) -> DeviceConstraints: return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index ae53f7abe..4591801fc 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -71,7 +71,7 @@ def defineAction(self, action_object) -> None: if name not in self.group_dict: self.group_dict[name] = list() self.group_dict[name].append(action_object) - else: + else: #pragma: no cover if group_name not in self.group_dict: self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) @@ -102,7 +102,7 @@ def getActionSubset(action_list: list, action_groups: list) -> list : if action_groups is None: return action_list - if len(action_groups) <= 0: + if len(action_groups) <= 0: #pragma: no cover action_groups = [None] groups = set(action_groups) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index e336f7e39..29c57e6ee 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 6b9fd598c..6037691f2 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -55,6 +55,7 @@ def test_BestFirstSearch(testCircuit): out, _ = op.optimizationPass() + assert op.search_engine.getStats(penultimate = True) is not None assert op.search_engine.getStats() is not None assert op.getUpperBoundCost() == (27, inf) assert op.minimumReached() == False @@ -68,6 +69,7 @@ def test_BestFirstSearch(testCircuit): out, _ = op.optimizationPass() + assert.getStats(penultimate = True) is not None assert op.search_engine.getStats() is not None assert op.getUpperBoundCost() == (27, inf) assert op.minimumReached() == True diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index c1563f8c7..39fbf3f62 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -37,7 +37,7 @@ def test_ActionApplyGate(testCircuit): _, state, two_qubit_gate = testCircuit apply_gate = ActionApplyGate() assert apply_gate.getName() == None - assert apply_gate.getGroupNames() == [None, "TwoQubitGates", "MultiqubitGates"] + assert apply_gate.getGroupNames() == [None, "TwoQubitGates"] updated_state = apply_gate.nextStatePrimitive(state, two_qubit_gate, 2) actions_list = [] From ff58250728aad95817a8818c1fa18b8b9afe647f Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 30 Jan 2024 08:52:25 -0500 Subject: [PATCH 063/128] Fix black errors, changes to tests pending --- .../cutting/cut_finding/circuit_interface.py | 3 +- .../cutting/cut_finding/cut_optimization.py | 3 +- .../cutting/cut_finding/cutting_actions.py | 1 - .../cutting/cut_finding/lo_cuts_optimizer.py | 2 +- .../cut_finding/optimization_settings.py | 18 +-- .../cut_finding/quantum_device_constraints.py | 4 +- .../cut_finding/search_space_generator.py | 123 ++++++++---------- .../tutorials/LO_circuit_cut_finder.ipynb | 2 +- .../cut_finding/test_best_first_search.py | 2 +- 9 files changed, 67 insertions(+), 91 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 1e442f2b9..e7866531a 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -182,7 +182,7 @@ class SimpleGateList(CircuitInterface): output_wires: array[int] - def __init__(self, input_circuit: list[NamedTuple], init_qubit_names: list =[]): + def __init__(self, input_circuit: list[CircuitElement], init_qubit_names: list =[]): self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() @@ -262,7 +262,6 @@ def insertWireCut(self, gate_ID: int, input_ID: int, src_wire_ID: int, dest_wire """ gate_pos = self.new_gate_ID_map[gate_ID] - new_gate = self.new_circuit[gate_pos] new_gate_spec = self.new_circuit[gate_pos] # Gate inputs are numbered starting from 1, so we must decrement the index to qubits diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index a6e8491f1..93a34d72a 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -35,7 +35,6 @@ def __init__(self): self.search_actions = None self.max_gamma = None self.qpu_width = None - self.greedy_multiplier = None def CutOptimizationCostFunc(state, func_args): @@ -75,7 +74,7 @@ def CutOptimizationNextStateFunc(state, func_args): if len(gate_spec[1].qubits) == 2: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: - action_list = func_args.search_actions.getGroup("MultiqubitGates") + raise ValueError("At present, only the cutting of two qubit gates is supported.") action_list = getActionSubset(action_list, gate_spec[2]) # Apply the search actions to generate a list of next states diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index f34825414..cbd397523 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -11,7 +11,6 @@ """Classes needed to implement the actions involved in circuit cutting.""" -import numpy as np from abc import ABC, abstractmethod from .search_space_generator import ActionNames diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index cfa3c80ed..db6bfcf16 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -97,7 +97,7 @@ def optimize( Input Arguments: circuit_interface (CircuitInterface) defines the circuit to be - cut. This object is then updated with the optimized cuts that + cut. This object is then updated with the optimized cuts that were identified. optimization_settings (OptimizationSettings) defines the settings diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 0e39aa4e3..3037c4955 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -23,34 +23,34 @@ class OptimizationSettings: Member Variables: - max_gamma (int) is a constraint on the maximum value of gamma that a + max_gamma: a constraint on the maximum value of gamma that a solution to the optimization is allowed to have to be considered feasible. - engine_selections (dict) is a dictionary that defines the selections + engine_selections: a dictionary that defines the selections of search engines for the various stages of optimization. In this release only "BestFirst" or Dijkstra's best-first search is supported. - max_backjumps (int) is a constraint on the maximum number of backjump + max_backjumps: a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - rand_seed (int) is a seed used to provide a repeatable initialization + rand_seed: a seed used to provide a repeatable initialization of the pesudorandom number generators used by the optimization. If None is used as the random seed, then a seed is obtained using an operating-system call to achieve an unrepeatable randomized initialization. - gate_cut_LO (bool) is a flag that indicates that LO gate cuts should be + gate_cut_LO: a flag that indicates that LO gate cuts should be included in the optimization. - gate_cut_LOCC_with_ancillas (bool) is a flag that indicates that + gate_cut_LOCC_with_ancillas: a flag that indicates that LOCC gate cuts with ancillas should be included in the optimization. - wire_cut_LO (bool) is a flag that indicates that LO wire cuts should be + wire_cut_LO: a flag that indicates that LO wire cuts should be included in the optimization. - wire_cut_LOCC_with_ancillas (bool) is a flag that indicates that + wire_cut_LOCC_with_ancillas: a flag that indicates that LOCC wire cuts with ancillas should be included in the optimization. - wire_cut_LOCC_no_ancillas (bool) is a flag that indicates that + wire_cut_LOCC_no_ancillas: a flag that indicates that LOCC wire cuts with no ancillas should be included in the optimization. NOTE: The current release only supports LO gate and wire cuts. LOCC diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 7784075f2..93274d938 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -24,10 +24,10 @@ class DeviceConstraints: Member Variables: - qubits_per_QPU (int) : The number of qubits that are available on the + qubits_per_QPU: The number of qubits that are available on the individual QPUs that make up the quantum processor. - num_QPUs (int) : The number of QPUs in the target quantum processor. + num_QPUs: The number of QPUs in the target quantum processor. Raises: diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 4591801fc..d7c3dc6a1 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -14,7 +14,15 @@ from dataclasses import dataclass -from typing import Callable +from typing import TYPE_CHECKING +if TYPE_CHECKING: + from cut_optimization import CutOptimizationFuncArgs + from .cutting_actions import DisjointSearchAction + +from typing import Callable, Iterable + +from .disjoint_subcircuits_state import DisjointSubcircuitsState + class ActionNames: @@ -25,13 +33,13 @@ class ActionNames: Member Variables: - action_dict (dict) maps action names to action objects. + action_dict: maps action names to action objects. - group_dict (dict) maps group names to lists of action objects. + group_dict: maps group names to lists of action objects. """ - action_dict: dict - group_dict: dict + action_dict: dict[str, DisjointSearchAction] + group_dict: dict[str,list[DisjointSearchAction]] def __init__(self): self.action_dict = dict() @@ -52,7 +60,7 @@ def copy(self, list_of_groups: list[str] = None) -> ActionNames: return new_container - def defineAction(self, action_object) -> None: + def defineAction(self, action_object: DisjointSearchAction) -> None: """Insert the specified action object into the look-up dictionaries using the name of the action and its group names. @@ -76,7 +84,7 @@ def defineAction(self, action_object) -> None: self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) - def getAction(self, action_name: str): + def getAction(self, action_name: str) -> (DisjointSearchAction | None): """Return the action object associated with the specified name. None is returned if there is no associated action object. """ @@ -94,7 +102,7 @@ def getGroup(self, group_name: str) -> (list | None): return self.group_dict[group_name] return None -def getActionSubset(action_list: list, action_groups: list) -> list : +def getActionSubset(action_list: list, action_groups: Iterable) -> list : """Return the subset of actions in action_list whose group affiliations intersect with action_groups. """ @@ -102,7 +110,7 @@ def getActionSubset(action_list: list, action_groups: list) -> list : if action_groups is None: return action_list - if len(action_groups) <= 0: #pragma: no cover + if len(action_groups) == 0: #pragma: no cover action_groups = [None] groups = set(action_groups) @@ -114,91 +122,62 @@ def getActionSubset(action_list: list, action_groups: list) -> list : @dataclass class SearchFunctions: - """Container class for holding functions needed to generate and explore + """Data class for holding functions needed to generate and explore a search space. In addition to the required input arguments, the function signatures are assumed to also allow additional input arguments that are - needed to perform the corresponding computations. In particular, an - ActionNames object should be incorporated into the additional input - arguments in order to generate next-states. For simplicity, all search - algorithms will assume that all search-space functions employ the same set - of additional arguments. + needed to perform the corresponding computations. Member Variables: - cost_func (lambda state, *args) is a function that computes cost values - from search states. The cost returned can be numeric or tuples of - numerics. In the latter case, lexicographical comparisons are performed - per Python semantics. - - stratum_func (lambda state, *args) is a function that computes stratum - identifiers from search states, which are then used to stratify the search - space when stratified beam search is employed. The stratum_func can be - None, in which case each level of the search has only one stratum, which - is then labeled None. - - greedy_bound_func (lambda current_best_cost, *args) can be either - None or a function that computes upper bounds to costs that are used during - the greedy depth-first phases of search. If None is provided, the upper - bound is taken to be infinity. In greedy search, the search proceeds in a - greedy best-first, depth-first fashion until either a goal state is reached, - a deadend is reached, or the cost bound provided by the greedy_bound_func is - exceeded. In the latter two cases, the search backjumps to the lowest cost - state in the search frontier and the search proceeds from there. The - inputs passed to the greedy_bound_func are the current lowest cost in the - search frontier and the input arguments that were passed to the - optimizationPass() method of the search algorithm. If the greedy_bound_func - simply returns current_best_cost, then the search behavior is equivalent to - pure best-first search. Returning None is equivalent to returning an - infinite greedy bound, which produces a purely greedy best-first, - depth-first search. - - next_state_func (lambda state, *args) is a function that returns a list - of next states generated from the input state. An ActionNames object - should be incorporated into the additional input arguments in order to - generate next-states. - - goal_state_func (lambda state, *args) is a function that returns True if - the input state is a solution state of the search. - - upperbound_cost_func (lambda goal_state, *args) can either be None or a - function that returns an upper bound to the optimal cost given a goal_state - as input. The upper bound is used to prune next-states from the search in - subsequent calls to the optimizationPass() method of the search algorithm. - If upperbound_cost_func is None, the cost of the goal_state as determined - by cost_func is used as an upper bound to the optimal cost. If the + cost_func: a function that computes cost values from search states. + The cost returned can be numeric or tuples of numerics. In the latter case, + lexicographical comparisons are performed per Python semantics. + + next_state_func: a function that returns a list of next states generated from the input state. + + goal_state_func: a function that returns True if the input state is a solution state of the search. + + upperbound_cost_func: can either be None or a function that returns an upper bound + to the optimal cost given a goal_state as input. The upper bound is used to prune + next-states from the search in subsequent calls to the optimizationPass() method of + the search algorithm. If upperbound_cost_func is None, the cost of the goal_state + as determined by cost_func is used as an upper bound to the optimal cost. If the upperbound_cost_func returns None, the effect is equivalent to returning an infinite upper bound (i.e., no cost pruning is performed on subsequent - calls to the optimizationPass method. + calls to the optimizationPass method). - mincost_bound_func (lambda *args) can either be None or a function that + mincost_bound_func: can either be None or a function that returns a cost bound that is compared to the minimum cost across all - vertices in a search frontier. If the minimum cost exceeds the min-cost + vertices in a search frontier. If the minimum cost exceeds the min-cost bound, the search is terminated even if a goal state has not yet been found. - Returning None is equivalent to returning an infinite min-cost bound (i.e., - min-cost checking is effectively not performed). A mincost_bound_func that - is None is likewise equivalent to an infinite min-cost bound. + None is equivalent to returning an infinite min-cost bound (i.e., + min-cost checking is effectively not performed). """ - cost_func: Callable = None, - stratum_func: Callable = None, - greedy_bound_func: Callable = None, - next_state_func: Callable = None, - goal_state_func: Callable = None, - upperbound_cost_func: Callable = None, - mincost_bound_func: Callable = None + cost_func: Callable[[DisjointSubcircuitsState, SearchFunctions],float|tuple[float, int]] = None, + + next_state_func: Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], + list[DisjointSubcircuitsState]]= None, + + goal_state_func: Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], bool] = None, + + upperbound_cost_func: None | Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], + tuple[float, float]] = None, + + mincost_bound_func: None | Callable[[CutOptimizationFuncArgs], None | tuple[float, float]] = None @dataclass class SearchSpaceGenerator: - """Container class for holding both the functions and the + """Data class for holding both the functions and the associated actions needed to generate and explore a search space. Member Variables: - functions (SearchFunctions) is a container class that holds + functions: a container class that holds the functions needed to generate and explore a search space. - actions (ActionNames) is a container class that holds the search + actions: a container class that holds the search action objects needed to generate and explore a search space. The actions are expected to be passed as arguments to the search functions by a search engine. diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 29c57e6ee..e336f7e39 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 6037691f2..3381e0ec9 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -69,7 +69,7 @@ def test_BestFirstSearch(testCircuit): out, _ = op.optimizationPass() - assert.getStats(penultimate = True) is not None + assert op.search_engine.getStats(penultimate = True) is not None assert op.search_engine.getStats() is not None assert op.getUpperBoundCost() == (27, inf) assert op.minimumReached() == True From c78c9a6a7b3b8418779feb6d222a4f59e96cda28 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 30 Jan 2024 15:49:38 -0500 Subject: [PATCH 064/128] Update test to match new circuit interfaces --- .../cutting/cut_finding/circuit_interface.py | 18 ++-- .../cut_finding/test_circuit_interfaces.py | 90 ++++++++++--------- 2 files changed, 57 insertions(+), 51 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index e7866531a..6e247c96a 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -26,8 +26,8 @@ class CircuitElement(NamedTuple): """Named tuple for specifying a circuit element.""" name: str - params: list - qubits: list + params: list[float | int] + qubits: list[int | str] gamma: float | int @@ -251,7 +251,8 @@ def insertGateCut(self, gate_ID: int, cut_type: str) -> None: gate_pos = self.new_gate_ID_map[gate_ID] self.cut_type[gate_pos] = cut_type - def insertWireCut(self, gate_ID: int, input_ID: int, src_wire_ID: int, dest_wire_ID: int, cut_type: str) -> None: + def insertWireCut(self, gate_ID: int, input_ID: int, + src_wire_ID: int, dest_wire_ID: int, cut_type: str) -> None: """Insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. Gate inputs are numbered starting from 1. The @@ -409,13 +410,14 @@ def sortOrder(self, name: Hashable) -> int|float: return self.qubit_names.getID(name) - def replaceWireIDs(self, gate_list: list, wire_map: list): - """Iterate through a list of gates and replaces wire IDs with the + def replaceWireIDs(self, gate_list: list[CircuitElement], wire_map: list): + """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map. """ - for gate in gate_list: - for k in range(len(gate.qubits)): - gate.qubits[k] = wire_map[gate.qubits[k]] + for inst in gate_list: + if type(inst) == CircuitElement: + for k in range(len(inst.qubits)): + inst.qubits[k] = wire_map[inst.qubits[k]] class NameToIDMap: diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 29835520b..f49ca6b27 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -1,4 +1,4 @@ -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement, SimpleGateList class TestCircuitInterface: @@ -7,36 +7,38 @@ def test_CircuitConversion(self): used by the circuit-cutting optimizer. """ + #Assign a fixed gamma=1 to single qubit gates. trial_circuit = [ - ("h", "q1"), - ("barrier", "q1"), - ("s", "q0"), - "barrier", - ("cx", "q1", "q0"), + CircuitElement(name="h", params=[], qubits=["q1"], gamma=1), + CircuitElement(name="barrier",params=[], qubits= ["q1"], gamma=1), + CircuitElement(name="s", params=[], qubits = ["q0"], gamma = 1), + ("barrier"), + CircuitElement(name="cx", params=[], qubits = ["q1", "q0"], gamma = 3), ] circuit_converted = SimpleGateList(trial_circuit) assert circuit_converted.getNumQubits() == 2 assert circuit_converted.getNumWires() == 2 assert circuit_converted.qubit_names.item_dict == {"q1": 0, "q0": 1} - assert circuit_converted.getMultiQubitGates() == [[4, ["cx", 0, 1], None]] + assert circuit_converted.getMultiQubitGates() == [[4, CircuitElement(name="cx", params=[], + qubits = [0, 1], gamma = 3) , None]] assert circuit_converted.circuit == [ - [["h", 0], None], - [["barrier", 0], None], - [["s", 1], None], + [CircuitElement(name="h", params=[], qubits=[0], gamma=1), None], + [CircuitElement(name="barrier",params=[], qubits= [0], gamma=1), None], + [CircuitElement(name="s", params=[], qubits = [1], gamma = 1), None], ["barrier", None], - [["cx", 0, 1], None], + [CircuitElement(name="cx", params=[], qubits = [0, 1], gamma = 3), None] ] def test_GateCutInterface(self): """Test the internal representation of LO gate cuts.""" - trial_circuit = [ - ("cx", 0, 1), - ("cx", 2, 3), - ("cx", 1, 2), - ("cx", 0, 1), - ("cx", 2, 3), + trial_circuit=[ + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) circuit_converted.insertGateCut(2, "LO") @@ -49,11 +51,11 @@ def test_GateCutInterface(self): == "AABB" ) assert circuit_converted.exportCutCircuit(name_mapping="default") == [ - ["cx", 0, 1], - ["cx", 2, 3], - ["cx", 1, 2], - ["cx", 0, 1], - ["cx", 2, 3], + trial_circuit[0], + trial_circuit[1], + trial_circuit[2], + trial_circuit[3], + trial_circuit[4], ] # the following two methods are the same in the absence of wire cuts. @@ -66,12 +68,12 @@ def test_GateCutInterface(self): def test_WireCutInterface(self): """Test the internal representation of LO wire cuts.""" - trial_circuit = [ - ("cx", 0, 1), - ("cx", 2, 3), - ("cx", 1, 2), - ("cx", 0, 1), - ("cx", 2, 3), + trial_circuit=[ + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) circuit_converted.insertWireCut( @@ -85,12 +87,12 @@ def test_WireCutInterface(self): assert list(circuit_converted.new_gate_ID_map) == [0, 1, 3, 4, 5] assert circuit_converted.exportCutCircuit(name_mapping=None) == [ - ["cx", 0, 1], - ["cx", 2, 3], - ["move", 1, ("cut", 1)], - ["cx", ("cut", 1), 2], - ["cx", 0, ("cut", 1)], - ["cx", 2, 3], + trial_circuit[0], + trial_circuit[1], + ['move', 1, 4], + CircuitElement(name='cx', params=[], qubits=[("cut", 1), 2], gamma=3), + CircuitElement(name='cx', params=[], qubits=[0, ("cut", 1)], gamma=3), + trial_circuit[4], ] # relabel wires after wire cuts according to 'None' name_mapping. @@ -101,15 +103,6 @@ def test_WireCutInterface(self): 3: 3, } - assert circuit_converted.exportCutCircuit(name_mapping="default") == [ - ["cx", 0, 1], - ["cx", 3, 4], - ["move", 1, 2], - ["cx", 2, 3], - ["cx", 0, 2], - ["cx", 3, 4], - ] - # relabel wires after wire cuts according to 'default' name_mapping. assert circuit_converted.exportOutputWires(name_mapping="default") == { 0: 0, @@ -117,3 +110,14 @@ def test_WireCutInterface(self): 2: 3, 3: 4, } + + assert circuit_converted.exportCutCircuit(name_mapping="default") == [ + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[3,4], gamma=3), + ["move", 1, 4], + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + CircuitElement(name='cx', params=[], qubits=[0,2], gamma=3), + CircuitElement(name='cx', params=[], qubits=[3,4], gamma=3), + ] + + From 551237d87113102c741ae1aa1d84a4c519472da9 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 31 Jan 2024 10:05:32 -0500 Subject: [PATCH 065/128] Update circuit interface tests and some docstrings. --- .../cutting/cut_finding/circuit_interface.py | 89 +++++++++---------- .../cut_finding/search_space_generator.py | 6 +- circuit_knitting/cutting/cut_finding/utils.py | 11 +-- .../cut_finding/test_circuit_interfaces.py | 16 ++-- 4 files changed, 58 insertions(+), 64 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 6e247c96a..e2a23c344 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -17,7 +17,7 @@ import string from array import array from abc import ABC, abstractmethod -from typing import NamedTuple, Hashable +from typing import NamedTuple, Hashable, Iterable import numpy as np @@ -27,7 +27,7 @@ class CircuitElement(NamedTuple): name: str params: list[float | int] - qubits: list[int | str] + qubits: list[tuple | int | str] gamma: float | int @@ -59,8 +59,7 @@ def getMultiQubitGates(self): member functions implemented by the derived class to replace the gate with the decomposition determined by the optimizer. - The must of the form - (, , ..., ) + The must of the form of CircuitElement. The must be a hashable identifier that can be used to look up cutting rules for the specified gate. Gate names are typically @@ -84,15 +83,13 @@ def getMultiQubitGates(self): cuts can be considered. In this case, the cut type None must be explicitly included to indicate the possibilty of not cutting, if not cutting is to be considered. In the current version of the code, - the allowed cut types are 'None', 'GateCut', 'WireCut', and 'AbsorbGate'. + the allowed cut types are 'None', 'GateCut' and 'WireCut'. """ @abstractmethod def insertGateCut(self, gate_ID, cut_type): """Derived classes must override this function and mark the specified gate as being cut. The cut type can only be "LO" in this release. - In the future, support for "LOCCWithAncillas" and "LOCCNoAncillas". - will be added. """ @abstractmethod @@ -104,8 +101,7 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): is also provided as input to allow the wire choice to be verified. The ID of the new wire/qubit is also provided, which can then be used internally in derived classes to create new wires/qubits as needed. - The cut type can only be "LO" in this release. In the future, support - for "LOCCWithAncillas" and "LOCCNoAncillas" will be added. + The cut type can only be "LO" in this release. """ @@ -123,11 +119,10 @@ class SimpleGateList(CircuitInterface): """Derived class that converts a simple list of gates into the form needed by the circuit-cutting optimizer code. - Elements of the list must be of the form: - 'barrier' - ('barrier' ) - ( ... ) - + Elements of the list must be of the form of CircuitElement. + The only exception to this is a barrier when one is placed across + all the qubits in a circuit. That is specified as ("barrier"). + Qubit names can be any hashable objects. Gate names can also be any hashable objects, but they must be consistent with the names used by the optimizer to look up cutting rules for the specified gates. @@ -137,17 +132,17 @@ class SimpleGateList(CircuitInterface): Member Variables: - qubit_names (NameToIDMap) is an object that maps qubit names to + qubit_names: an object that maps qubit names to numerical qubit IDs. - num_qubits (int) is the number of qubits in the input circuit. Qubit IDs + num_qubits: the number of qubits in the input circuit. Qubit IDs whose values are greater than or equal to num_qubits represent qubits - that were introduced as the result of wire cutting. These qubits are + that were introduced as the result of wire cutting. These qubits are assigned generated names of the form ('cut', ) in the qubit_names object, where is the name of the wire/qubit that was cut to create the new wire/qubit. - circuit (list) is the internal representation of the circuit, which is + circuit: the internal representation of the circuit, which is a list of the following form: [ ... [, None] ...] @@ -155,34 +150,34 @@ class SimpleGateList(CircuitInterface): where the qubit names have been replaced with qubit IDs in the gate specifications. - new_circuit (list) is a list of gate specifications that define - the cut circuit. As with circuit, qubit IDs are used to identify + new_circuit: a list of gate specifications that define + the cut circuit. As with circuit, qubit IDs are used to identify wires/qubits. - cut_type (list) is a list that assigns cut-type annotations to gates + cut_type: a list that assigns cut-type annotations to gates in new_circuit to indicate which quasiprobability decomposition to use for the corresponding gate/wire cut. - new_gate_ID_map (list) is a list that maps the positions of gates + new_gate_ID_map: a list that maps the positions of gates in circuit to their new positions in new_circuit. - output_wires (list) maps qubit IDs in circuit to the corresponding + output_wires: a list that maps qubit IDs in circuit to the corresponding output wires of new_circuit so that observables defined for circuit can be remapped to new_circuit. - subcircuits (list) is a list of list of wire IDs, where each list of + subcircuits: a list of list of wire IDs, where each list of wire IDs defines a subcircuit. """ circuit: list[CircuitElement | None] new_circuit: list[CircuitElement] - cut_type: None + cut_type: str | None qubit_names: NameToIDMap num_qubits: int new_gate_ID_map: array[int] output_wires: array[int] - def __init__(self, input_circuit: list[CircuitElement], init_qubit_names: list =[]): + def __init__(self, input_circuit: list[CircuitElement], init_qubit_names: list[Hashable]= []): self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() @@ -222,7 +217,7 @@ def getNumWires(self) -> int: return self.qubit_names.getNumItems() - def getMultiQubitGates(self) -> list[int|CircuitElement]: + def getMultiQubitGates(self) -> list[int | CircuitElement]: """Extract the multiqubit gates from the circuit and prepends the index of the gate in the circuits to the gate specification. @@ -233,7 +228,7 @@ def getMultiQubitGates(self) -> list[int|CircuitElement]: described above. The is the list index of the corresponding element in - self.circuit + self.circuit. """ subcircuit = list() for k, gate in enumerate(self.circuit): @@ -258,14 +253,14 @@ def insertWireCut(self, gate_ID: int, input_ID: int, that gate. Gate inputs are numbered starting from 1. The wire/qubit ID of the source wire to be cut is also provided as input to allow the wire choice to be verified. The ID of the - (new) destination wire/qubit must also be provided. The cut + (new) destination wire/qubit must also be provided. The cut type in this release can only be "LO". """ gate_pos = self.new_gate_ID_map[gate_ID] new_gate_spec = self.new_circuit[gate_pos] - # Gate inputs are numbered starting from 1, so we must decrement the index to qubits + # Gate inputs are numbered starting from 1, so we must decrement the index to match qubit numbering. assert src_wire_ID == new_gate_spec.qubits[input_ID-1], ( f"Input wire ID {src_wire_ID} does not match " + f"new_circuit wire ID {new_gate_spec.qubits[input_ID-1]}" @@ -359,7 +354,7 @@ def exportSubcircuitsAsString(self, name_mapping: str ="default") -> str: return "".join(out) def makeWireMapping(self, name_mapping: None | str) -> list: - """Return a wire-mapping array given an input specification of a + """Return a wire-mapping list given an input specification of a name mapping. If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. If "default" is used as the name_mapping, then the defaultWireNameMapping() @@ -382,12 +377,13 @@ def makeWireMapping(self, name_mapping: None | str) -> list: return wire_mapping - def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]],int]: + def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]], int]: """Return a dictionary that maps wire names in self.qubit_names to default numeric output qubit names when exporting a cut circuit. Cut - wires are assigned numeric names that are adjacent to the numeric - name of the wire prior to cutting so that Move operators are then - applied against adjacent qubits. + wires are assigned numeric IDs that are adjacent to the numeric + ID of the wire prior to cutting so that Move operators are then + applied against adjacent qubits. This is ensured by the sortOrder + method. """ name_pairs = [(name, self.sortOrder(name)) for name in self.getWireNames()] @@ -400,7 +396,9 @@ def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]],int]: return name_map - def sortOrder(self, name: Hashable) -> int|float: + def sortOrder(self, name: Hashable) -> int | float: + """Order numeric IDs of wires to enable defaultWireNameMapping. """ + if isinstance(name, tuple): if name[0] == "cut": x = self.sortOrder(name[1]) @@ -410,7 +408,7 @@ def sortOrder(self, name: Hashable) -> int|float: return self.qubit_names.getID(name) - def replaceWireIDs(self, gate_list: list[CircuitElement], wire_map: list): + def replaceWireIDs(self, gate_list: list[CircuitElement], wire_map: list[tuple | int | str]): """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map. """ @@ -422,14 +420,15 @@ def replaceWireIDs(self, gate_list: list[CircuitElement], wire_map: list): class NameToIDMap: - """Class used to map hashable items (e.g., qubit names) to natural numbers - (e.g., qubit IDs)""" + """Class used to construct maps between hashable items (e.g., qubit names) + and natural numbers (e.g., qubit IDs). + """ next_ID: int - item_dict: dict - ID_dict: dict + item_dict: dict[Hashable, int] + ID_dict: dict[int, Hashable] - def __init__(self, init_names: list =[]): + def __init__(self, init_names: list[Hashable]): """Allow the name dictionary to be initialized with the names in init_names in the order the names appear in order to force a preferred ordering in the assigment of item IDs to those names. @@ -468,7 +467,7 @@ def defineID(self, item_ID: int, item_name: Hashable): self.item_dict[item_name] = item_ID self.ID_dict[item_ID] = item_name - def getName(self, item_ID: int) -> Hashable|None: + def getName(self, item_ID: int) -> Hashable | None: """Return the name associated with the specified item ID. None is returned if item_ID does not (yet) exist. """ @@ -495,12 +494,12 @@ def getArraySizeNeeded(self) -> int: return 1 + max(self.ID_dict.keys()) - def getItems(self)-> Hashable: + def getItems(self) -> Iterable[Hashable]: """Return an iterator over the hashable items loaded thus far.""" return self.item_dict.keys() - def getIDs(self) -> Hashable: + def getIDs(self) -> Iterable[Hashable]: """Return an iterator over the hashable items loaded thus far.""" return self.ID_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index d7c3dc6a1..67794db24 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -39,7 +39,7 @@ class ActionNames: """ action_dict: dict[str, DisjointSearchAction] - group_dict: dict[str,list[DisjointSearchAction]] + group_dict: dict[str, list[DisjointSearchAction]] def __init__(self): self.action_dict = dict() @@ -174,8 +174,8 @@ class SearchSpaceGenerator: Member Variables: - functions: a container class that holds - the functions needed to generate and explore a search space. + functions: a data class that holds the functions needed to generate + and explore a search space. actions: a container class that holds the search action objects needed to generate and explore a search space. diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 6344e8e15..d4b88527c 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -22,19 +22,14 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): - """Convert a qiskit quantum circuit object into a circuit list that is compatible with the SimpleGateList. + """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class: `SimpleGateList`. Args: circuit: QuantumCircuit object. Returns: - circuit_list_rep: list of circuit gates along with qubit numbers associated to each gate, represented in a - form that is compatible with SimpleGateList and is of the form: - - ['barrier', - ('barrier', ), - (( [, ]), ... )]. - + circuit_list_rep: list of circuit instructions represented in a form that is compatible with + :class: `SimpleGateList` and can therefore be ingested by the cut finder. TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. """ diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index f49ca6b27..6f95a30dc 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -7,11 +7,11 @@ def test_CircuitConversion(self): used by the circuit-cutting optimizer. """ - #Assign a fixed gamma=1 to single qubit gates. + #Assign gamma=None to single qubit gates. trial_circuit = [ - CircuitElement(name="h", params=[], qubits=["q1"], gamma=1), - CircuitElement(name="barrier",params=[], qubits= ["q1"], gamma=1), - CircuitElement(name="s", params=[], qubits = ["q0"], gamma = 1), + CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), + CircuitElement(name="barrier",params=[], qubits= ["q1"], gamma=None), + CircuitElement(name="s", params=[], qubits = ["q0"], gamma = None), ("barrier"), CircuitElement(name="cx", params=[], qubits = ["q1", "q0"], gamma = 3), ] @@ -23,9 +23,9 @@ def test_CircuitConversion(self): assert circuit_converted.getMultiQubitGates() == [[4, CircuitElement(name="cx", params=[], qubits = [0, 1], gamma = 3) , None]] assert circuit_converted.circuit == [ - [CircuitElement(name="h", params=[], qubits=[0], gamma=1), None], - [CircuitElement(name="barrier",params=[], qubits= [0], gamma=1), None], - [CircuitElement(name="s", params=[], qubits = [1], gamma = 1), None], + [CircuitElement(name="h", params=[], qubits=[0], gamma=None), None], + [CircuitElement(name="barrier",params=[], qubits= [0], gamma=None), None], + [CircuitElement(name="s", params=[], qubits = [1], gamma = None), None], ["barrier", None], [CircuitElement(name="cx", params=[], qubits = [0, 1], gamma = 3), None] ] @@ -56,7 +56,7 @@ def test_GateCutInterface(self): trial_circuit[2], trial_circuit[3], trial_circuit[4], - ] + ] # the following two methods are the same in the absence of wire cuts. assert ( From 077d4b5845618443ee70eb9281646a81b02dec58 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 31 Jan 2024 12:28:43 -0500 Subject: [PATCH 066/128] Update CCOtoQC func and associated test. --- .../cutting/cut_finding/circuit_interface.py | 2 +- circuit_knitting/cutting/cut_finding/utils.py | 60 ++++++++++++------- test/cutting/cut_finding/test_cco_utils.py | 47 ++++++++------- .../cut_finding/test_circuit_interfaces.py | 2 +- 4 files changed, 65 insertions(+), 46 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index e2a23c344..d7e8208d6 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -59,7 +59,7 @@ def getMultiQubitGates(self): member functions implemented by the derived class to replace the gate with the decomposition determined by the optimizer. - The must of the form of CircuitElement. + The must be of the form of CircuitElement. The must be a hashable identifier that can be used to look up cutting rules for the specified gate. Gate names are typically diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index d4b88527c..9092cf889 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -22,14 +22,14 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): - """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class: `SimpleGateList`. + """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class:`SimpleGateList`. Args: circuit: QuantumCircuit object. Returns: circuit_list_rep: list of circuit instructions represented in a form that is compatible with - :class: `SimpleGateList` and can therefore be ingested by the cut finder. + :class:`SimpleGateList` and can therefore be ingested by the cut finder. TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. """ @@ -39,12 +39,19 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): circuit_list_rep.append(inst.operation.name) else: gamma = None + if inst.operation.name == "barrier" and len(inst.qubits) != circuit.num_qubits: + circuit_element = CircuitElement( + name=inst.operation.name, + params=[], + qubits=list(circuit.find_bit(q).index for q in inst.qubits), + gamma=gamma, + ) if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: gamma = QPDBasis.from_instruction(inst.operation).kappa circuit_element = CircuitElement( inst.operation.name, params=inst.operation.params, - qubits=tuple(circuit.find_bit(q).index for q in inst.qubits), + qubits=list(circuit.find_bit(q).index for q in inst.qubits), gamma=gamma, ) circuit_list_rep.append(circuit_element) @@ -53,34 +60,45 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): def CCOtoQCCircuit(interface): - """Convert the cut circuit outputted by the CircuitCuttingOptimizer into a qiskit.QuantumCircuit object. + """Convert the cut circuit outputted by the cut finder into a :class:`qiskit.QuantumCircuit` instance. Args: - interface: A SimpleGateList object whose attributes carry information about the cut circuit. + interface: An instance of :class:`SimpleGateList` whose attributes carry information about the cut circuit. Returns: - qc_cut: The SimpleGateList converted into a qiskit.QuantumCircuit object, + qc_cut: The SimpleGateList converted into a :class:`qiskit.QuantumCircuit` instance. + + TODO: This function only works for instances of LO gate cutting. Expand to cover the wire cutting case. """ cut_circuit_list = interface.exportCutCircuit(name_mapping=None) num_qubits = interface.getNumWires() - cut_circuit_list_len = len(cut_circuit_list) cut_types = interface.cut_type qc_cut = QuantumCircuit(num_qubits) - for i in range(cut_circuit_list_len): - op = cut_circuit_list[ - i - ] # the operation, including gate names and qubits acted on. - gate_qubits = len(op) - 1 # number of qubits involved in the operation. - if cut_types[i] is None: # only append gates that are not cut to qc_cut. - if type(op[0]) is tuple: - params = [i for i in op[0][1:]] - gate_name = op[0][0] - else: - params = [] - gate_name = op[0] - inst = Instruction(gate_name, gate_qubits, 0, params) - qc_cut.append(inst, op[1 : len(op)]) + for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): + if cut_types[k] is None: #only append gates that are not cut. + op_name = op.name + op_qubits = op.qubits + op_params = op.params + inst = Instruction(op_name, len(op_qubits), 0, op_params) + qc_cut.append(inst, op_qubits) return qc_cut + + + # for i in range(cut_circuit_list_len): + # op = cut_circuit_list[ + # i + # ] # the operation, including gate names and qubits acted on. + # gate_qubits = len(op) - 1 # number of qubits involved in the operation. + # if cut_types[i] is None: # only append gates that are not cut to qc_cut. + # if type(op[0]) is tuple: + # params = [i for i in op[0][1:]] + # gate_name = op[0][0] + # else: + # params = [] + # gate_name = op[0] + # inst = Instruction(gate_name, gate_qubits, 0, params) + # qc_cut.append(inst, op[1 : len(op)]) + # return qc_cut def selectSearchEngine( diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index 8a4e5fd36..7ae37654b 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -3,8 +3,8 @@ from qiskit.circuit.library import EfficientSU2 from qiskit import QuantumCircuit, QuantumRegister from qiskit.circuit import Qubit, Instruction, CircuitInstruction -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit, CCOtoQCCircuit +from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList, CircuitElement # test circuit 1. tc_1 = QuantumCircuit(2) @@ -23,13 +23,13 @@ @fixture def InternalTestCircuit(): circuit = [ - ("cx", 0, 1), - ("cx", 2, 3), - ("cx", 1, 2), - ("cx", 0, 1), - ("cx", 2, 3), - ("h", 0), - (("rx", 0.4), 0), + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), + CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), + CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + CircuitElement(name='h', params=[], qubits=[0], gamma=None), + CircuitElement(name='rx', params=[0.4], qubits=[0], gamma=None), ] interface = SimpleGateList(circuit) interface.insertGateCut(2, "LO") @@ -40,24 +40,25 @@ def InternalTestCircuit(): @pytest.mark.parametrize( "test_circuit, known_output", [ - (tc_1, [("h", 1), ("barrier", 1), ("s", 0), "barrier", ("cx", 1, 0)]), + (tc_1, [CircuitElement("h", [], [1], None), CircuitElement("barrier",[], [1], None), + CircuitElement("s",[], [0], None), "barrier", CircuitElement("cx", [], [1, 0], 3)]), ( tc_2, [ - (("ry", 0.4), 0), - (("rz", 0.4), 0), - (("ry", 0.4), 1), - (("rz", 0.4), 1), - ("cx", 0, 1), - (("ry", 0.4), 0), - (("rz", 0.4), 0), - (("ry", 0.4), 1), - (("rz", 0.4), 1), - ("cx", 0, 1), - (("ry", 0.4), 0), - (("rz", 0.4), 0), - (("ry", 0.4), 1), - (("rz", 0.4), 1), + CircuitElement("ry", [0.4], [0], None), + CircuitElement("rz", [0.4], [0], None), + CircuitElement("ry", [0.4], [1], None), + CircuitElement("rz", [0.4], [1], None), + CircuitElement("cx", [], [0, 1], 3), + CircuitElement("ry", [0.4], [0], None), + CircuitElement("rz", [0.4], [0], None), + CircuitElement("ry", [0.4], [1], None), + CircuitElement("rz", [0.4], [1], None), + CircuitElement("cx", [],[0, 1], 3), + CircuitElement("ry", [0.4], [0], None), + CircuitElement("rz", [0.4], [0], None), + CircuitElement("ry", [0.4], [1], None), + CircuitElement("rz", [0.4], [1], None), ], ), ], diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 6f95a30dc..7c8a2e957 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -12,7 +12,7 @@ def test_CircuitConversion(self): CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), CircuitElement(name="barrier",params=[], qubits= ["q1"], gamma=None), CircuitElement(name="s", params=[], qubits = ["q0"], gamma = None), - ("barrier"), + "barrier", CircuitElement(name="cx", params=[], qubits = ["q1", "q0"], gamma = 3), ] circuit_converted = SimpleGateList(trial_circuit) From 7b35453853280c7ab971409d7ad4f49f09547533 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 31 Jan 2024 14:37:31 -0500 Subject: [PATCH 067/128] Update BFS test and run style. --- .../cutting/cut_finding/__init__.py | 1 - .../cutting/cut_finding/circuit_interface.py | 50 +++++----- .../cutting/cut_finding/cut_optimization.py | 4 +- .../cutting/cut_finding/cutting_actions.py | 13 +-- .../cut_finding/disjoint_subcircuits_state.py | 5 +- .../cut_finding/optimization_settings.py | 8 +- .../cut_finding/search_space_generator.py | 49 +++++---- circuit_knitting/cutting/cut_finding/utils.py | 36 +++---- .../tutorials/04_automatic_cut_finding.ipynb | 17 +++- .../tutorials/LO_circuit_cut_finder.ipynb | 99 ++++++++++--------- .../cut_finding/test_best_first_search.py | 99 ++++++++++++------- test/cutting/cut_finding/test_cco_utils.py | 34 ++++--- .../cut_finding/test_circuit_interfaces.py | 68 ++++++------- .../cut_finding/test_cut_finder_roundtrip.py | 14 ++- .../cut_finding/test_cutting_actions.py | 6 +- .../test_disjoint_subcircuits_state.py | 22 ++--- .../cut_finding/test_optimization_settings.py | 12 ++- .../test_quantum_device_constraints.py | 8 +- 18 files changed, 295 insertions(+), 250 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index b9765124b..e69de29bb 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -1 +0,0 @@ -from .cut_finding import find_cuts \ No newline at end of file diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index d7e8208d6..78424857c 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -9,7 +9,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Quantum circuit representation compatible with cut-finding optimizers.""" +"""Quantum circuit representation compatible with cut-finding optimizer.""" from __future__ import annotations @@ -104,7 +104,6 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): The cut type can only be "LO" in this release. """ - @abstractmethod def defineSubcircuits(self, list_of_list_of_wires): """Derived classes must override this function. The input is a @@ -113,7 +112,6 @@ def defineSubcircuits(self, list_of_list_of_wires): """ - class SimpleGateList(CircuitInterface): """Derived class that converts a simple list of gates into @@ -121,8 +119,8 @@ class SimpleGateList(CircuitInterface): Elements of the list must be of the form of CircuitElement. The only exception to this is a barrier when one is placed across - all the qubits in a circuit. That is specified as ("barrier"). - + all the qubits in a circuit. That is specified by a string "barrier". + Qubit names can be any hashable objects. Gate names can also be any hashable objects, but they must be consistent with the names used by the optimizer to look up cutting rules for the specified gates. @@ -155,8 +153,7 @@ class SimpleGateList(CircuitInterface): wires/qubits. cut_type: a list that assigns cut-type annotations to gates - in new_circuit to indicate which quasiprobability decomposition to - use for the corresponding gate/wire cut. + in new_circuit. new_gate_ID_map: a list that maps the positions of gates in circuit to their new positions in new_circuit. @@ -168,6 +165,7 @@ class SimpleGateList(CircuitInterface): subcircuits: a list of list of wire IDs, where each list of wire IDs defines a subcircuit. """ + circuit: list[CircuitElement | None] new_circuit: list[CircuitElement] cut_type: str | None @@ -176,8 +174,9 @@ class SimpleGateList(CircuitInterface): new_gate_ID_map: array[int] output_wires: array[int] - - def __init__(self, input_circuit: list[CircuitElement], init_qubit_names: list[Hashable]= []): + def __init__( + self, input_circuit: list[CircuitElement], init_qubit_names: list[Hashable] = [] + ): self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() @@ -205,8 +204,6 @@ def __init__(self, input_circuit: list[CircuitElement], init_qubit_names: list[H # Initialize the list of subcircuits assuming no cutting self.subcircuits = list(list(range(self.num_qubits))) - - def getNumQubits(self) -> int: """Return the number of qubits in the input circuit.""" @@ -246,8 +243,14 @@ def insertGateCut(self, gate_ID: int, cut_type: str) -> None: gate_pos = self.new_gate_ID_map[gate_ID] self.cut_type[gate_pos] = cut_type - def insertWireCut(self, gate_ID: int, input_ID: int, - src_wire_ID: int, dest_wire_ID: int, cut_type: str) -> None: + def insertWireCut( + self, + gate_ID: int, + input_ID: int, + src_wire_ID: int, + dest_wire_ID: int, + cut_type: str, + ) -> None: """Insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. Gate inputs are numbered starting from 1. The @@ -261,7 +264,7 @@ def insertWireCut(self, gate_ID: int, input_ID: int, new_gate_spec = self.new_circuit[gate_pos] # Gate inputs are numbered starting from 1, so we must decrement the index to match qubit numbering. - assert src_wire_ID == new_gate_spec.qubits[input_ID-1], ( + assert src_wire_ID == new_gate_spec.qubits[input_ID - 1], ( f"Input wire ID {src_wire_ID} does not match " + f"new_circuit wire ID {new_gate_spec.qubits[input_ID-1]}" ) @@ -284,10 +287,9 @@ def insertWireCut(self, gate_ID: int, input_ID: int, self.new_gate_ID_map[gate_ID:] += 1 # Update the output wires - qubit = self.circuit[gate_ID][0].qubits[input_ID-1] + qubit = self.circuit[gate_ID][0].qubits[input_ID - 1] self.output_wires[qubit] = dest_wire_ID - def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: """Assign subcircuits where each subcircuit is specified as a list of wire IDs. @@ -295,7 +297,7 @@ def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: self.subcircuits = list_of_list_of_wires - def getWireNames(self) -> list[str | tuple[str, str]] : + def getWireNames(self) -> list[str | tuple[str, str]]: """Return a list of the internal wire names used in the circuit, which consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. @@ -303,7 +305,7 @@ def getWireNames(self) -> list[str | tuple[str, str]] : return list(self.qubit_names.getItems()) - def exportCutCircuit(self, name_mapping: str ="default") -> list[CircuitElement]: + def exportCutCircuit(self, name_mapping: str = "default") -> list[CircuitElement]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -320,7 +322,7 @@ def exportCutCircuit(self, name_mapping: str ="default") -> list[CircuitElement] return out - def exportOutputWires(self, name_mapping: str ="default") -> dict: + def exportOutputWires(self, name_mapping: str = "default") -> dict: """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. If None is provided as the name_mapping, then the original qubit names are @@ -337,7 +339,7 @@ def exportOutputWires(self, name_mapping: str ="default") -> dict: out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] return out - def exportSubcircuitsAsString(self, name_mapping: str ="default") -> str: + def exportSubcircuitsAsString(self, name_mapping: str = "default") -> str: """Return a string that maps qubits/wires in the output circuit to subcircuits per the Circuit Knitting Toolbox convention. This method only works with mappings to numeric qubit/wire names, such @@ -377,7 +379,7 @@ def makeWireMapping(self, name_mapping: None | str) -> list: return wire_mapping - def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]], int]: + def defaultWireNameMapping(self) -> dict[list[str | tuple[str, str]], int]: """Return a dictionary that maps wire names in self.qubit_names to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric IDs that are adjacent to the numeric @@ -397,7 +399,7 @@ def defaultWireNameMapping(self) -> dict[list[str|tuple[str, str]], int]: return name_map def sortOrder(self, name: Hashable) -> int | float: - """Order numeric IDs of wires to enable defaultWireNameMapping. """ + """Order numeric IDs of wires to enable defaultWireNameMapping.""" if isinstance(name, tuple): if name[0] == "cut": @@ -408,7 +410,9 @@ def sortOrder(self, name: Hashable) -> int | float: return self.qubit_names.getID(name) - def replaceWireIDs(self, gate_list: list[CircuitElement], wire_map: list[tuple | int | str]): + def replaceWireIDs( + self, gate_list: list[CircuitElement], wire_map: list[tuple | int | str] + ) -> None: """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map. """ diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 93a34d72a..2eb97a9fe 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -74,7 +74,9 @@ def CutOptimizationNextStateFunc(state, func_args): if len(gate_spec[1].qubits) == 2: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: - raise ValueError("At present, only the cutting of two qubit gates is supported.") + raise ValueError( + "At present, only the cutting of two qubit gates is supported." + ) action_list = getActionSubset(action_list, gate_spec[2]) # Apply the search actions to generate a list of next states diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index cbd397523..3d4619111 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -53,7 +53,6 @@ def nextState(self, state, gate_spec, max_width): return next_list - class ActionApplyGate(DisjointSearchAction): @@ -76,10 +75,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): specification: gate_spec. """ gate = gate_spec[1] # extract the gate from gate specification. - # if len(gate.qubits) > 2: - # # The function multiqubitNextState handles - # # gates that act on 3 or more qubits. - # return self.multiqubitNextState(state, gate_spec, max_width) r1 = state.findQubitRoot( gate.qubits[0] @@ -173,13 +168,12 @@ def getCostParams(gate_spec): This method returns a tuple of the form: (gamma_lower_bound, num_bell_pairs, gamma_upper_bound) - Since CKT only supports single-cut LO, these tuples will be of + Since CKT does not support LOCC at the moment, these tuples will be of the form (gamma, 0, gamma). """ gamma = gate_spec[1].gamma return (gamma, 0, gamma) - def exportCuts(self, circuit_interface, wire_map, gate_spec, args): """Insert an LO gate cut into the input circuit for the specified gate and cut arguments. @@ -224,7 +218,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): q1 = gate.qubits[0] q2 = gate.qubits[1] w1 = state.getWire(q1) - w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) r2 = state.findQubitRoot(q2) @@ -247,7 +240,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. @@ -260,7 +252,6 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) - def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments. @@ -303,7 +294,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): gate = gate_spec[1] q1 = gate.qubits[0] q2 = gate.qubits[1] - w1 = state.getWire(q1) w2 = state.getWire(q2) r1 = state.findQubitRoot(q1) r2 = state.findQubitRoot(q2) @@ -327,7 +317,6 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index c430bb0fd..f9ef244ce 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -161,7 +161,7 @@ def copy(self): """Make shallow copy.""" return copy.copy(self) - + def CutActionsList(self): """Create a formatted list containing the actions carried out on a DisjointSubcircuitState along with the locations of these actions which are specified in terms of @@ -429,9 +429,6 @@ def exportCuts(self, circuit_interface): circuit_interface.defineSubcircuits(subcircuits) - scc_subcircuits = [(s,) for s in range(len(subcircuits))] - scc_order = np.zeros((len(scc_subcircuits), len(scc_subcircuits)), dtype=bool) - def calcRootBellPairsGamma(root_bell_pairs): """Calculate the minimum-achievable LOCC gamma for circuit diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 3037c4955..e7bf34419 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -16,7 +16,6 @@ from dataclasses import dataclass - @dataclass class OptimizationSettings: """Class for specifying parameters that control the optimization. @@ -31,7 +30,7 @@ class OptimizationSettings: only "BestFirst" or Dijkstra's best-first search is supported. max_backjumps: a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. + operations that can be performed by the search algorithm. rand_seed: a seed used to provide a repeatable initialization of the pesudorandom number generators used by the optimization. @@ -129,10 +128,7 @@ def getCutSearchGroups(self) -> list[str]: out = [None] - if ( - self.gate_cut_LO - or self.gate_cut_LOCC_with_ancillas - ): + if self.gate_cut_LO or self.gate_cut_LOCC_with_ancillas: out.append("GateCut") if ( diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 67794db24..d75152d0d 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -15,6 +15,7 @@ from dataclasses import dataclass from typing import TYPE_CHECKING + if TYPE_CHECKING: from cut_optimization import CutOptimizationFuncArgs from .cutting_actions import DisjointSearchAction @@ -24,7 +25,6 @@ from .disjoint_subcircuits_state import DisjointSubcircuitsState - class ActionNames: """Class that maps action names to individual action objects @@ -39,13 +39,12 @@ class ActionNames: """ action_dict: dict[str, DisjointSearchAction] - group_dict: dict[str, list[DisjointSearchAction]] + group_dict: dict[str, list[DisjointSearchAction]] def __init__(self): self.action_dict = dict() self.group_dict = dict() - def copy(self, list_of_groups: list[str] = None) -> ActionNames: """Return a copy of self that contains only those actions whose group affiliations intersect with list_of_groups. @@ -79,12 +78,12 @@ def defineAction(self, action_object: DisjointSearchAction) -> None: if name not in self.group_dict: self.group_dict[name] = list() self.group_dict[name].append(action_object) - else: #pragma: no cover + else: # pragma: no cover if group_name not in self.group_dict: self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) - def getAction(self, action_name: str) -> (DisjointSearchAction | None): + def getAction(self, action_name: str) -> DisjointSearchAction | None: """Return the action object associated with the specified name. None is returned if there is no associated action object. """ @@ -93,7 +92,7 @@ def getAction(self, action_name: str) -> (DisjointSearchAction | None): return self.action_dict[action_name] return None - def getGroup(self, group_name: str) -> (list | None): + def getGroup(self, group_name: str) -> list | None: """Return the list of action objects associated with the group_name. None is returned if there are no associated action objects. """ @@ -102,7 +101,8 @@ def getGroup(self, group_name: str) -> (list | None): return self.group_dict[group_name] return None -def getActionSubset(action_list: list, action_groups: Iterable) -> list : + +def getActionSubset(action_list: list, action_groups: Iterable) -> list: """Return the subset of actions in action_list whose group affiliations intersect with action_groups. """ @@ -110,7 +110,7 @@ def getActionSubset(action_list: list, action_groups: Iterable) -> list : if action_groups is None: return action_list - if len(action_groups) == 0: #pragma: no cover + if len(action_groups) == 0: # pragma: no cover action_groups = [None] groups = set(action_groups) @@ -119,13 +119,14 @@ def getActionSubset(action_list: list, action_groups: Iterable) -> list : a for a in action_list if len(groups.intersection(set(a.getGroupNames()))) > 0 ] + @dataclass class SearchFunctions: """Data class for holding functions needed to generate and explore a search space. In addition to the required input arguments, the function signatures are assumed to also allow additional input arguments that are - needed to perform the corresponding computations. + needed to perform the corresponding computations. Member Variables: @@ -133,7 +134,7 @@ class SearchFunctions: The cost returned can be numeric or tuples of numerics. In the latter case, lexicographical comparisons are performed per Python semantics. - next_state_func: a function that returns a list of next states generated from the input state. + next_state_func: a function that returns a list of next states generated from the input state. goal_state_func: a function that returns True if the input state is a solution state of the search. @@ -154,17 +155,27 @@ class SearchFunctions: min-cost checking is effectively not performed). """ - cost_func: Callable[[DisjointSubcircuitsState, SearchFunctions],float|tuple[float, int]] = None, + cost_func: Callable[ + [DisjointSubcircuitsState, SearchFunctions], float | tuple[float, int] + ] = (None,) + + next_state_func: Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], + list[DisjointSubcircuitsState], + ] = (None,) + + goal_state_func: Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], bool + ] = (None,) + + upperbound_cost_func: None | Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], tuple[float, float] + ] = (None,) - next_state_func: Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], - list[DisjointSubcircuitsState]]= None, - - goal_state_func: Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], bool] = None, + mincost_bound_func: None | Callable[ + [CutOptimizationFuncArgs], None | tuple[float, float] + ] = None - upperbound_cost_func: None | Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], - tuple[float, float]] = None, - - mincost_bound_func: None | Callable[[CutOptimizationFuncArgs], None | tuple[float, float]] = None @dataclass class SearchSpaceGenerator: diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 9092cf889..31363e457 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -39,13 +39,16 @@ def QCtoCCOCircuit(circuit: QuantumCircuit): circuit_list_rep.append(inst.operation.name) else: gamma = None - if inst.operation.name == "barrier" and len(inst.qubits) != circuit.num_qubits: + if ( + inst.operation.name == "barrier" + and len(inst.qubits) != circuit.num_qubits + ): circuit_element = CircuitElement( - name=inst.operation.name, - params=[], - qubits=list(circuit.find_bit(q).index for q in inst.qubits), - gamma=gamma, - ) + name=inst.operation.name, + params=[], + qubits=list(circuit.find_bit(q).index for q in inst.qubits), + gamma=gamma, + ) if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: gamma = QPDBasis.from_instruction(inst.operation).kappa circuit_element = CircuitElement( @@ -68,37 +71,20 @@ def CCOtoQCCircuit(interface): Returns: qc_cut: The SimpleGateList converted into a :class:`qiskit.QuantumCircuit` instance. - TODO: This function only works for instances of LO gate cutting. Expand to cover the wire cutting case. + TODO: This function only works for instances of LO gate cutting. Expand to cover the wire cutting case when needed. """ cut_circuit_list = interface.exportCutCircuit(name_mapping=None) num_qubits = interface.getNumWires() cut_types = interface.cut_type qc_cut = QuantumCircuit(num_qubits) for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): - if cut_types[k] is None: #only append gates that are not cut. + if cut_types[k] is None: # only append gates that are not cut. op_name = op.name op_qubits = op.qubits op_params = op.params inst = Instruction(op_name, len(op_qubits), 0, op_params) qc_cut.append(inst, op_qubits) return qc_cut - - - # for i in range(cut_circuit_list_len): - # op = cut_circuit_list[ - # i - # ] # the operation, including gate names and qubits acted on. - # gate_qubits = len(op) - 1 # number of qubits involved in the operation. - # if cut_types[i] is None: # only append gates that are not cut to qc_cut. - # if type(op[0]) is tuple: - # params = [i for i in op[0][1:]] - # gate_name = op[0][0] - # else: - # params = [] - # gate_name = op[0] - # inst = Instruction(gate_name, gate_qubits, 0, params) - # qc_cut.append(inst, op[1 : len(op)]) - # return qc_cut def selectSearchEngine( diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 05e1693c2..a6a4fa98d 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -35,6 +35,7 @@ "import numpy as np\n", "from qiskit.circuit.random import random_circuit\n", "from qiskit.quantum_info import PauliList\n", + "\n", "circuit = random_circuit(7, 6, max_operands=2, seed=1242)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")" @@ -132,10 +133,14 @@ "source": [ "from circuit_knitting.cutting import partition_problem\n", "\n", - "partitioned_problem = partition_problem(circuit=qc_w_ancilla, observables=observables_expanded)\n", + "partitioned_problem = partition_problem(\n", + " circuit=qc_w_ancilla, observables=observables_expanded\n", + ")\n", "subcircuits = partitioned_problem.subcircuits\n", "subobservables = partitioned_problem.subobservables\n", - "print(f\"Sampling overhead: {np.prod([basis.overhead for basis in partitioned_problem.bases])}\")" + "print(\n", + " f\"Sampling overhead: {np.prod([basis.overhead for basis in partitioned_problem.bases])}\"\n", + ")" ] }, { @@ -224,8 +229,12 @@ "source": [ "from circuit_knitting.cutting import generate_cutting_experiments\n", "\n", - "subexperiments, coefficients = generate_cutting_experiments(circuits=subcircuits, observables=subobservables, num_samples=1_000)\n", - "print(f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\")" + "subexperiments, coefficients = generate_cutting_experiments(\n", + " circuits=subcircuits, observables=subobservables, num_samples=1_000\n", + ")\n", + "print(\n", + " f\"{len(subexperiments[0]) + len(subexperiments[1])} total subexperiments to run on backend.\"\n", + ")" ] } ], diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index e336f7e39..44bf5ad7a 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -9,8 +9,12 @@ "import numpy as np\n", "from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList\n", "from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer\n", - "from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings\n", - "from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints" + "from circuit_knitting.cutting.cut_finding.optimization_settings import (\n", + " OptimizationSettings,\n", + ")\n", + "from circuit_knitting.cutting.cut_finding.quantum_device_constraints import (\n", + " DeviceConstraints,\n", + ")" ] }, { @@ -51,11 +55,9 @@ "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", "\n", - "circuit_ckt=QCtoCCOCircuit(qc)\n", + "circuit_ckt = QCtoCCOCircuit(qc)\n", "\n", - "qc.draw(\"mpl\", scale=0.8)\n", - "\n", - "\n" + "qc.draw(\"mpl\", scale=0.8)" ] }, { @@ -99,39 +101,43 @@ } ], "source": [ - "settings = OptimizationSettings(rand_seed = 12345)\n", - "\n", - "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", + "settings = OptimizationSettings(rand_seed=12345)\n", "\n", + "settings.setEngineSelection(\"CutOptimization\", \"BestFirst\")\n", "\n", - "qubits_per_QPU=4\n", - "num_QPUs=2\n", "\n", + "qubits_per_QPU = 4\n", + "num_QPUs = 2\n", "\n", "\n", "for num_qpus in range(num_QPUs, 1, -1):\n", " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", - " \n", - " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", - " num_QPUs = num_QPUs)\n", - " \n", + " print(f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------\")\n", + "\n", + " constraint_obj = DeviceConstraints(qubits_per_QPU=qpu_qubits, num_QPUs=num_QPUs)\n", + "\n", " interface = SimpleGateList(circuit_ckt)\n", "\n", - " op = LOCutsOptimizer(interface, \n", - " settings, \n", - " constraint_obj)\n", - " \n", + " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", + "\n", " out = op.optimize()\n", "\n", - " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", - " ', Min_gamma_reached =', op.minimumReached())\n", - " if (out is not None):\n", + " print(\n", + " \" Gamma =\",\n", + " None if (out is None) else out.upperBoundGamma(),\n", + " \", Min_gamma_reached =\",\n", + " op.minimumReached(),\n", + " )\n", + " if out is not None:\n", " out.print(simple=True)\n", " else:\n", " print(out)\n", - " \n", - " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')\n" + "\n", + " print(\n", + " \"Subcircuits:\",\n", + " interface.exportSubcircuitsAsString(name_mapping=\"default\"),\n", + " \"\\n\",\n", + " )" ] }, { @@ -167,6 +173,7 @@ ], "source": [ "from qiskit import QuantumCircuit\n", + "\n", "qc_0 = QuantumCircuit(7)\n", "for i in range(7):\n", " qc_0.rx(np.pi / 4, i)\n", @@ -244,40 +251,44 @@ "source": [ "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", "\n", - "circuit_ckt_wirecut=QCtoCCOCircuit(qc_0)\n", - "\n", - "settings = OptimizationSettings(rand_seed = 12345)\n", + "circuit_ckt_wirecut = QCtoCCOCircuit(qc_0)\n", "\n", - "settings.setEngineSelection('CutOptimization', 'BestFirst')\n", + "settings = OptimizationSettings(rand_seed=12345)\n", "\n", - "qubits_per_QPU=7\n", - "num_QPUs=2\n", + "settings.setEngineSelection(\"CutOptimization\", \"BestFirst\")\n", "\n", + "qubits_per_QPU = 7\n", + "num_QPUs = 2\n", "\n", "\n", "for num_qpus in range(num_QPUs, 1, -1):\n", " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", - " print(f'\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------')\n", - " \n", - " constraint_obj = DeviceConstraints(qubits_per_QPU = qpu_qubits, \n", - " num_QPUs = num_QPUs)\n", + " print(f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------\")\n", + "\n", + " constraint_obj = DeviceConstraints(qubits_per_QPU=qpu_qubits, num_QPUs=num_QPUs)\n", "\n", " interface = SimpleGateList(circuit_ckt_wirecut)\n", - " \n", - " op = LOCutsOptimizer(interface, \n", - " settings, \n", - " constraint_obj)\n", - " \n", + "\n", + " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", + "\n", " out = op.optimize()\n", "\n", - " print(' Gamma =', None if (out is None) else out.upperBoundGamma(),\n", - " ', Min_gamma_reached =', op.minimumReached())\n", - " if (out is not None):\n", + " print(\n", + " \" Gamma =\",\n", + " None if (out is None) else out.upperBoundGamma(),\n", + " \", Min_gamma_reached =\",\n", + " op.minimumReached(),\n", + " )\n", + " if out is not None:\n", " out.print(simple=True)\n", " else:\n", " print(out)\n", "\n", - " print('Subcircuits:', interface.exportSubcircuitsAsString(name_mapping='default'),'\\n')" + " print(\n", + " \"Subcircuits:\",\n", + " interface.exportSubcircuitsAsString(name_mapping=\"default\"),\n", + " \"\\n\",\n", + " )" ] } ], diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 3381e0ec9..bb80f5e33 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -1,9 +1,16 @@ from pytest import fixture from numpy import inf -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + SimpleGateList, + CircuitElement, +) from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization -from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings -from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints +from circuit_knitting.cutting.cut_finding.optimization_settings import ( + OptimizationSettings, +) +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( + DeviceConstraints, +) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( PrintActionListWithNames, ) @@ -12,33 +19,33 @@ @fixture def testCircuit(): circuit = [ - ("cx", 0, 1), - ("cx", 0, 2), - ("cx", 1, 2), - ("cx", 0, 3), - ("cx", 1, 3), - ("cx", 2, 3), - ("cx", 4, 5), - ("cx", 4, 6), - ("cx", 5, 6), - ("cx", 4, 7), - ("cx", 5, 7), - ("cx", 6, 7), - ("cx", 3, 4), - ("cx", 3, 5), - ("cx", 3, 6), - ("cx", 0, 1), - ("cx", 0, 2), - ("cx", 1, 2), - ("cx", 0, 3), - ("cx", 1, 3), - ("cx", 2, 3), - ("cx", 4, 5), - ("cx", 4, 6), - ("cx", 5, 6), - ("cx", 4, 7), - ("cx", 5, 7), - ("cx", 6, 7), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 5], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 6], gamma=3), + CircuitElement(name="cx", params=[], qubits=[5, 6], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 7], gamma=3), + CircuitElement(name="cx", params=[], qubits=[5, 7], gamma=3), + CircuitElement(name="cx", params=[], qubits=[6, 7], gamma=3), + CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), + CircuitElement(name="cx", params=[], qubits=[3, 5], gamma=3), + CircuitElement(name="cx", params=[], qubits=[3, 6], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 5], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 6], gamma=3), + CircuitElement(name="cx", params=[], qubits=[5, 6], gamma=3), + CircuitElement(name="cx", params=[], qubits=[4, 7], gamma=3), + CircuitElement(name="cx", params=[], qubits=[5, 7], gamma=3), + CircuitElement(name="cx", params=[], qubits=[6, 7], gamma=3), ] interface = SimpleGateList(circuit) return interface @@ -55,22 +62,38 @@ def test_BestFirstSearch(testCircuit): out, _ = op.optimizationPass() - assert op.search_engine.getStats(penultimate = True) is not None + assert op.search_engine.getStats(penultimate=True) is not None assert op.search_engine.getStats() is not None assert op.getUpperBoundCost() == (27, inf) - assert op.minimumReached() == False + assert op.minimumReached() is False assert out is not None - assert (out.lowerBoundGamma(), out.gamma_UB, out.getMaxWidth()) == (15, 27, 4) + assert (out.lowerBoundGamma(), out.gamma_UB, out.getMaxWidth()) == ( + 27, + 27, + 4, + ) # lower and upper bounds are the same in the absence of LOCC. assert PrintActionListWithNames(out.actions) == [ - ["CutTwoQubitGate", [12, ["cx", 3, 4], None], ((1, 3), (2, 4))], - ["CutTwoQubitGate", [13, ["cx", 3, 5], None], ((1, 3), (2, 5))], - ["CutTwoQubitGate", [14, ["cx", 3, 6], None], ((1, 3), (2, 6))], + [ + "CutTwoQubitGate", + [12, CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), None], + ((1, 3), (2, 4)), + ], + [ + "CutTwoQubitGate", + [13, CircuitElement(name="cx", params=[], qubits=[3, 5], gamma=3), None], + ((1, 3), (2, 5)), + ], + [ + "CutTwoQubitGate", + [14, CircuitElement(name="cx", params=[], qubits=[3, 6], gamma=3), None], + ((1, 3), (2, 6)), + ], ] out, _ = op.optimizationPass() - assert op.search_engine.getStats(penultimate = True) is not None + assert op.search_engine.getStats(penultimate=True) is not None assert op.search_engine.getStats() is not None assert op.getUpperBoundCost() == (27, inf) - assert op.minimumReached() == True + assert op.minimumReached() is True assert out is None diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index 7ae37654b..5e955939a 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -4,7 +4,10 @@ from qiskit import QuantumCircuit, QuantumRegister from qiskit.circuit import Qubit, Instruction, CircuitInstruction from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit, CCOtoQCCircuit -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList, CircuitElement +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + SimpleGateList, + CircuitElement, +) # test circuit 1. tc_1 = QuantumCircuit(2) @@ -23,13 +26,13 @@ @fixture def InternalTestCircuit(): circuit = [ - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), - CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), - CircuitElement(name='h', params=[], qubits=[0], gamma=None), - CircuitElement(name='rx', params=[0.4], qubits=[0], gamma=None), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="h", params=[], qubits=[0], gamma=None), + CircuitElement(name="rx", params=[0.4], qubits=[0], gamma=None), ] interface = SimpleGateList(circuit) interface.insertGateCut(2, "LO") @@ -40,8 +43,16 @@ def InternalTestCircuit(): @pytest.mark.parametrize( "test_circuit, known_output", [ - (tc_1, [CircuitElement("h", [], [1], None), CircuitElement("barrier",[], [1], None), - CircuitElement("s",[], [0], None), "barrier", CircuitElement("cx", [], [1, 0], 3)]), + ( + tc_1, + [ + CircuitElement("h", [], [1], None), + CircuitElement("barrier", [], [1], None), + CircuitElement("s", [], [0], None), + "barrier", + CircuitElement("cx", [], [1, 0], 3), + ], + ), ( tc_2, [ @@ -54,7 +65,7 @@ def InternalTestCircuit(): CircuitElement("rz", [0.4], [0], None), CircuitElement("ry", [0.4], [1], None), CircuitElement("rz", [0.4], [1], None), - CircuitElement("cx", [],[0, 1], 3), + CircuitElement("cx", [], [0, 1], 3), CircuitElement("ry", [0.4], [0], None), CircuitElement("rz", [0.4], [0], None), CircuitElement("ry", [0.4], [1], None), @@ -67,6 +78,7 @@ def test_QCtoCCOCircuit(test_circuit, known_output): test_circuit_internal = QCtoCCOCircuit(test_circuit) assert test_circuit_internal == known_output + def test_CCOtoQCCircuit(InternalTestCircuit): qc_cut = CCOtoQCCircuit(InternalTestCircuit) assert qc_cut.data == [ diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 7c8a2e957..c2cc4fad8 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -1,4 +1,7 @@ -from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement, SimpleGateList +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + CircuitElement, + SimpleGateList, +) class TestCircuitInterface: @@ -7,38 +10,39 @@ def test_CircuitConversion(self): used by the circuit-cutting optimizer. """ - #Assign gamma=None to single qubit gates. + # Assign gamma=None to single qubit gates. trial_circuit = [ CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), - CircuitElement(name="barrier",params=[], qubits= ["q1"], gamma=None), - CircuitElement(name="s", params=[], qubits = ["q0"], gamma = None), + CircuitElement(name="barrier", params=[], qubits=["q1"], gamma=None), + CircuitElement(name="s", params=[], qubits=["q0"], gamma=None), "barrier", - CircuitElement(name="cx", params=[], qubits = ["q1", "q0"], gamma = 3), + CircuitElement(name="cx", params=[], qubits=["q1", "q0"], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) assert circuit_converted.getNumQubits() == 2 assert circuit_converted.getNumWires() == 2 assert circuit_converted.qubit_names.item_dict == {"q1": 0, "q0": 1} - assert circuit_converted.getMultiQubitGates() == [[4, CircuitElement(name="cx", params=[], - qubits = [0, 1], gamma = 3) , None]] + assert circuit_converted.getMultiQubitGates() == [ + [4, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None] + ] assert circuit_converted.circuit == [ [CircuitElement(name="h", params=[], qubits=[0], gamma=None), None], - [CircuitElement(name="barrier",params=[], qubits= [0], gamma=None), None], - [CircuitElement(name="s", params=[], qubits = [1], gamma = None), None], + [CircuitElement(name="barrier", params=[], qubits=[0], gamma=None), None], + [CircuitElement(name="s", params=[], qubits=[1], gamma=None), None], ["barrier", None], - [CircuitElement(name="cx", params=[], qubits = [0, 1], gamma = 3), None] + [CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], ] def test_GateCutInterface(self): """Test the internal representation of LO gate cuts.""" - trial_circuit=[ - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), - CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + trial_circuit = [ + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) circuit_converted.insertGateCut(2, "LO") @@ -56,7 +60,7 @@ def test_GateCutInterface(self): trial_circuit[2], trial_circuit[3], trial_circuit[4], - ] + ] # the following two methods are the same in the absence of wire cuts. assert ( @@ -68,12 +72,12 @@ def test_GateCutInterface(self): def test_WireCutInterface(self): """Test the internal representation of LO wire cuts.""" - trial_circuit=[ - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), - CircuitElement(name='cx', params=[], qubits=[1,2], gamma=3), - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), + trial_circuit = [ + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) circuit_converted.insertWireCut( @@ -89,9 +93,9 @@ def test_WireCutInterface(self): assert circuit_converted.exportCutCircuit(name_mapping=None) == [ trial_circuit[0], trial_circuit[1], - ['move', 1, 4], - CircuitElement(name='cx', params=[], qubits=[("cut", 1), 2], gamma=3), - CircuitElement(name='cx', params=[], qubits=[0, ("cut", 1)], gamma=3), + ["move", 1, 4], + CircuitElement(name="cx", params=[], qubits=[("cut", 1), 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, ("cut", 1)], gamma=3), trial_circuit[4], ] @@ -112,12 +116,10 @@ def test_WireCutInterface(self): } assert circuit_converted.exportCutCircuit(name_mapping="default") == [ - CircuitElement(name='cx', params=[], qubits=[0,1], gamma=3), - CircuitElement(name='cx', params=[], qubits=[3,4], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), ["move", 1, 4], - CircuitElement(name='cx', params=[], qubits=[2,3], gamma=3), - CircuitElement(name='cx', params=[], qubits=[0,2], gamma=3), - CircuitElement(name='cx', params=[], qubits=[3,4], gamma=3), + CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), + CircuitElement(name="cx", params=[], qubits=[0, 2], gamma=3), + CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), ] - - diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 8288c1520..0afc42a84 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -5,8 +5,12 @@ from qiskit.circuit.library import EfficientSU2 from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList -from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings -from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints +from circuit_knitting.cutting.cut_finding.optimization_settings import ( + OptimizationSettings, +) +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( + DeviceConstraints, +) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( PrintActionListWithNames, ) @@ -57,7 +61,7 @@ def test_no_cuts(gate_cut_test_setup): print(optimization_pass.best_result) - assert PrintActionListWithNames(output.actions) == [] #no cutting. + assert PrintActionListWithNames(output.actions) == [] # no cutting. assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" @@ -85,7 +89,7 @@ def test_GateCuts(gate_cut_test_setup): assert output.upperBoundGamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. - assert optimization_pass.minimumReached() == True # matches optimal solution. + assert optimization_pass.minimumReached() is True # matches optimal solution. assert ( interface.exportSubcircuitsAsString(name_mapping="default") == "AABB" @@ -122,7 +126,7 @@ def test_WireCuts(wire_cut_test_setup): assert output.upperBoundGamma() == best_result.gamma_UB == 4 # One LO wire cut. - assert optimization_pass.minimumReached() == True # matches optimal solution + assert optimization_pass.minimumReached() is True # matches optimal solution def test_selectSearchEngine(gate_cut_test_setup): diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 39fbf3f62..0f273f57b 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -36,7 +36,7 @@ def test_ActionApplyGate(testCircuit): _, state, two_qubit_gate = testCircuit apply_gate = ActionApplyGate() - assert apply_gate.getName() == None + assert apply_gate.getName() is None assert apply_gate.getGroupNames() == [None, "TwoQubitGates"] updated_state = apply_gate.nextStatePrimitive(state, two_qubit_gate, 2) @@ -110,6 +110,6 @@ def test_DefinedActions(): # Check that unsupported cutting actions return None # when the action or corresponding group is requested. - assert ActionNames().getAction("LOCCGateCut") == None + assert ActionNames().getAction("LOCCGateCut") is None - assert ActionNames().getGroup("LOCCCUTS") == None + assert ActionNames().getGroup("LOCCCUTS") is None diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 1fd733bab..25368fc82 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -8,8 +8,6 @@ ) - - @mark.parametrize("num_qubits, max_wire_cuts", [(2.1, 1.2), (None, -1), (-1, None)]) def test_StateInitialization(num_qubits, max_wire_cuts): """Test device constraints for being valid data types.""" @@ -93,7 +91,7 @@ def test_CutGate(testCircuit): assert list(next_state.wiremap) == [0, 1] - assert next_state.checkDoNotMergeRoots(0, 1) == True + assert next_state.checkDoNotMergeRoots(0, 1) is True assert next_state.num_wires == 2 @@ -132,15 +130,15 @@ def test_CutLeftWire(testCircuit): assert state.getNumQubits() == 2 - assert next_state.canExpandSubcircuit(1, 1, 2) == False + assert next_state.canExpandSubcircuit(1, 1, 2) is False - assert next_state.canExpandSubcircuit(1, 1, 3) == True + assert next_state.canExpandSubcircuit(1, 1, 3) is True - assert next_state.canAddWires(2) == False + assert next_state.canAddWires(2) is False assert next_state.getWireRootMapping() == [0, 1, 1] - assert next_state.checkDoNotMergeRoots(0, 1) == True + assert next_state.checkDoNotMergeRoots(0, 1) is True assert list(next_state.uptree) == [0, 1, 1, 3] @@ -175,11 +173,11 @@ def test_CutRightWire(testCircuit): assert state.getNumQubits() == 2 - assert next_state.canAddWires(1) == True + assert next_state.canAddWires(1) is True assert next_state.getWireRootMapping() == [0, 1, 0] - assert next_state.checkDoNotMergeRoots(0, 1) == True + assert next_state.checkDoNotMergeRoots(0, 1) is True assert list(next_state.uptree) == [0, 1, 0, 3] @@ -201,7 +199,7 @@ def test_CutBothWires(testCircuit): assert list(next_state.wiremap) == [2, 3] - assert next_state.canAddWires(1) == False + assert next_state.canAddWires(1) is False assert next_state.num_wires == 4 @@ -212,7 +210,7 @@ def test_CutBothWires(testCircuit): assert ( next_state.checkDoNotMergeRoots(0, 2) == next_state.checkDoNotMergeRoots(1, 2) - == True + is True ) assert list(next_state.uptree) == [0, 1, 2, 2] @@ -233,4 +231,4 @@ def test_CutBothWires(testCircuit): assert next_state.upperBoundGamma() == 16 # 4^n scaling. - assert next_state.verifyMergeConstraints() == True + assert next_state.verifyMergeConstraints() is True diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index 38eb01705..ebcc47699 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -1,5 +1,7 @@ import pytest -from circuit_knitting.cutting.cut_finding.optimization_settings import OptimizationSettings +from circuit_knitting.cutting.cut_finding.optimization_settings import ( + OptimizationSettings, +) @pytest.mark.parametrize( @@ -17,8 +19,8 @@ def test_GateCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): """Test default gate cut types.""" op = OptimizationSettings() op.setGateCutTypes() - assert op.gate_cut_LO == True - assert op.gate_cut_LOCC_with_ancillas == False + assert op.gate_cut_LO is True + assert op.gate_cut_LOCC_with_ancillas is False def test_WireCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): @@ -26,8 +28,8 @@ def test_WireCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): op = OptimizationSettings() op.setWireCutTypes() assert op.wire_cut_LO - assert op.wire_cut_LOCC_with_ancillas == False - assert op.wire_cut_LOCC_no_ancillas == False + assert op.wire_cut_LOCC_with_ancillas is False + assert op.wire_cut_LOCC_no_ancillas is False def test_AllCutSearchGroups(): diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index 9c28bad99..282286bbd 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -1,10 +1,10 @@ import pytest -from circuit_knitting.cutting.cut_finding.quantum_device_constraints import DeviceConstraints +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( + DeviceConstraints, +) -@pytest.mark.parametrize( - "qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)] -) +@pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)]) def test_DeviceConstraints(qubits_per_QPU, num_QPUs): """Test device constraints for being valid data types.""" From 19c78f2481d19c6d3f7f2d63f017ab76e72bb89a Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 1 Feb 2024 13:47:51 -0500 Subject: [PATCH 068/128] Finish making all tests consistent with new circuit interface --- .../cutting/cut_finding/__init__.py | 1 + .../cutting/cut_finding/circuit_interface.py | 14 ++++----- .../cut_finding/disjoint_subcircuits_state.py | 6 ++-- circuit_knitting/cutting/cut_finding/utils.py | 2 +- .../cut_finding/test_cut_finder_roundtrip.py | 20 ++++++++++-- .../cut_finding/test_cutting_actions.py | 31 +++++++++++++------ .../test_disjoint_subcircuits_state.py | 27 ++++++++-------- 7 files changed, 64 insertions(+), 37 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index e69de29bb..b9765124b 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -0,0 +1 @@ +from .cut_finding import find_cuts \ No newline at end of file diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 78424857c..d23b3197e 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -166,7 +166,7 @@ class SimpleGateList(CircuitInterface): wire IDs defines a subcircuit. """ - circuit: list[CircuitElement | None] + circuit: list[CircuitElement | str | None] new_circuit: list[CircuitElement] cut_type: str | None qubit_names: NameToIDMap @@ -214,7 +214,7 @@ def getNumWires(self) -> int: return self.qubit_names.getNumItems() - def getMultiQubitGates(self) -> list[int | CircuitElement]: + def getMultiQubitGates(self) -> list[int | CircuitElement | str | None]: """Extract the multiqubit gates from the circuit and prepends the index of the gate in the circuits to the gate specification. @@ -297,7 +297,7 @@ def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: self.subcircuits = list_of_list_of_wires - def getWireNames(self) -> list[str | tuple[str, str]]: + def getWireNames(self) -> list[Hashable]: """Return a list of the internal wire names used in the circuit, which consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. @@ -355,7 +355,7 @@ def exportSubcircuitsAsString(self, name_mapping: str = "default") -> str: out[wire_map[wire]] = alphabet[k] return "".join(out) - def makeWireMapping(self, name_mapping: None | str) -> list: + def makeWireMapping(self, name_mapping: None | str) -> list[Hashable | int]: """Return a wire-mapping list given an input specification of a name mapping. If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. If "default" @@ -429,8 +429,8 @@ class NameToIDMap: """ next_ID: int - item_dict: dict[Hashable, int] - ID_dict: dict[int, Hashable] + item_dict: dict[Hashable] + ID_dict: dict[Hashable] def __init__(self, init_names: list[Hashable]): """Allow the name dictionary to be initialized with the names @@ -460,7 +460,7 @@ def getID(self, item_name: Hashable) -> int: return self.item_dict[item_name] - def defineID(self, item_ID: int, item_name: Hashable): + def defineID(self, item_ID: int, item_name: Hashable) -> None: """Assign a specific ID number to an item name.""" assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index f9ef244ce..db8eca837 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -86,7 +86,7 @@ class DisjointSubcircuitsState: """ def __init__(self, num_qubits=None, max_wire_cuts=None): - """A DisjointSubcircuitsState object must be initialized with + """An instance of :class:`DisjointSubcircuitsState` must be initialized with a specification of the number of qubits in the circuit and the maximum number of wire cuts that can be performed.""" @@ -266,14 +266,14 @@ def upperBoundGamma(self): return self.gamma_UB - def canAddWires(self, num_wires): + def canAddWires(self, num_wires: int) -> bool: """Return True if an additional num_wires can be cut without exceeding the maximum allowed number of wire cuts. """ return self.num_wires + num_wires <= self.uptree.shape[0] - def canExpandSubcircuit(self, root, num_wires, max_width): + def canExpandSubcircuit(self, root: int, num_wires: int, max_width: int) -> bool: """Return True if num_wires can be added to subcircuit root without exceeding the maximum allowed number of qubits. """ diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/utils.py index 31363e457..1d9b6ee1e 100644 --- a/circuit_knitting/cutting/cut_finding/utils.py +++ b/circuit_knitting/cutting/cut_finding/utils.py @@ -103,7 +103,7 @@ def selectSearchEngine( ) else: - assert False, f"Invalid stage_of_optimization {stage_of_optimization}" + raise ValueError(f"Search engine {engine} is not supported.") def greedyBestFirstSearch(state, search_space_funcs, *args): diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 0afc42a84..58659feb7 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -4,7 +4,10 @@ from qiskit import QuantumCircuit from qiskit.circuit.library import EfficientSU2 from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + SimpleGateList, + CircuitElement, +) from circuit_knitting.cutting.cut_finding.optimization_settings import ( OptimizationSettings, ) @@ -82,7 +85,13 @@ def test_GateCuts(gate_cut_test_setup): cut_actions_list = output.CutActionsList() assert cut_actions_list == [ - {"Cut action": "CutTwoQubitGate", "Cut Gate": [9, ["cx", 1, 2]]} + { + "Cut action": "CutTwoQubitGate", + "Cut Gate": [ + 9, + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), + ], + } ] best_result = optimization_pass.getResults() @@ -117,7 +126,12 @@ def test_WireCuts(wire_cut_test_setup): assert cut_actions_list == [ { "Cut action": "CutLeftWire", - "Cut location:": {"Gate": [10, ["cx", 3, 4]]}, + "Cut location:": { + "Gate": [ + 10, + CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), + ] + }, "Input wire": 1, } ] diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 0f273f57b..4eaf5e9f9 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -1,5 +1,8 @@ from pytest import fixture -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + CircuitElement, + SimpleGateList, +) from circuit_knitting.cutting.cut_finding.cutting_actions import ( ActionApplyGate, ActionCutTwoQubitGate, @@ -16,9 +19,9 @@ @fixture def testCircuit(): circuit = [ - ("h", "q1"), - ("s", "q0"), - ("cx", "q1", "q0"), + CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), + CircuitElement(name="s", params=[], qubits=["q0"], gamma=None), + CircuitElement(name="cx", params=[], qubits=["q1", "q0"], gamma=3), ] interface = SimpleGateList(circuit) @@ -59,14 +62,18 @@ def test_CutTwoQubitGate(testCircuit): for state in updated_state: actions_list.extend(PrintActionListWithNames(state.actions)) assert actions_list == [ - ["CutTwoQubitGate", [2, ["cx", 0, 1], None], ((1, 0), (2, 1))] + [ + "CutTwoQubitGate", + [2, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], + ((1, 0), (2, 1)), + ] ] assert cut_gate.getCostParams(two_qubit_gate) == ( - 1, - 1, 3, - ) # check if reproduces the parameters for a CNOT. + 0, + 3, + ) # reproduces the parameters for a CNOT when only LO is enabled. cut_gate.exportCuts( interface, None, two_qubit_gate, None @@ -86,7 +93,9 @@ def test_CutLeftWire(testCircuit): for state in updated_state: actions_list.extend(PrintActionListWithNames(state.actions)) assert actions_list[0][0] == "CutLeftWire" - assert actions_list[0][1][1] == ["cx", 0, 1] + assert actions_list[0][1][1] == CircuitElement( + name="cx", params=[], qubits=[0, 1], gamma=3 + ) assert actions_list[0][2][0][0] == 1 # the first input ('left') wire is cut. @@ -102,7 +111,9 @@ def test_CutRightWire(testCircuit): for state in updated_state: actions_list.extend(PrintActionListWithNames(state.actions)) assert actions_list[0][0] == "CutRightWire" - assert actions_list[0][1][1] == ["cx", 0, 1] + assert actions_list[0][1][1] == CircuitElement( + name="cx", params=[], qubits=[0, 1], gamma=3 + ) assert actions_list[0][2][0][0] == 2 # the second input ('right') wire is cut diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 25368fc82..87fa6d85b 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -1,11 +1,14 @@ from pytest import mark, raises, fixture -from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( DisjointSubcircuitsState, ) from circuit_knitting.cutting.cut_finding.cut_optimization import ( disjoint_subcircuit_actions, ) +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + SimpleGateList, + CircuitElement, +) @mark.parametrize("num_qubits, max_wire_cuts", [(2.1, 1.2), (None, -1), (-1, None)]) @@ -19,11 +22,11 @@ def test_StateInitialization(num_qubits, max_wire_cuts): @fixture def testCircuit(): circuit = [ - ("h", "q1"), - ("barrier", "q1"), - ("s", "q0"), + CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), + CircuitElement(name="barrier", params=[], qubits=["q1"], gamma=None), + CircuitElement(name="s", params=[], qubits=["q0"], gamma=None), "barrier", - ("cx", "q1", "q0"), + CircuitElement(name="cx", params=[], qubits=["q1", "q0"], gamma=3), ] interface = SimpleGateList(circuit) @@ -53,10 +56,6 @@ def test_StateUncut(testCircuit): assert state.getSearchLevel() == 0 - # print_output = test_prints(state.print(simple=True)) - - # assert print_output == [] - def test_ApplyGate(testCircuit): state, two_qubit_gate = testCircuit @@ -130,9 +129,9 @@ def test_CutLeftWire(testCircuit): assert state.getNumQubits() == 2 - assert next_state.canExpandSubcircuit(1, 1, 2) is False + assert not next_state.canExpandSubcircuit(1, 1, 2) # False - assert next_state.canExpandSubcircuit(1, 1, 3) is True + assert next_state.canExpandSubcircuit(1, 1, 3) # True assert next_state.canAddWires(2) is False @@ -227,8 +226,10 @@ def test_CutBothWires(testCircuit): assert next_state.getSearchLevel() == 1 - assert next_state.lowerBoundGamma() == 9 # 3^n scaling. + assert ( + next_state.lowerBoundGamma() == 9 + ) # The 3^n scaling which is possible with LOCC. - assert next_state.upperBoundGamma() == 16 # 4^n scaling. + assert next_state.upperBoundGamma() == 16 # The 4^n scaling that comes with LO. assert next_state.verifyMergeConstraints() is True From 5e55d84780287357cbba5a425373db9104eecf5e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 5 Feb 2024 10:54:36 -0500 Subject: [PATCH 069/128] Add and update tests --- .../cutting/cut_finding/best_first_search.py | 6 +- .../cut_finding/{utils.py => cco_utils.py} | 0 .../cutting/cut_finding/circuit_interface.py | 2 +- .../cutting/cut_finding/cut_finding.py | 2 +- .../cutting/cut_finding/cut_optimization.py | 8 +- .../cutting/cut_finding/cutting_actions.py | 32 ++++--- .../cut_finding/disjoint_subcircuits_state.py | 2 +- .../cutting/cut_finding/lo_cuts_optimizer.py | 3 +- .../cut_finding/search_space_generator.py | 8 +- .../tutorials/LO_circuit_cut_finder.ipynb | 4 +- test/cutting/cut_finding/test_cco_utils.py | 5 +- .../cut_finding/test_circuit_interfaces.py | 17 +++- .../cut_finding/test_cut_finder_roundtrip.py | 86 +++++++++++++++++-- .../cut_finding/test_optimization_settings.py | 2 +- 14 files changed, 137 insertions(+), 40 deletions(-) rename circuit_knitting/cutting/cut_finding/{utils.py => cco_utils.py} (100%) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index eea25f5cd..da73ee0e8 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -83,7 +83,7 @@ def get(self): None, None, None is returned if the priority queue is empty. """ - if self.qsize() == 0: + if self.qsize() == 0: # pragma: no cover return None, None, None best = heapq.heappop(self.pqueue) @@ -313,7 +313,7 @@ def getUpperBoundCost(self): return self.upperbound_cost - def updateUpperBoundCost(self, cost_bound): + def updateUpperBoundCost(self, cost_bound: tuple) -> None: """Update the cost upper bound based on an input cost bound. """ @@ -330,7 +330,7 @@ def updateUpperBoundGoalState(self, goal_state, *args): if self.upperbound_cost_func is not None: bound = self.upperbound_cost_func(goal_state, *args) - else: + else: # pragma: no cover bound = self.cost_func(goal_state, *args) if self.upperbound_cost is None or bound < self.upperbound_cost: diff --git a/circuit_knitting/cutting/cut_finding/utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py similarity index 100% rename from circuit_knitting/cutting/cut_finding/utils.py rename to circuit_knitting/cutting/cut_finding/cco_utils.py diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index d23b3197e..38304c46d 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -493,7 +493,7 @@ def getArraySizeNeeded(self) -> int: array that maps item IDs to other values. """ - if self.getNumItems() <= 0: + if self.getNumItems() == 0: # pragma: no cover return 0 return 1 + max(self.ID_dict.keys()) diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 13f6005da..e4d74583b 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -20,7 +20,7 @@ from .quantum_device_constraints import DeviceConstraints from .circuit_interface import SimpleGateList from .lo_cuts_optimizer import LOCutsOptimizer -from .utils import QCtoCCOCircuit +from .cco_utils import QCtoCCOCircuit from ..instructions import CutWire from ..cutting_decomposition import cut_gates diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 2eb97a9fe..504e925af 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -12,7 +12,7 @@ """Classes required to search for optimal cut locations.""" import numpy as np -from .utils import selectSearchEngine, greedyBestFirstSearch +from .cco_utils import selectSearchEngine, greedyBestFirstSearch from .cutting_actions import disjoint_subcircuit_actions from .search_space_generator import ( getActionSubset, @@ -54,7 +54,7 @@ def CutOptimizationUpperBoundCostFunc(goal_state, func_args): def CutOptimizationMinCostBoundFunc(func_args): """Return an a priori min-cost bound defined in the optimization settings.""" - if func_args.max_gamma is None: + if func_args.max_gamma is None: # pragma: no cover return None return (func_args.max_gamma, np.inf) @@ -221,7 +221,7 @@ def __init__( mwc = maxWireCutsGamma(self.greedy_goal_state.upperBoundGamma()) max_wire_cuts = min(max_wire_cuts, mwc) - elif self.func_args.max_gamma is not None: + elif self.func_args.max_gamma is not None: # pragma: no cover mwc = maxWireCutsGamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) @@ -249,7 +249,7 @@ def optimizationPass(self): """Produce, at each call, a goal state representing a distinct set of cutting decisions. None is returned once no additional choices of cuts can be made without exceeding the minimum upper bound across - all cutting decisions previously returned and the optimization settings. + all cutting decisions previously returned, given the optimization settings. """ state, cost = self.search_engine.optimizationPass(self.func_args) if state is None and not self.goal_state_returned: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 3d4619111..b21211b09 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -125,9 +125,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): ActionCutTwoQubitGate to state given the gate_spec. """ - # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1].qubits) != 2: - return list() + # Cutting of multi-qubit gates is not supported in this version. + if len(gate_spec[1].qubits) != 2: # pragma: no cover + raise ValueError( + "At present, only the cutting of two qubit gates is supported." + ) gamma_LB, num_bell_pairs, gamma_UB = self.getCostParams(gate_spec) @@ -206,9 +208,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): ActionCutLeftWire to state given the gate_spec. """ - # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1].qubits) != 2: - return list() + # Cutting of multi-qubit gates is not supported in this version. + if len(gate_spec[1].qubits) != 2: # pragma: no cover + raise ValueError( + "At present, only the cutting of two qubit gates is supported." + ) # If the wire-cut limit would be exceeded, return the empty list if not state.canAddWires(1): @@ -283,9 +287,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): ActionCutRightWire to state given the gate_spec. """ - # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1].qubits) != 2: - return list() + # Cutting of multi-qubit gates is not supported in this version. + if len(gate_spec[1].qubits) != 2: # pragma: no cover + raise ValueError( + "At present, only the cutting of two qubit gates is supported." + ) # If the wire-cut limit would be exceeded, return the empty list if not state.canAddWires(1): @@ -349,9 +355,11 @@ def nextStatePrimitive(self, state, gate_spec, max_width): ActionCutBothWires to state given the gate_spec. """ - # If the gate is not a two-qubit gate, then return the empty list - if len(gate_spec[1].qubits) != 2: - return list() + # Cutting of multi-qubit gates is not supported in this version. + if len(gate_spec[1].qubits) != 2: # pragma: no cover + raise ValueError( + "At present, only the cutting of two qubit gates is supported." + ) # If the wire-cut limit would be exceeded, return the empty list if not state.canAddWires(2): diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index db8eca837..bec8ac20c 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -170,6 +170,7 @@ def CutActionsList(self): cut_actions = PrintActionListWithNames(self.actions) # Output formatting for LO gate and wire cuts. + # TODO: Change to NamedTuples. for i in range(len(cut_actions)): if (cut_actions[i][0] == "CutLeftWire") or ( cut_actions[i][0] == "CutRightWire" @@ -453,5 +454,4 @@ def PrintActionListWithNames(action_list): in DisjointSubcircuitsState objects with the corresponding action names for readability, and print. """ - return [[x[0].getName()] + x[1:] for x in action_list] diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index db6bfcf16..f2a368b87 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -131,7 +131,6 @@ def optimize( assert self.device_constraints is not None, "device_constraints cannot be None" - # Perform cut optimization assuming no qubit reuse self.cut_optimization = CutOptimization( self.circuit_interface, self.optimization_settings, @@ -177,7 +176,7 @@ def minimumReached(self): return self.cut_optimization.minimumReached() -def printStateList(state_list): +def printStateList(state_list): #pragma: no cover for x in state_list: print() x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index d75152d0d..f7531cb85 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -16,14 +16,14 @@ from typing import TYPE_CHECKING -if TYPE_CHECKING: - from cut_optimization import CutOptimizationFuncArgs - from .cutting_actions import DisjointSearchAction - from typing import Callable, Iterable from .disjoint_subcircuits_state import DisjointSubcircuitsState +if TYPE_CHECKING: #pragma: no cover + from cut_optimization import CutOptimizationFuncArgs + from .cutting_actions import DisjointSearchAction + class ActionNames: diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 44bf5ad7a..884acf75d 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -50,7 +50,7 @@ ], "source": [ "from qiskit.circuit.library import EfficientSU2\n", - "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit\n", "\n", "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", @@ -249,7 +249,7 @@ } ], "source": [ - "from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit\n", "\n", "circuit_ckt_wirecut = QCtoCCOCircuit(qc_0)\n", "\n", diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index 5e955939a..e42f3697f 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -3,7 +3,10 @@ from qiskit.circuit.library import EfficientSU2 from qiskit import QuantumCircuit, QuantumRegister from qiskit.circuit import Qubit, Instruction, CircuitInstruction -from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit, CCOtoQCCircuit +from circuit_knitting.cutting.cut_finding.cco_utils import ( + QCtoCCOCircuit, + CCOtoQCCircuit, +) from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, CircuitElement, diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index c2cc4fad8..0d9e3825c 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -18,7 +18,11 @@ def test_CircuitConversion(self): "barrier", CircuitElement(name="cx", params=[], qubits=["q1", "q0"], gamma=3), ] - circuit_converted = SimpleGateList(trial_circuit) + circuit_converted = SimpleGateList( + trial_circuit + ) # When init_qubit_names is initialized to [], the first qubit that + # appears in the first gate in the list that specifies the circuit + # is assigned ID 0. assert circuit_converted.getNumQubits() == 2 assert circuit_converted.getNumWires() == 2 @@ -34,6 +38,17 @@ def test_CircuitConversion(self): [CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], ] + # Assign by hand a different qubit mapping by specifiying init_qubit_names. + circuit_converted = SimpleGateList(trial_circuit, ["q0", "q1"]) + assert circuit_converted.qubit_names.item_dict == {"q0": 0, "q1": 1} + assert circuit_converted.circuit == [ + [CircuitElement(name="h", params=[], qubits=[1], gamma=None), None], + [CircuitElement(name="barrier", params=[], qubits=[1], gamma=None), None], + [CircuitElement(name="s", params=[], qubits=[0], gamma=None), None], + ["barrier", None], + [CircuitElement(name="cx", params=[], qubits=[1, 0], gamma=3), None], + ] + def test_GateCutInterface(self): """Test the internal representation of LO gate cuts.""" diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 58659feb7..60d177ef4 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -3,7 +3,7 @@ from pytest import fixture, raises from qiskit import QuantumCircuit from qiskit.circuit.library import EfficientSU2 -from circuit_knitting.cutting.cut_finding.utils import QCtoCCOCircuit +from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, CircuitElement, @@ -16,8 +16,19 @@ ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( PrintActionListWithNames, + DisjointSubcircuitsState, ) -from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer +from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import ( + LOCutsOptimizer, + cut_optimization_search_funcs, +) +from circuit_knitting.cutting.cut_finding.cut_optimization import ( + CutOptimizationFuncArgs, +) +from circuit_knitting.cutting.cut_finding.cutting_actions import ( + disjoint_subcircuit_actions, +) +from circuit_knitting.cutting.cut_finding.best_first_search import BestFirstSearch @fixture @@ -49,6 +60,17 @@ def wire_cut_test_setup(): return interface, settings +@fixture +def multiqubit_test_setup(): + qc = QuantumCircuit(3) + qc.ccx(0, 1, 2) + circuit_internal = QCtoCCOCircuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(rand_seed=12345) + settings.setEngineSelection("CutOptimization", "BestFirst") + return interface, settings + + def test_no_cuts(gate_cut_test_setup): # QPU with 4 qubits requires no cutting. qubits_per_QPU = 4 @@ -62,8 +84,6 @@ def test_no_cuts(gate_cut_test_setup): output = optimization_pass.optimize(interface, settings, constraint_obj) - print(optimization_pass.best_result) - assert PrintActionListWithNames(output.actions) == [] # no cutting. assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" @@ -143,18 +163,70 @@ def test_WireCuts(wire_cut_test_setup): assert optimization_pass.minimumReached() is True # matches optimal solution -def test_selectSearchEngine(gate_cut_test_setup): +# check if unsupported search engine is flagged. +def test_SelectSearchEngine(gate_cut_test_setup): qubits_per_QPU = 4 num_QPUs = 2 interface, settings = gate_cut_test_setup - # check if unsupported search engine is flagged. settings.setEngineSelection("CutOptimization", "BeamSearch") + search_engine = settings.getEngineSelection("CutOptimization") + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - with raises(ValueError): + with raises(ValueError) as e_info: _ = optimization_pass.optimize() + assert e_info.value.args[0] == f"Search engine {search_engine} is not supported." + + +# The cutting of multiqubit gates is not supported at present. +def test_MultiqubitCuts(multiqubit_test_setup): + # QPU with 2 qubits requires cutting. + qubits_per_QPU = 2 + num_QPUs = 2 + + interface, settings = multiqubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + with raises(ValueError) as e_info: + _ = optimization_pass.optimize() + assert ( + e_info.value.args[0] + == "At present, only the cutting of two qubit gates is supported." + ) + + +def test_UpdatedCostBounds(gate_cut_test_setup): + qubits_per_QPU = 3 + num_QPUs = 2 + + interface, settings = gate_cut_test_setup + + constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + + func_args = CutOptimizationFuncArgs() + func_args.entangling_gates = interface.getMultiQubitGates() + func_args.search_actions = disjoint_subcircuit_actions + func_args.max_gamma = settings.getMaxGamma() + func_args.qpu_width = constraint_obj.getQPUWidth() + state = DisjointSubcircuitsState(interface.getNumQubits(), 2) + bfs = BestFirstSearch(settings, cut_optimization_search_funcs) + bfs.initialize([state], func_args) + + # Perform cut finding with the default cost upper bound. + state, _ = bfs.optimizationPass(func_args) + assert state is not None + + # Update and lower cost upper bound. + bfs.updateUpperBoundCost((2, 4)) + state, _ = bfs.optimizationPass(func_args) + assert ( + state is None + ) # Since any cut has a cost of at least 3, the returned state must be None. diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index ebcc47699..442fbc68d 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -6,7 +6,7 @@ @pytest.mark.parametrize( "max_gamma, max_backjumps ", - [(0, 1), (-1, 0)], + [(0, 1), (-1, 0), (1,-1)], ) def test_OptimizationParameters(max_gamma, max_backjumps): """Test optimization parameters for being valid data types.""" From a57bd91f5d37b24b8f20b8116c473d4843e773a6 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 5 Feb 2024 10:58:06 -0500 Subject: [PATCH 070/128] Add and update tests --- circuit_knitting/cutting/cut_finding/cut_optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 504e925af..866f73c4c 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -221,7 +221,7 @@ def __init__( mwc = maxWireCutsGamma(self.greedy_goal_state.upperBoundGamma()) max_wire_cuts = min(max_wire_cuts, mwc) - elif self.func_args.max_gamma is not None: # pragma: no cover + elif self.func_args.max_gamma is not None: mwc = maxWireCutsGamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) From 5a9c1135b9e5416e50b0f63901b4bb49a6e201de Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 9 Feb 2024 13:19:26 -0500 Subject: [PATCH 071/128] Add type hints, tests, update func names. --- .../cutting/cut_finding/best_first_search.py | 111 +++++++++++---- .../cutting/cut_finding/cco_utils.py | 71 ++++++---- .../cutting/cut_finding/circuit_interface.py | 60 ++++---- .../cutting/cut_finding/cut_finding.py | 4 +- .../cutting/cut_finding/cut_optimization.py | 93 +++++++----- .../cutting/cut_finding/cutting_actions.py | 21 ++- .../cut_finding/disjoint_subcircuits_state.py | 134 +++++++++--------- .../cutting/cut_finding/lo_cuts_optimizer.py | 33 +++-- .../cut_finding/search_space_generator.py | 67 +++++---- .../tutorials/04_automatic_cut_finding.ipynb | 58 +++++--- .../tutorials/LO_circuit_cut_finder.ipynb | 8 +- .../cut_finding/test_best_first_search.py | 6 +- test/cutting/cut_finding/test_cco_utils.py | 14 +- .../cut_finding/test_circuit_interfaces.py | 12 +- .../cut_finding/test_cut_finder_roundtrip.py | 73 +++++----- .../cut_finding/test_cutting_actions.py | 45 ++++-- .../test_disjoint_subcircuits_state.py | 13 +- .../cut_finding/test_optimization_settings.py | 8 +- .../test_quantum_device_constraints.py | 4 +- 19 files changed, 498 insertions(+), 337 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index da73ee0e8..9a278919d 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -11,10 +11,21 @@ """Classes required to implement Dijkstra's (best-first) search algorithm.""" +from __future__ import annotations + import heapq import numpy as np +from typing import TYPE_CHECKING +from numpy import array from itertools import count +from .optimization_settings import OptimizationSettings +from .disjoint_subcircuits_state import DisjointSubcircuitsState +from .search_space_generator import SearchFunctions + +if TYPE_CHECKING: # pragma: no cover + from .cut_optimization import CutOptimizationFuncArgs + class BestFirstPriorityQueue: @@ -55,7 +66,7 @@ class BestFirstPriorityQueue: queue.PriorityQueue if parallelization is ultimately required). """ - def __init__(self, rand_seed): + def __init__(self, rand_seed: int): """A BestFirstPriorityQueue object must be initialized with a specification of a random seed (int) for the pseudo-random number generator. If None is used as the random seed, then a seed is @@ -65,9 +76,14 @@ def __init__(self, rand_seed): self.rand_gen = np.random.default_rng(rand_seed) self.unique = count() - self.pqueue = list() # queue.PriorityQueue() - - def put(self, state, depth, cost): + self.pqueue = list() + + def put( + self, + state: DisjointSubcircuitsState, + depth: int, + cost: int | float | tuple[int | float, int | float], + ) -> None: """Push state onto the priority queue. The search depth and cost of the state must also be provided as input. """ @@ -77,7 +93,14 @@ def put(self, state, depth, cost): (cost, (-depth), self.rand_gen.random(), next(self.unique), state), ) - def get(self): + def get( + self, + ) -> ( + tuple[None, None, None] + | tuple[ + DisjointSubcircuitsState, int, int | float | tuple[int | float, int | float] + ] + ): """Pop and return the lowest cost state currently on the queue, along with the search depth of that state and its cost. None, None, None is returned if the priority queue is empty. @@ -90,12 +113,12 @@ def get(self): return best[-1], (-best[1]), best[0] - def qsize(self): + def qsize(self) -> int: """Return the size of the priority queue.""" return len(self.pqueue) - def clear(self): + def clear(self) -> None: """Clear all entries in the priority queue.""" self.pqueue.clear() @@ -107,7 +130,7 @@ class BestFirstSearch: choosing the deepest, lowest-cost state in the search frontier and generating next states. Successive calls to the optimizationPass() method will resume the search at the next deepest, lowest-cost state - in the search frontier. The costs of goal states that are returned + in the search frontier. The costs of goal states that are returned are used to constrain subsequent searches. None is returned if no (additional) feasible solutions can be found, or when no (additional) solutions can be found without exceeding the lowest upper-bound cost @@ -144,9 +167,7 @@ class BestFirstSearch: returns a cost bound that is compared to the minimum cost across all vertices in a search frontier. If the minimum cost exceeds the min-cost bound, the search is terminated even if a goal state has not yet been found. - Returning None is equivalent to returning an infinite min-cost bound. A - mincost_bound_func that is None is likewise equivalent to an infinite - min-cost bound. + A mincost_bound_func that is None is equivalent to an infinite min-cost bound. stop_at_first_min (Boolean) is a flag that indicates whether or not to stop the search after the first minimum-cost goal state has been reached. @@ -155,12 +176,12 @@ class BestFirstSearch: can be performed before the search is forced to terminate. None indicates that no restriction is placed in the number of backjump operations. - pqueue (BestFirstPriorityQueue) is a best-first priority-queue object. + pqueue (:class:`BestFirstPriorityQueue`) is an instance of :class:`BestFirstPriorityQueue`. - upperbound_cost (numeric or tuple) is the cost bound obtained by applying + upperbound_cost (float or tuple) is the cost bound obtained by applying the upperbound_cost_func to the goal states that are encountered. - mincost_bound (numeric or tuple) is the cost bound imposed on the minimum + mincost_bound (float or tuple) is the cost bound imposed on the minimum cost across all vertices in the search frontier. The search is forced to terminate when the minimum cost exceeds this cost bound. @@ -183,7 +204,10 @@ class BestFirstSearch: """ def __init__( - self, optimization_settings, search_functions, stop_at_first_min=False + self, + optimization_settings: OptimizationSettings, + search_functions: SearchFunctions, + stop_at_first_min: bool = False, ): """A BestFirstSearch object must be initialized with a list of initial states, a random seed for the numpy pseudo-random number @@ -194,7 +218,7 @@ def __init__( after the first minimum-cost goal state has been reached (True), or whether subsequent calls to the optimizationPass() method should return any additional minimum-cost goal states that might exist - (False). The default is not to stop at the first minimum. A limit + (False). The default is not to stop at the first minimum. A limit on the maximum number of backjumps can also be optionally provided to terminate the search if the number of backjumps exceeds the specified limit without finding the (next) optimal goal state. @@ -221,7 +245,12 @@ def __init__( self.num_backjumps = 0 self.penultimate_stats = None - def initialize(self, initial_state_list, *args): + def initialize( + self, + initial_state_list: list[DisjointSubcircuitsState], + *args: CutOptimizationFuncArgs, + ) -> None: + """Clear the priority queue and push an initial list of states into it.""" self.pqueue.clear() self.upperbound_cost = None @@ -235,11 +264,19 @@ def initialize(self, initial_state_list, *args): self.put(initial_state_list, 0, args) - def optimizationPass(self, *args): + def optimizationPass( + self, *args: CutOptimizationFuncArgs + ) -> ( + tuple[None, None] + | tuple[ + DisjointSubcircuitsState | None, + int | float | tuple[int | float, int | float], + ] + ): """Perform best-first search until either a goal state is found and returned, or cost-bounds are reached or no further goal states can be - found, in which case None is returned. The cost of the returned state - is also returned. Any input arguments to optimizationPass() are passed + found, in which case None is returned. The cost of the returned state + is also returned. Any input arguments to optimizationPass() are passed along to the search-space functions employed. """ @@ -257,7 +294,7 @@ def optimizationPass(self, *args): self.updateMinimumReached(cost) - if cost is None or self.costBoundsExceeded(cost, args): + if cost is None or self.costBoundsExceeded(cost): return None, None self.num_states_visited += 1 @@ -282,17 +319,16 @@ def optimizationPass(self, *args): return None, None - def minimumReached(self): + def minimumReached(self) -> bool: """Return True if the optimization reached a global minimum.""" return self.minimum_reached - def getStats(self, penultimate=False): + def getStats(self, penultimate: bool = False) -> array[int, int, int, int]: """Return a Numpy array containing the number of states visited (dequeued), the number of next-states generated, the number of next-states that are enqueued after cost pruning, and the number - of backjumps performed. Numpy arrays are employed to facilitate - the aggregation of search statisitcs. + of backjumps performed. """ if penultimate: @@ -308,12 +344,14 @@ def getStats(self, penultimate=False): dtype=int, ) - def getUpperBoundCost(self): + def getUpperBoundCost(self) -> int | float | tuple[int | float, int | float]: """Return the current upperbound cost""" return self.upperbound_cost - def updateUpperBoundCost(self, cost_bound: tuple) -> None: + def updateUpperBoundCost( + self, cost_bound: int | float | tuple[int | float, int | float] + ) -> None: """Update the cost upper bound based on an input cost bound. """ @@ -323,7 +361,9 @@ def updateUpperBoundCost(self, cost_bound: tuple) -> None: ): self.upperbound_cost = cost_bound - def updateUpperBoundGoalState(self, goal_state, *args): + def updateUpperBoundGoalState( + self, goal_state: DisjointSubcircuitsState, *args: CutOptimizationFuncArgs + ) -> None: """Update the cost upper bound based on a goal state reached in the search. """ @@ -336,7 +376,12 @@ def updateUpperBoundGoalState(self, goal_state, *args): if self.upperbound_cost is None or bound < self.upperbound_cost: self.upperbound_cost = bound - def put(self, state_list, depth, args): + def put( + self, + state_list: list[DisjointSubcircuitsState], + depth: int, + args: CutOptimizationFuncArgs, + ) -> None: """Push a list of (next) states onto the best-first priority queue. """ @@ -350,7 +395,9 @@ def put(self, state_list, depth, args): self.pqueue.put(state, depth, cost) self.num_enqueues += 1 - def updateMinimumReached(self, min_cost): + def updateMinimumReached( + self, min_cost: None | int | float | tuple[int | float, int | float] + ) -> bool: """Update the minimum_reached flag indicating that a global optimum has been reached. """ @@ -362,7 +409,9 @@ def updateMinimumReached(self, min_cost): return self.minimum_reached - def costBoundsExceeded(self, cost, args): + def costBoundsExceeded( + self, cost: None | int | float | tuple[int | float, int | float] + ) -> bool: """Return True if any cost bounds have been exceeded. """ diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index 1d9b6ee1e..38d4709c1 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -15,54 +15,57 @@ from qiskit import QuantumCircuit from qiskit.circuit import Instruction, Gate - +from .optimization_settings import OptimizationSettings +from typing import TYPE_CHECKING +if TYPE_CHECKING: + from .cut_optimization import CutOptimizationFuncArgs +from .disjoint_subcircuits_state import DisjointSubcircuitsState +from .search_space_generator import SearchFunctions from .best_first_search import BestFirstSearch -from .circuit_interface import CircuitElement +from .circuit_interface import CircuitElement, SimpleGateList from ..qpd import QPDBasis -def QCtoCCOCircuit(circuit: QuantumCircuit): - """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class:`SimpleGateList`. +def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: + """Convert a qiskit quantum circuit object into a circuit list that is + compatible with the :class:`SimpleGateList`. To conform with the uniformity + of the design, single and multiqubit (that is, gates acting on more than two + qubits) are assigned :math:`gamma=None`. In the converted list, a barrier + across the entire circuit is represented by the string "barrier." + Everything else is represented by an instance of :class:`CircuitElement`. Args: - circuit: QuantumCircuit object. + circuit: an instance of :class:`qiskit.QuantumCircuit` . Returns: circuit_list_rep: list of circuit instructions represented in a form that is compatible with :class:`SimpleGateList` and can therefore be ingested by the cut finder. - TODO: Extend this function to allow for circuits with (mid-circuit or other) measurements, as needed. + TODO: Extend this function to allow for circuits with (mid-circuit or other) + measurements, as needed. """ circuit_list_rep = [] for inst in circuit.data: if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: - circuit_list_rep.append(inst.operation.name) + circuit_element = "barrier" else: gamma = None - if ( - inst.operation.name == "barrier" - and len(inst.qubits) != circuit.num_qubits - ): - circuit_element = CircuitElement( - name=inst.operation.name, - params=[], - qubits=list(circuit.find_bit(q).index for q in inst.qubits), - gamma=gamma, - ) if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: gamma = QPDBasis.from_instruction(inst.operation).kappa + name = inst.operation.name + params = inst.operation.params circuit_element = CircuitElement( - inst.operation.name, - params=inst.operation.params, + name=name, + params=params, qubits=list(circuit.find_bit(q).index for q in inst.qubits), gamma=gamma, ) - circuit_list_rep.append(circuit_element) + circuit_list_rep.append(circuit_element) return circuit_list_rep -def CCOtoQCCircuit(interface): +def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: """Convert the cut circuit outputted by the cut finder into a :class:`qiskit.QuantumCircuit` instance. Args: @@ -71,7 +74,8 @@ def CCOtoQCCircuit(interface): Returns: qc_cut: The SimpleGateList converted into a :class:`qiskit.QuantumCircuit` instance. - TODO: This function only works for instances of LO gate cutting. Expand to cover the wire cutting case when needed. + TODO: This function only works for instances of LO gate cutting. + Expand to cover the wire cutting case when needed. """ cut_circuit_list = interface.exportCutCircuit(name_mapping=None) num_qubits = interface.getNumWires() @@ -88,11 +92,14 @@ def CCOtoQCCircuit(interface): def selectSearchEngine( - stage_of_optimization, - optimization_settings, - search_space_funcs, - stop_at_first_min=False, -): + stage_of_optimization: str, + optimization_settings: OptimizationSettings, + search_space_funcs: SearchFunctions, + stop_at_first_min: bool = False, +) -> BestFirstSearch: + """Select the search algorithm to use. At present, only Dijkstra's algorithm + for best first search is supported. + """ engine = optimization_settings.getEngineSelection(stage_of_optimization) if engine == "BestFirst": @@ -106,11 +113,15 @@ def selectSearchEngine( raise ValueError(f"Search engine {engine} is not supported.") -def greedyBestFirstSearch(state, search_space_funcs, *args): +def greedyBestFirstSearch( + state: DisjointSubcircuitsState, + search_space_funcs: SearchFunctions, + *args: CutOptimizationFuncArgs, +) -> None | DisjointSubcircuitsState: """Perform greedy best-first search using the input starting state and - the input search-space functions. The resulting goal state is returned, + the input search-space functions. The resulting goal state is returned, or None if a deadend is reached (no backtracking is performed). Any - additional input arguments are pass as additional arguments to the + additional input arguments are passed as additional arguments to the search-space functions. """ diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 38304c46d..06243f9ba 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -117,9 +117,9 @@ class SimpleGateList(CircuitInterface): """Derived class that converts a simple list of gates into the form needed by the circuit-cutting optimizer code. - Elements of the list must be of the form of CircuitElement. + Elements of the list must be instances of :class:`CircuitElement`. The only exception to this is a barrier when one is placed across - all the qubits in a circuit. That is specified by a string "barrier". + all the qubits in a circuit. That is specified by the string: "barrier". Qubit names can be any hashable objects. Gate names can also be any hashable objects, but they must be consistent with the names used by the @@ -130,17 +130,17 @@ class SimpleGateList(CircuitInterface): Member Variables: - qubit_names: an object that maps qubit names to - numerical qubit IDs. + qubit_names (NametoIDMap): an instance of :class:`NametoIDMap` that maps + qubit names to numerical qubit IDs. - num_qubits: the number of qubits in the input circuit. Qubit IDs + num_qubits (int): the number of qubits in the input circuit. Qubit IDs whose values are greater than or equal to num_qubits represent qubits that were introduced as the result of wire cutting. These qubits are assigned generated names of the form ('cut', ) in the qubit_names object, where is the name of the wire/qubit that was cut to create the new wire/qubit. - circuit: the internal representation of the circuit, which is + circuit (list): the internal representation of the circuit, which is a list of the following form: [ ... [, None] ...] @@ -148,25 +148,25 @@ class SimpleGateList(CircuitInterface): where the qubit names have been replaced with qubit IDs in the gate specifications. - new_circuit: a list of gate specifications that define + new_circuit (list): a list of gate specifications that define the cut circuit. As with circuit, qubit IDs are used to identify wires/qubits. - cut_type: a list that assigns cut-type annotations to gates + cut_type (list): a list that assigns cut-type annotations to gates in new_circuit. - new_gate_ID_map: a list that maps the positions of gates + new_gate_ID_map (list): a list that maps the positions of gates in circuit to their new positions in new_circuit. - output_wires: a list that maps qubit IDs in circuit to the corresponding + output_wires (list): a list that maps qubit IDs in circuit to the corresponding output wires of new_circuit so that observables defined for circuit can be remapped to new_circuit. - subcircuits: a list of list of wire IDs, where each list of + subcircuits (list): a list of list of wire IDs, where each list of wire IDs defines a subcircuit. """ - circuit: list[CircuitElement | str | None] + circuit: list[CircuitElement | None] new_circuit: list[CircuitElement] cut_type: str | None qubit_names: NameToIDMap @@ -214,7 +214,7 @@ def getNumWires(self) -> int: return self.qubit_names.getNumItems() - def getMultiQubitGates(self) -> list[int | CircuitElement | str | None]: + def getMultiQubitGates(self) -> list[int | CircuitElement | None]: """Extract the multiqubit gates from the circuit and prepends the index of the gate in the circuits to the gate specification. @@ -297,7 +297,7 @@ def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: self.subcircuits = list_of_list_of_wires - def getWireNames(self) -> list[Hashable]: + def getWireNames(self) -> list[Hashable | tuple[str, Hashable]]: """Return a list of the internal wire names used in the circuit, which consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. @@ -305,7 +305,9 @@ def getWireNames(self) -> list[Hashable]: return list(self.qubit_names.getItems()) - def exportCutCircuit(self, name_mapping: str = "default") -> list[CircuitElement]: + def exportCutCircuit( + self, name_mapping: None | str | dict[Hashable, Hashable] = "default" + ) -> list[CircuitElement | list[str | Hashable | Hashable]]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -322,7 +324,9 @@ def exportCutCircuit(self, name_mapping: str = "default") -> list[CircuitElement return out - def exportOutputWires(self, name_mapping: str = "default") -> dict: + def exportOutputWires( + self, name_mapping: None | str | dict[Hashable, Hashable] = "default" + ) -> dict[Hashable, Hashable | tuple[str, Hashable]]: """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. If None is provided as the name_mapping, then the original qubit names are @@ -339,9 +343,11 @@ def exportOutputWires(self, name_mapping: str = "default") -> dict: out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] return out - def exportSubcircuitsAsString(self, name_mapping: str = "default") -> str: + def exportSubcircuitsAsString( + self, name_mapping: None | str | dict[Hashable, int] = "default" + ) -> str: """Return a string that maps qubits/wires in the output circuit - to subcircuits per the Circuit Knitting Toolbox convention. This + to subcircuits per the Circuit Knitting Toolbox convention. This method only works with mappings to numeric qubit/wire names, such as provided by "default" or a custom name_mapping. """ @@ -355,7 +361,9 @@ def exportSubcircuitsAsString(self, name_mapping: str = "default") -> str: out[wire_map[wire]] = alphabet[k] return "".join(out) - def makeWireMapping(self, name_mapping: None | str) -> list[Hashable | int]: + def makeWireMapping( + self, name_mapping: None | str | dict[Hashable, Hashable] + ) -> list[Hashable]: """Return a wire-mapping list given an input specification of a name mapping. If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. If "default" @@ -379,12 +387,12 @@ def makeWireMapping(self, name_mapping: None | str) -> list[Hashable | int]: return wire_mapping - def defaultWireNameMapping(self) -> dict[list[str | tuple[str, str]], int]: - """Return a dictionary that maps wire names in self.qubit_names to + def defaultWireNameMapping(self) -> dict[list[Hashable], int]: + """Return a dictionary that maps wire names in :func:`self.getWireNames()` to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric IDs that are adjacent to the numeric ID of the wire prior to cutting so that Move operators are then - applied against adjacent qubits. This is ensured by the sortOrder + applied against adjacent qubits. This is ensured by the :func:`self.sortOrder()` method. """ @@ -489,8 +497,8 @@ def getNumItems(self) -> int: def getArraySizeNeeded(self) -> int: """Return one plus the maximum item ID assigned thus far, or zero if no items have been assigned. The value returned - is thus the minimum size needed to construct a Python/Numpy - array that maps item IDs to other values. + is thus the minimum size needed for a Python/Numpy + array that maps item IDs to other hashables. """ if self.getNumItems() == 0: # pragma: no cover @@ -499,11 +507,11 @@ def getArraySizeNeeded(self) -> int: return 1 + max(self.ID_dict.keys()) def getItems(self) -> Iterable[Hashable]: - """Return an iterator over the hashable items loaded thus far.""" + """Return the keys of the dictionary of hashable items loaded thus far.""" return self.item_dict.keys() def getIDs(self) -> Iterable[Hashable]: - """Return an iterator over the hashable items loaded thus far.""" + """Return the keys of the dictionary of ID's assigned to hashable items loaded thus far.""" return self.ID_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index e4d74583b..7ad601042 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -20,7 +20,7 @@ from .quantum_device_constraints import DeviceConstraints from .circuit_interface import SimpleGateList from .lo_cuts_optimizer import LOCutsOptimizer -from .cco_utils import QCtoCCOCircuit +from .cco_utils import qc_to_cco_circuit from ..instructions import CutWire from ..cutting_decomposition import cut_gates @@ -46,7 +46,7 @@ def find_cuts( resulting from cutting these gates will be runnable on the devices specified in ``constraints``. """ - circuit_cco = QCtoCCOCircuit(circuit) + circuit_cco = qc_to_cco_circuit(circuit) interface = SimpleGateList(circuit_cco) if isinstance(optimization, dict): diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 866f73c4c..0775b7052 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -11,7 +11,12 @@ """Classes required to search for optimal cut locations.""" +from __future__ import annotations + +from dataclasses import dataclass import numpy as np +import array +from .search_space_generator import ActionNames from .cco_utils import selectSearchEngine, greedyBestFirstSearch from .cutting_actions import disjoint_subcircuit_actions from .search_space_generator import ( @@ -22,36 +27,44 @@ from .disjoint_subcircuits_state import ( DisjointSubcircuitsState, ) +from .circuit_interface import SimpleGateList +from .optimization_settings import OptimizationSettings +from .quantum_device_constraints import DeviceConstraints - +@dataclass class CutOptimizationFuncArgs: """Class for passing relevant arguments to the CutOptimization search-space generating functions. """ - - def __init__(self): - self.entangling_gates = None - self.search_actions = None - self.max_gamma = None - self.qpu_width = None - - -def CutOptimizationCostFunc(state, func_args): - """Return the cost function. The cost function aims to minimize the - gamma bound while giving preference to circuit partionings that balance the - sizes of the resulting partitions. + entangling_gates = None + search_actions = None + max_gamma = None + qpu_width = None + + +def CutOptimizationCostFunc( + state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs +) -> tuple[int | float, int | float]: + """Return the cost function. The particular cost function chosen here + aims to minimize the gamma while also (secondarily) giving preference to + circuit partitionings that balance the sizes of the resulting partitions, + by minimizing the maximum width across subcircuits. """ return (state.lowerBoundGamma(), state.getMaxWidth()) -def CutOptimizationUpperBoundCostFunc(goal_state, func_args): +def CutOptimizationUpperBoundCostFunc( + goal_state, func_args: CutOptimizationFuncArgs +) -> tuple[int | float, int | float]: """Return the gamma upper bound.""" return (goal_state.upperBoundGamma(), np.inf) -def CutOptimizationMinCostBoundFunc(func_args): +def CutOptimizationMinCostBoundFunc( + func_args: CutOptimizationFuncArgs, +) -> tuple[int | float, int | float]: """Return an a priori min-cost bound defined in the optimization settings.""" if func_args.max_gamma is None: # pragma: no cover @@ -60,7 +73,9 @@ def CutOptimizationMinCostBoundFunc(func_args): return (func_args.max_gamma, np.inf) -def CutOptimizationNextStateFunc(state, func_args): +def CutOptimizationNextStateFunc( + state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs +) -> list[disjoint_subcircuit_actions]: """Generate a list of next states from the input state.""" # Get the entangling gate spec that is to be processed next based @@ -86,7 +101,9 @@ def CutOptimizationNextStateFunc(state, func_args): return next_state_list -def CutOptimizationGoalStateFunc(state, func_args): +def CutOptimizationGoalStateFunc( + state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs +) -> bool: """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy the device constraints and the optimization settings). """ @@ -105,12 +122,12 @@ def CutOptimizationGoalStateFunc(state, func_args): def greedyCutOptimization( - circuit_interface, - optimization_settings, - device_constraints, - search_space_funcs=cut_optimization_search_funcs, - search_actions=disjoint_subcircuit_actions, -): + circuit_interface: SimpleGateList, + optimization_settings: OptimizationSettings, + device_constraints: DeviceConstraints, + search_space_funcs: SearchFunctions = cut_optimization_search_funcs, + search_actions: ActionNames = disjoint_subcircuit_actions, +) -> greedyBestFirstSearch: func_args = CutOptimizationFuncArgs() func_args.entangling_gates = circuit_interface.getMultiQubitGates() func_args.search_actions = search_actions @@ -139,26 +156,26 @@ class CutOptimization: Member Variables: - circuit (CircuitInterface) is the interface object for the circuit + circuit (:class:`CircuitInterface`) is the interface object for the circuit to be cut. - settings (OptimizationSettings) is an object that contains the settings + settings (:class:`OptimizationSettings`) is an object that contains the settings that control the optimization process. - constraints (DeviceConstraints) is an object that contains the device + constraints (:class:`DeviceConstraints`) is an object that contains the device constraints that solutions must obey. - search_funcs (SearchFunctions) is an object that holds the functions + search_funcs (:class:`SearchFunctions`) is an object that holds the functions needed to generate and explore the cut optimization search space. - func_args (CutOptimizationFuncArgs) is an object that contains the + func_args (:class:`CutOptimizationFuncArgs`) is an object that contains the necessary device constraints and optimization settings parameters that aree needed by the cut optimization search-space function. - search_actions (ActionNames) is an object that contains the allowed + search_actions (:class:`ActionNames`) is an object that contains the allowed actions that are used to generate the search space. - search_engine (BestFirstSearch) is an object that implements the + search_engine (:class`BestFirstSearch`) is an object that implements the search algorithm. """ @@ -221,7 +238,7 @@ def __init__( mwc = maxWireCutsGamma(self.greedy_goal_state.upperBoundGamma()) max_wire_cuts = min(max_wire_cuts, mwc) - elif self.func_args.max_gamma is not None: + elif self.func_args.max_gamma is not None: mwc = maxWireCutsGamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) @@ -245,7 +262,7 @@ def __init__( self.search_engine = sq self.goal_state_returned = False - def optimizationPass(self): + def optimizationPass(self) -> tuple[DisjointSubcircuitsState, int | float]: """Produce, at each call, a goal state representing a distinct set of cutting decisions. None is returned once no additional choices of cuts can be made without exceeding the minimum upper bound across @@ -260,28 +277,28 @@ def optimizationPass(self): return state, cost - def minimumReached(self): + def minimumReached(self) -> bool: """Return True if the optimization reached a global minimum.""" return self.search_engine.minimumReached() - def getStats(self, penultimate=False): + def getStats(self, penultimate: bool = False) -> array: """Return the search-engine statistics.""" return self.search_engine.getStats(penultimate=penultimate) - def getUpperBoundCost(self): + def getUpperBoundCost(self) -> tuple[int | float, int | float]: """Return the current upperbound cost.""" return self.search_engine.getUpperBoundCost() - def updateUpperBoundCost(self, cost_bound): + def updateUpperBoundCost(self, cost_bound: tuple[int | float, int | float]) -> None: """Update the cost upper bound based on an input cost bound.""" self.search_engine.updateUpperBoundCost(cost_bound) -def maxWireCutsCircuit(circuit_interface): +def maxWireCutsCircuit(circuit_interface: SimpleGateList) -> int: """Calculate an upper bound on the maximum number of wire cuts that can be made given the total number of inputs to multiqubit gates in the circuit. @@ -290,7 +307,7 @@ def maxWireCutsCircuit(circuit_interface): return sum([len(x[1]) - 1 for x in circuit_interface.getMultiQubitGates()]) -def maxWireCutsGamma(max_gamma): +def maxWireCutsGamma(max_gamma: float | int) -> int: """Calculate an upper bound on the maximum number of wire cuts that can be made given the maximum allowed gamma. """ diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index b21211b09..ef3315588 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -11,8 +11,13 @@ """Classes needed to implement the actions involved in circuit cutting.""" + +from __future__ import annotations + from abc import ABC, abstractmethod from .search_space_generator import ActionNames +from .disjoint_subcircuits_state import DisjointSubcircuitsState +from .circuit_interface import CircuitElement # Object that holds action names for constructing disjoint subcircuits disjoint_subcircuit_actions = ActionNames() @@ -59,17 +64,19 @@ class ActionApplyGate(DisjointSearchAction): """Action class that implements the action of applying a two-qubit gate without decomposition""" - def getName(self): + def getName(self) -> None: """Return the look-up name of ActionApplyGate.""" return None - def getGroupNames(self): + def getGroupNames(self) -> None: """Return the group name of ActionApplyGate.""" return [None, "TwoQubitGates"] - def nextStatePrimitive(self, state, gate_spec, max_width): + def nextStatePrimitive( + self, state: DisjointSubcircuitsState, gate_spec: CircuitElement, max_width: int + ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionApplyGate to state given the two-qubit gate specification: gate_spec. @@ -323,7 +330,9 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + def exportCuts( + self, circuit_interface, wire_map, gate_spec, cut_args + ): # pragma: no cover """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. """ @@ -393,7 +402,9 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + def exportCuts( + self, circuit_interface, wire_map, gate_spec, cut_args + ): # pragma: no cover """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. """ diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index bec8ac20c..adda7ec11 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -11,9 +11,13 @@ """Class needed for representing search-space states when cutting circuits.""" +from __future__ import annotations + import copy import numpy as np +from typing import Hashable, Iterable from collections import Counter +from .circuit_interface import CircuitElement, SimpleGateList class DisjointSubcircuitsState: @@ -23,44 +27,43 @@ class DisjointSubcircuitsState: sufficient information is stored in order to minimize the memory footprint. - Each wire cut introduces a new wire. A mapping from qubit IDs + Each wire cut introduces a new wire. A mapping from qubit IDs in QASM-like statements to wire IDs is therefore created - and maintained. Groups of wires form subcircuits, and these - subcircuits can then be merged via search actions. The mapping + and maintained. Groups of wires form subcircuits. The mapping from wires to subcircuits is represented using an up-tree data - structure over wires. The number of wires (width) in each + structure over wires. The number of wires (width) in each subcircuit is also tracked to ensure subcircuits will fit on target quantum devices. Member Variables: - wiremap (int Numpy array) provides the mapping from qubit IDs + wiremap: an int Numpy array that provides the mapping from qubit IDs to wire IDs. - num_wires (int) is the number of wires in the cut circuit. + num_wires: an int which is the number of wires in the cut circuit. - uptree (int Numpy array) contains the uptree data structure that + uptree: an int Numpy array that contains the uptree data structure that defines groups of wires that form subcircuits. The uptree array map wire IDs to parent wire IDs in a subcircuit. If a wire points to itself, then that wire is the root wire in the corresponding subcircuit. Otherwise, you need to follow the parent links to find the root wire that corresponds to that subcircuit. - width (int Numpy array) contains the number of wires in each - subcircuit. The values of width are valid only for root wire IDs. + width: an int Numpy array that contains the number of wires in each + subcircuit. The values of width are valid only for root wire IDs. - bell_pairs (list) is a list of pairs of subcircuits (wires) that + bell_pairs: a list of pairs of subcircuits (wires) that define the virtual Bell pairs that would need to be constructed in order to implement optimal LOCC wire and gate cuts using ancillas. - gamma_LB (float) is the cumulative lower-bound gamma for circuit cuts + gamma_LB: a float that is the cumulative lower-bound gamma for circuit cuts that cannot be constructed using Bell pairs, such as LO gate cuts for small-angled rotations. - gamma_UB (float) is the cumulative upper-bound gamma for all circuit + gamma_UB: a float that is the cumulative upper-bound gamma for all circuit cuts assuming all cuts are LO. - no_merge (list) contains a list of subcircuit merging constaints. + no_merge: a list that contains a list of subcircuit merging constaints. Each constraint can either be a pair of wire IDs or a list of pairs of wire IDs. In the case of a pair of wire IDs, the constraint is that the subcircuits that contain those wire IDs cannot be merged @@ -68,24 +71,23 @@ class DisjointSubcircuitsState: wire IDs, the constraint is that at least one pair of corresponding subcircuits cannot be merged. - actions (list) contains a list of circuit-cutting actions that have + actions: a list that contains a list of circuit-cutting actions that have been performed on the circuit. Elements of the list have the form [, , (, ..., )] The is the object that was used to generate the circuit cut. The is the specification of the - cut gate using the format defined in the CircuitInterface class + cut gate using the format defined in the :class:`CircuitInterface` class description. The trailing entries are the arguments needed by the - to apply further search-space generating objects - in Stage Two in order to explore the space of QPD assignments to - the circuit-cutting action. + that can be used to explore the space of QPD assignments + to the circuit-cutting action. - level (int) is the level in the search tree at which this search + level: an int which specifies the level in the search tree at which this search state resides, with 0 being the root of the search tree. """ - def __init__(self, num_qubits=None, max_wire_cuts=None): + def __init__(self, num_qubits: int = None, max_wire_cuts: int = None): """An instance of :class:`DisjointSubcircuitsState` must be initialized with a specification of the number of qubits in the circuit and the maximum number of wire cuts that can be performed.""" @@ -137,7 +139,7 @@ def __init__(self, num_qubits=None, max_wire_cuts=None): self.cut_actions_list = list() self.level = 0 - def __copy__(self): + def __copy__(self) -> DisjointSubcircuitsState: new_state = DisjointSubcircuitsState() new_state.wiremap = self.wiremap.copy() @@ -157,17 +159,17 @@ def __copy__(self): return new_state - def copy(self): + def copy(self) -> DisjointSubcircuitsState: """Make shallow copy.""" return copy.copy(self) - def CutActionsList(self): - """Create a formatted list containing the actions carried out on a DisjointSubcircuitState - along with the locations of these actions which are specified in terms of - gate and wire references.""" + def cut_actions_sublist(self) -> list[list | dict]: + """Create a formatted list containing the actions carried out on an instance + of :class:`DisjointSubcircuitState` along with the locations of these actions + which are specified in terms of the associated gates and wires.""" - cut_actions = PrintActionListWithNames(self.actions) + cut_actions = print_actions_list(self.actions) # Output formatting for LO gate and wire cuts. # TODO: Change to NamedTuples. @@ -196,10 +198,10 @@ def CutActionsList(self): return self.cut_actions_list - def print(self, simple=False): # pragma: no cover + def print(self, simple: bool = False) -> None: # pragma: no cover """Print the various properties of a DisjointSubcircuitState.""" - cut_actions_list = self.CutActionsList() + cut_actions_list = self.cut_actions_sublist() if simple: print(cut_actions_list) else: @@ -212,22 +214,22 @@ def print(self, simple=False): # pragma: no cover print("lowerBound", self.lowerBoundGamma()) print("gamma_UB", self.gamma_UB) print("no_merge", self.no_merge) - print("actions", PrintActionListWithNames(self.actions)) + print("actions", print_actions_list(self.actions)) print("level", self.level) - def getNumQubits(self): + def getNumQubits(self) -> int: """Return the number of qubits in the circuit.""" if self.wiremap is not None: return self.wiremap.shape[0] - def getMaxWidth(self): + def getMaxWidth(self) -> int: """Return the maximum width across subcircuits.""" if self.width is not None: return np.amax(self.width) - def getSubCircuitIndices(self): + def getSubCircuitIndices(self) -> list[int]: """Return a list of root indices for the subcircuits in the current cut circuit. """ @@ -235,23 +237,23 @@ def getSubCircuitIndices(self): if self.uptree is not None: return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] - def getWireRootMapping(self): + def getWireRootMapping(self) -> list[int]: """Return a list of root wires for each wire in the current cut circuit. """ return [self.findWireRoot(i) for i in range(self.num_wires)] - def findRootBellPair(self, bell_pair): + def findRootBellPair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: """Find the root wires for a Bell pair (represented as a pair - of wires) and returns a sorted tuple representing the Bell pair. + of wires) and return a sorted tuple representing the Bell pair. """ r0 = self.findWireRoot(bell_pair[0]) r1 = self.findWireRoot(bell_pair[1]) return (r0, r1) if (r0 < r1) else (r1, r0) - def lowerBoundGamma(self): + def lowerBoundGamma(self) -> float: """Calculate a lower bound for gamma using the current counts for the different types of circuit cuts. """ @@ -260,7 +262,7 @@ def lowerBoundGamma(self): return self.gamma_LB * calcRootBellPairsGamma(root_bell_pairs) - def upperBoundGamma(self): + def upperBoundGamma(self) -> float: """Calculate an upper bound for gamma using the current counts for the different types of circuit cuts. """ @@ -281,8 +283,8 @@ def canExpandSubcircuit(self, root: int, num_wires: int, max_width: int) -> bool return self.width[root] + num_wires <= max_width - def newWire(self, qubit): - """Cut the wire associated with qubit and returns + def newWire(self, qubit: Hashable) -> int: + """Cut the wire associated with qubit and return the ID of the new wire now associated with qubit. """ @@ -295,14 +297,14 @@ def newWire(self, qubit): return self.wiremap[qubit] - def getWire(self, qubit): + def getWire(self, qubit: Hashable) -> int: """Return the ID of the wire currently associated with qubit.""" return self.wiremap[qubit] - def findWireRoot(self, wire): + def findWireRoot(self, wire: int) -> int: """Return the ID of the root wire in the subcircuit - that contains wire and collapses the path to the root. + that contains wire and collapse the path to the root. """ # Find the root wire in the subcircuit @@ -318,14 +320,14 @@ def findWireRoot(self, wire): return root - def findQubitRoot(self, qubit): + def findQubitRoot(self, qubit: Hashable) -> int: """Return the ID of the root wire in the subcircuit currently - associated with qubit and collapses the path to the root. + associated with qubit and collapse the path to the root. """ return self.findWireRoot(self.wiremap[qubit]) - def checkDoNotMergeRoots(self, root_1, root_2): + def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: """Return True if the subcircuits represented by root wire IDs root_1 and root_2 should not be merged. """ @@ -347,7 +349,7 @@ def checkDoNotMergeRoots(self, root_1, root_2): return False - def verifyMergeConstraints(self): + def verifyMergeConstraints(self) -> bool: """Return True if all merge constraints are satisfied.""" for clause in self.no_merge: @@ -358,7 +360,7 @@ def verifyMergeConstraints(self): return True - def assertDoNotMergeRoots(self, wire_1, wire_2): + def assertDoNotMergeRoots(self, wire_1: int, wire_2: int) -> bool: """Add a constraint that the subcircuits associated with wires IDs wire_1 and wire_2 should not be merged. """ @@ -369,9 +371,9 @@ def assertDoNotMergeRoots(self, wire_1, wire_2): self.no_merge.append((wire_1, wire_2)) - def mergeRoots(self, root_1, root_2): + def mergeRoots(self, root_1: int, root_2: int) -> None: """Merge the subcircuits associated with root wire IDs root_1 - and root_2, and updates the statistics (i.e., width) + and root_2, and update the statistics (i.e., width) associated with the newly merged subcircuit. """ @@ -388,7 +390,7 @@ def mergeRoots(self, root_1, root_2): self.uptree[other_root] = merged_root self.width[merged_root] += self.width[other_root] - def addAction(self, action_obj, gate_spec, *args): + def addAction(self, action_obj, gate_spec: CircuitElement, *args) -> None: """Append the specified action to the list of search-space actions that have been performed. """ @@ -396,19 +398,19 @@ def addAction(self, action_obj, gate_spec, *args): if action_obj.getName() is not None: self.actions.append([action_obj, gate_spec, args]) - def getSearchLevel(self): + def getSearchLevel(self) -> int: """Return the search level.""" return self.level - def setNextLevel(self, state): + def setNextLevel(self, state: DisjointSubcircuitsState) -> int: """Set the search level of self to one plus the search level of the input state. """ self.level = state.level + 1 - def exportCuts(self, circuit_interface): + def exportCuts(self, circuit_interface: SimpleGateList) -> SimpleGateList: """Export LO cuts into the input circuit_interface for each of the cutting decisions made. """ @@ -431,15 +433,14 @@ def exportCuts(self, circuit_interface): circuit_interface.defineSubcircuits(subcircuits) -def calcRootBellPairsGamma(root_bell_pairs): +def calcRootBellPairsGamma(root_bell_pairs: Iterable[Hashable]) -> float: """Calculate the minimum-achievable LOCC gamma for circuit - cuts that utilize virtual Bell pairs. The input can be a list - or iterator over hashable identifiers that represent Bell pairs - across disconnected subcircuits in a cut circuit. There must be - a one-to-one mapping between identifiers and pairs of subcircuits. - Repeated identifiers are interpreted as mutiple Bell pairs across - the same pair of subcircuits, and the counts of such repeats are - used to calculate gamma. + cuts that utilize virtual Bell pairs. The input can be an iterable + over hashable identifiers that represent Bell pairs across disconnected + subcircuits in a cut circuit. There must be a one-to-one mapping between + identifiers and pairs of subcircuits. Repeated identifiers are interpreted + as mutiple Bell pairs across the same pair of subcircuits, and the counts + of such repeats are used to calculate gamma. """ gamma = 1.0 @@ -449,9 +450,10 @@ def calcRootBellPairsGamma(root_bell_pairs): return gamma -def PrintActionListWithNames(action_list): - """Replace the action objects that appear in action lists - in DisjointSubcircuitsState objects with the corresponding - action names for readability, and print. +def print_actions_list( + action_list: list[DisjointSubcircuitsState.actions], +) -> list[list[str | list | tuple]]: + """Return a list specifying action objects that represent cutting actions assoicated with an + instance of :class:`DisjointSubcircuitsState`. """ return [[x[0].getName()] + x[1:] for x in action_list] diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index f2a368b87..d550d4840 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -10,6 +10,7 @@ # that they have been altered from the originals. """File containing the wrapper class for optimizing LO gate and wire cuts.""" +from __future__ import annotations from .cut_optimization import CutOptimization from .cut_optimization import disjoint_subcircuit_actions @@ -19,6 +20,12 @@ from .cut_optimization import CutOptimizationUpperBoundCostFunc from .search_space_generator import SearchFunctions, SearchSpaceGenerator +from numpy import array +from .disjoint_subcircuits_state import DisjointSubcircuitsState +from .quantum_device_constraints import DeviceConstraints +from .optimization_settings import OptimizationSettings +from .circuit_interface import SimpleGateList + ### Functions for generating the cut optimization search space cut_optimization_search_funcs = SearchFunctions( @@ -88,27 +95,27 @@ def __init__( def optimize( self, - circuit_interface=None, - optimization_settings=None, - device_constraints=None, - ): + circuit_interface: SimpleGateList = None, + optimization_settings: OptimizationSettings = None, + device_constraints: DeviceConstraints = None, + ) -> DisjointSubcircuitsState | None: """Method to optimize the cutting of a circuit. Input Arguments: - circuit_interface (CircuitInterface) defines the circuit to be + circuit_interface: defines the circuit to be cut. This object is then updated with the optimized cuts that were identified. - optimization_settings (OptimizationSettings) defines the settings + optimization_settings: defines the settings to be used for the optimization. - device_constraints (DeviceConstraints) defines the capabilties of + device_constraints: the capabilties of the target quantum hardware. Returns: - The lowest-cost DisjointSubcircuitsState object identified in + The lowest-cost instance of :class:`DisjointSubcircuitsState` identified in the search, or None if no solution could be found. In the case of the former, the circuit_interface object is also updated as a side effect to incorporate the cuts found. @@ -156,19 +163,19 @@ def optimize( return self.best_result - def getResults(self): + def getResults(self) -> DisjointSubcircuitsState | None: """Return the optimization results.""" return self.best_result - def getStats(self, penultimate=False): + def getStats(self, penultimate=False) -> array[int | float]: """Return the optimization results.""" return { "CutOptimization": self.cut_optimization.getStats(penultimate=penultimate) } - def minimumReached(self): + def minimumReached(self) -> bool: """Return a Boolean flag indicating whether the global minimum was reached. """ @@ -176,7 +183,9 @@ def minimumReached(self): return self.cut_optimization.minimumReached() -def printStateList(state_list): #pragma: no cover +def printStateList( + state_list: list[DisjointSubcircuitsState], +) -> None: # pragma: no cover for x in state_list: print() x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index f7531cb85..338b02993 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -14,14 +14,12 @@ from dataclasses import dataclass -from typing import TYPE_CHECKING - -from typing import Callable, Iterable +from typing import Callable, Iterable, TYPE_CHECKING from .disjoint_subcircuits_state import DisjointSubcircuitsState -if TYPE_CHECKING: #pragma: no cover - from cut_optimization import CutOptimizationFuncArgs +if TYPE_CHECKING: # pragma: no cover + from .cut_optimization import CutOptimizationFuncArgs from .cutting_actions import DisjointSearchAction @@ -46,7 +44,7 @@ def __init__(self): self.group_dict = dict() def copy(self, list_of_groups: list[str] = None) -> ActionNames: - """Return a copy of self that contains only those actions + """Return a copy of :class:`ActionNames` that contains only those actions whose group affiliations intersect with list_of_groups. The default is to return a copy containing all actions. """ @@ -92,7 +90,7 @@ def getAction(self, action_name: str) -> DisjointSearchAction | None: return self.action_dict[action_name] return None - def getGroup(self, group_name: str) -> list | None: + def getGroup(self, group_name: str) -> list[DisjointSearchAction] | None: """Return the list of action objects associated with the group_name. None is returned if there are no associated action objects. """ @@ -102,7 +100,9 @@ def getGroup(self, group_name: str) -> list | None: return None -def getActionSubset(action_list: list, action_groups: Iterable) -> list: +def getActionSubset( + action_list: list, action_groups: Iterable[DisjointSearchAction] +) -> list[DisjointSearchAction]: """Return the subset of actions in action_list whose group affiliations intersect with action_groups. """ @@ -130,33 +130,41 @@ class SearchFunctions: Member Variables: - cost_func: a function that computes cost values from search states. - The cost returned can be numeric or tuples of numerics. In the latter case, - lexicographical comparisons are performed per Python semantics. - - next_state_func: a function that returns a list of next states generated from the input state. - - goal_state_func: a function that returns True if the input state is a solution state of the search. - - upperbound_cost_func: can either be None or a function that returns an upper bound - to the optimal cost given a goal_state as input. The upper bound is used to prune - next-states from the search in subsequent calls to the optimizationPass() method of - the search algorithm. If upperbound_cost_func is None, the cost of the goal_state - as determined by cost_func is used as an upper bound to the optimal cost. If the + cost_func (lambda state, *args) is a function that computes cost values + from search states. The cost returned can be numeric or tuples of + numerics. In the latter case, lexicographical comparisons are performed + per Python semantics. + + next_state_func (lambda state, *args) is a function that returns a list + of next states generated from the input state. An ActionNames object + should be incorporated into the additional input arguments in order to + generate next-states. + + goal_state_func (lambda state, *args) is a function that returns True if + the input state is a solution state of the search. + + upperbound_cost_func (lambda goal_state, *args) can either be None or a + function that returns an upper bound to the optimal cost given a goal_state + as input. The upper bound is used to prune next-states from the search in + subsequent calls to the optimizationPass() method of the search algorithm. + If upperbound_cost_func is None, the cost of the goal_state as determined + by cost_func is used as an upper bound to the optimal cost. If the upperbound_cost_func returns None, the effect is equivalent to returning an infinite upper bound (i.e., no cost pruning is performed on subsequent - calls to the optimizationPass method). + optimization calls. - mincost_bound_func: can either be None or a function that + mincost_bound_func (lambda *args) can either be None or a function that returns a cost bound that is compared to the minimum cost across all - vertices in a search frontier. If the minimum cost exceeds the min-cost + vertices in a search frontier. If the minimum cost exceeds the min-cost bound, the search is terminated even if a goal state has not yet been found. - None is equivalent to returning an infinite min-cost bound (i.e., - min-cost checking is effectively not performed). + Returning None is equivalent to returning an infinite min-cost bound (i.e., + min-cost checking is effectively not performed). A mincost_bound_func that + is None is likewise equivalent to an infinite min-cost bound. """ cost_func: Callable[ - [DisjointSubcircuitsState, SearchFunctions], float | tuple[float, int] + [DisjointSubcircuitsState, SearchFunctions], + int | float | tuple[int | float, int | float], ] = (None,) next_state_func: Callable[ @@ -169,11 +177,12 @@ class SearchFunctions: ] = (None,) upperbound_cost_func: None | Callable[ - [DisjointSubcircuitsState, CutOptimizationFuncArgs], tuple[float, float] + [DisjointSubcircuitsState, CutOptimizationFuncArgs], + tuple[int | float, int | float], ] = (None,) mincost_bound_func: None | Callable[ - [CutOptimizationFuncArgs], None | tuple[float, float] + [CutOptimizationFuncArgs], None | tuple[int | float, int | float] ] = None diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index a6a4fa98d..4d31283eb 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -16,17 +16,25 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/matplotlib.py:274: UserWarning: Style JSON file 'iqp.json' not found in any of these locations: /Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/styles/iqp.json, iqp.json. Will use default style.\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/0AAAGRCAYAAAA3ltNoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5p0lEQVR4nO3dd3gU5d7G8e/uJoGQkFACSYDQCSBEIIAUaaKIEKUpUhTEY6EoqCgeCzZEBLuIBxBfsaGxAlZQug1BOggEQktCQg+kt933j2ggpLed3c39uS4uNjPP7N6zO7Mzv52ZZ0w2m82GiIiIiIiIiLgcs9EBRERERERERKRiqOgXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhEREREREREXpaJfRERERERExEWp6BcRERERERFxUSr6RURERERERFyUin4RERERERERF6WiX0RERERERMRFqegXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhEREREREREXpaJfRERERERExEWp6BcRERERERFxUSr6RURERERERFyUin4RERERERERF6WiX0RERERERMRFqegXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhEREREREREX5WZ0ABF72b4UUuKNTgGeNaD90LI9h6PMC5TP/IiIiNiDo2w/te0UZ+JK683QbVs4lJJcLnnKqqlnNZZ26GiX11LRL5VGSjwknTE6RflwpXkRERGxF20/RUrOldabQynJ7E1KNDqG3en0fhEREREREREXpaJfRERERERExEWp6BcRERERERFxUSr6RURERERERFyUOvITucxL4eP4ecsHAJhNZmr5BNK+WV/uGvgifr71DU4nIiIiFU37AiIlp/XGcelIv0g+Qpr05LOnYlny5DEeH/0JB49v4/mPhhsdS0REROxE+wIiJaf1xjGp6BfJh5vFg1o+Afj51ufKpr0I63Ivfx/9g6TUC0ZHExERETvQvoBIyWm9cUwq+kWKcPr8cTbs+hKz2YLZbDE6joiIiNiZ9gVESk7rjePQNf0i+dhxaB03PemNzWYlLSMFgFt6PYynhxcAMz68hY7B1xPW9V4ADsZsY9Yno1nw4DY83KsalltERETKR1H7AqfPxzBlXjfefuAvanrXJTU9mfGvt+PZsV/TJDDEyOgihilqvfl111I++vm5XNMcO/k3kwa9yU3dJ9o9b2Xh1EX/jh07ePrpp1m3bh02m42+ffsyf/58goODCQsLIzw83OiI4qRaBXXh0ZEfkJ6Zyvodn7PtwCruvGFmzvhJg9/kobd70CNkGNU9a/Hm1xO5f8g8FfwiIiIuoqh9AT/f+tzSayoLv5nKY6M/5qOfnqVHm6Eq+KVSK2q96REylB4hQ3P+/m33Mt778Qn6dbrDiLiVhtMW/atXr+bGG2+kUaNGTJ8+HU9PT95//30GDBhAYmIi7du3NzqiOLEq7p7U92sOQJOAtsSeiWTesslMHb4IyN7Q39xrKu98N41WDbvQwC+Y0BbXGhm52NIyUvh09SzW7gjndHw0Vdw9CazdjOs6jmFojylGxxNxSCnnIWYnnD8ONit41oQGV4JPIJhMRqcTkYpQ1L4AwOCrJ3Pfm534+pc3+XX31yyYusOouCIOoTjrzb9OxUfz1tL7mHXXj1T1qGbvqCVis9nIevJpSE7G8upLmCwXL1ewHThI5gNTsTw2DXOvngamLJhTFv2nTp1ixIgRhIaGsmrVKjw9PQEYM2YMTZo0AVDRL+VqTL9nueuV1oR1HU/LoE4ADOp+H1PmdWVH5FrmTdlscMLie/OrieyIXMukwW/StF47klMvcDBmGyfjjxkdTcTh2GwQ+Rsc2Zh7eHwMxO6G2o0h5CZwq2JIPBGxo/z2BSxmCxMHvc4jC67hmbFf55zCLCLZ8ltvAKxWK7M/vZ2R1zxG03pXGpiweEwmE5aHHyJzwiSs4Z9juW0UALa0NDLnvIypbx+HLfjBSTvymzNnDufOnWPx4sU5BT+Ar68voaGhgIp+KV8N6rSgW+ubWLziyZxhZrOZG7tO4KpWA6nhXcfAdCXz+55lDO8zjavbDiGwVhOa1WtH/87jGNPvaaOjiTicQ7/nLfgvdeYIbF8G1ix7JRIRo+S3LwCwae8P1PIJ5HDcLoOSiTiugtabJatnUq2qD0N6TDYoWcmZatfC8uAUrEs+xRoRAYD13cWQkYFl0gSD0xXOKYv+8PBwevbsSXBwcL7j/f39CQgIACAzM5MHHniAWrVqUaNGDe666y5SU1PtGVdcxPA+09gS8RM7ItflDDOZzJhMzrUa1fIJ5K/9K7iQfNboKCIOLS2x8IL/X/FRcOpgxecREeNdvi9wOHYXv+1ZxttTNrNi0/8Re+aQsQFFHNDl683uw7+xYtP/Me3WxcYGKwXz1d0x9buOrNmvYP1jI9bvf8Dy32mYqjn25Qkmm81mMzpEScTFxREYGMjUqVN59dVXc42zWq0EBgbSoUMHVqxYAcCMGTP48ssv+fHHH/Hw8GDQoEF07tyZuXPnFuv1MjMziYuLK/f5EPs79IM/6Rfcy/U5V25+n4jov5g8dF6xp/HwyaDpwBNlet2yzMvuw7/x4iejOX0+mkb+bWjdqCtXtRpI9zaDMZXi4uTymB8RR3R6T3VO7/ItRksb1eqm0bDv6QrPJCJlU577AjabjQff7sHoa5+gS+swfvrrA9bv+JwX7vq+yGm17RRnUp7rTWJKPBPfCOXh4f9H++bXlGja8lhv+kdGcCA9rUzPYUtJJXPS/RAbh3n0SCxjby/V87TwqMLKZvkfxC5IQEAAbm4lv0Lf6a7pT0pKAsi3OFm+fDknT57MdWr/u+++y0svvUT9+vUBePbZZxk+fDivv/46FkvR94uMi4sjKCiofMKLoRY9vJvGAW2MjkFERAS9x7ct03OUZV7aNrmaDx+LZF/UJv4++ge7Dm1gxke3cFXLAcy485sSF/7lMT8ijui5ccvodsWgYqwTJs5EZXK1thUiDq889wV+3PQuNav706V1GADXd7qDFZvf45ddX9MzZFih02rbKc6kPNebb/+Yz9kLscz/5qFcw6/vdAc393qogKmylcd64/bOfEyNG5XpOUyeVbEMv4WsufMw/3Ntf2lEREQQ1KdkHYFHRUXRoEGDEr+W0xX9QUFBWCwW1q9fn2v40aNHmTw5+5qQf4v++Ph4oqKicv0IEBoaSkJCAkeOHKFZs2b2ii0uqn/ncfTvPM7oGCVmsbjRpnF32jTuzvDeD7Nqy8fMCR/DzkMbaNest9HxRBxCSS7dMZuL/hFZRFzLwC73MLDLPbmGvTZxfQGtRQRgVN/HGdX3caNjlJ1b9nbfVIyDyI7A6Yp+Dw8Pxo4dy+LFixk8eDBhYWFERUWxaNEi/P39iYmJySnyExISAKhRo0bO9P8+/ndcUQICAoiKiirPWRCDZJ+aZHQKCA4OLvMyVd7z0tC/NQDxiSdLPG15zI+IIzq53Zez+4pz5osNn7oWrQciTsCV9gVE7MWV1pvyOL2/vAQHB7OyhPPzb791JeV0RT/A3LlzcXd3Z/ny5axZs4Zu3bqxdOlSZsyYwcGDB3M6+KtevToA58+fz3mD4uPjc40ripubW6lOoRDHE+UO6UaHANzd3cu8TJVlXqbO78017UcR3KATNbzrEHP6IIt/fAJvzxolvrYKymd+RBxRLS/4fV9xWppo2tmD+loPRByeK+0LiNiLK603bscOg4MU/W52/B5wyqLf29ubhQsXsnDhwlzDd+/eTUhICGZz9imZNWrUICgoiO3bt9OyZUsAtm3bRvXq1WncuLG9Y4s4hKtaDmDNtiV8uPJpktIuUMO7Llc26cUjIxbj6+VndDwRh1GtJtRrC8d3F97OqxYEtLJPJhEREZGScsqiPz/x8fFER0cTFhaWa/jdd9/Niy++SM+ePXF3d+fZZ59l3LhxxerET8QVjez7GCP7PmZ0DBGn0KofZGXCiQKO+HvVhg43g8XDvrlERETEOObr+2G+vp/RMYrNZYr+Xbt2AeTqtA/giSee4PTp07Rp0war1cott9zCnDlzDEgoIiLOxmyBtmHQoB0c3Qyn/7kFt08gBHUA/2Awu8yWVERERFyRy+yqFFT0u7m5MXfuXObOnWtAKnEWP/z5Lis3v4fJZOaBYfNpEhiSM+73Pd/w6ZpZuFs8COs6nmtDb8Nms/H6l/cSfWo/Hu6eTB3+LnVrBLFy8/t8vGoGdWs0BGDW3T9Sxd3TqNkSkXJgMkHNIPCsAb/+c1XZlYOgavG6hhERJxV39ggvfjIai8WdrKxMHhg2n6b1rswZP/uT24k9ewirNYubuk/i+k53GJhWxDhFrSup6cm8vXwKcWcPY7VmMfOu7zlx9ghvfDUes8mMxezG1OHvEli7qYFz4dpcpuifNGkSkyZNMjqGOKELyWf57o/5zJ28kdgzh5j79URenrAGAKvVyv/98BjzpmzCw60qDy/oQ9fWN7I9ci3ublV4bdIGIqK38H8/PMbjo5cAENblXp0+LyIi4uTq+Dbg9Um/Yjab2XZwDZ+umcWTt4fnjL+93zM0qNOC9Mw07n01hGvaj8LdTdf6SOVT1Lry0c/P0bfDaDo075szzNe7Di/853u8PH3ZvG8FH696nmkjFhsRv1Io/k2IRVzU/mObuLJZH9ws7gTVbcn5pNNYrVYAziefpoZ3XTyreGOxuBFUpyV7j/1J9KkIght0AqBF/VB2Hf4l5/lW/rWYB9/uwefrXjZkfkRERKTsLBa3nM6hk1Mv0LReu1zjG9RpAYC7xQOzyYzJVJxbfIq4nqLWlR2Ra/ljzzc8PL8PS1bNBKCmd128PH3/md4ds1n9rVUkFf1S6SWknKW6Z82cvz2rVCcp9TwANbzqEJ94kjMXYklOTWDX4V9ISDlLk8AQ/opYic1m46/9K3Pub3912yG8+8jfvDx+DTsPrWfrgdWGzJOIiIiU3cGY7Ux5qxvzlt1Ph+bX5tvms3Uv0SPkZtws7nZOJ+I4CltXDh3fQeeWN/Dy+DUciNnKjsh1OePSMlL48KdnGNbjATsnrlxU9Eul5+1Zk8SU+Jy/U9IS8Kqa/cujyWTigZsXMPuT25j1ySgaB7Sltk89rmo1gAZ+wTyy4Bo27f+RpoFX/vNcNbCYLbi7edCj7TAOxmw1YpZERESkHDSv3565k/9gxrhvmLfs/jzj124P52DMVsb1f96AdCKOo7B1xcfLj47B12M2m+kYfD2HYncCkJWVyYtLRjO89yO5+tOS8qeiXyq9Vg27sOvwBrKyMok5fRBfL7+cU5QArmzai5cnrOHJ28JJTU+idcOuANzR/zlenbiOblcMol3TPgAkpZzPmW7nofXU92th13kRERGR8pGemZbz2KuqL1Xcq+Uav3n/SlZs+j8eHflhrv0GkcqmqHUlpGkvDvxzICwi+i/q1W6OzWbj1S/upmPL/lzddog941ZKLtORn0hp+VSrxYCr7mbq/F6YTGYmD32bzftWkJBylr4dRrPg24c5GLMVi9md/wx4AXc3D84nnWbGh7dgMbtRt2ZD7hvyFgBfbHiVLftXYjKZaRnUme5tBhs8dyIiIlIae478xkc/PYvZbMFmszHhptdy7R+8HH4HtX3r8fii/gA8eVs4tXwCDE4tYn9FrSt3D5zNa1/cTXpmKo3823BVqwH8tX8lG3Z+zolzR1i3PZxm9dozafAbRs+KyzLZbDab0SFE7OGPxZB0xugU4FUbut1ZtudwlHmB8pkfEWeQmnDxln09xuuWfSLOyFG2n9p2ijNxpfWm3e+/sDcpsXwClVFrL292dO9pl9fSuUgiIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qLUkZ9UGp41yja9zQrJ57IfV6sJplL+ZFbWHOXxHOU1L+WRRURExF4cZfupbac4E1dab5p6Viu6kZ3YM4s68hMpJlfqxMuV5kXEXrTeiIi+B0RKTuuN8XR6v4iIiIiIiIiLUtEvIiIiIiIi4qJU9IuIiIiIiIi4KBX9IiIiIiIiIi5KRb+IiIiIiIiIi1LRLyIiIiIiIuKiVPSLiIiIiIiIuCgV/SIiIiIiIiIuSkW/iIiIiIiIiItS0S8iIiIiIiLiolT0i4iIiIiIiLgoFf0iIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qJU9IuIiIiIiIi4KDejA4jj2r4UUuKNTpHNswa0H2p0ChERkZJzpO2ps9B2v2iOtFw50+e1aB2cSTQ6BdT2hnv6GJ1CKgsV/VKglHhIOmN0ChEREeem7alUBC1XpXMmEeLOG51CxL50er+IiIiIiIiIi1LRLyIiIiIiIuKidHq/A0lJh5MXICMLLObsa318PI1OJSIiIiIiIs5KRb/B4s7DbxGwLxZOJeQd7+sJzf2he3NoWhdMJvtnFBEREREREeekot8gZxPhy83w9/HC251PgS1Hsv/Vqwm3XgWN/eyRsGReCh/Hz1s+AMBsMlPLJ5D2zfpy18AX8fOtb3A6ERERkcpL+2kilZuu6TfApkMw5/uiC/7LHT8Hb/4E324Dq7VispVFSJOefPZULEuePMbjoz/h4PFtPP/RcKNjiYiIiFR62k8TqbxU9NvZmr/hkz8gLbN009tssPpvWPKH4xX+bhYPavkE4Odbnyub9iKsy738ffQPklIvGB1NREREpFLTfppI5aWi3442HYJvthXexmzKvo7f1zP7cUG2HIFlW8s1Xrk6ff44G3Z9idlswWy2GB1HRERERP6h/TSRykVFv52cS4KvNhfdrnpVeG5Y9r/qVQtvu2E/RMSVT77ysOPQOm560psbn6jGqJn12XVoA8N6PIinhxcAp8/HMPqFhpxLPAlAanoyd8xpweHYXUbGFhEREXF5Re2nzfjwFr7f+E5O+4Mx2/jPy61Jz0g1KrJTee/BxkZHECmQUxf9O3bsYPDgwfj6+uLj48OQIUOIjY2levXqjBw50uh4uXy5ufSn9BcmfCNkZpX/85ZGq6AuLHhoO29N2cRt1z3FFY26cecNM3PG+/nW55ZeU1n4zVQAPvrpWXq0GUqTwBCjIouISAWyZsH543DmKCScyr5ETUSMUdR+2qTBbxK+5kXOJ53GarXy5tcTuX/IPDzcizgKJSIOz2l771+9ejU33ngjjRo1Yvr06Xh6evL+++8zYMAAEhMTad++vdERc5y4AHtiKua5zybBzigIbVwxz18SVdw9qe/XHIAmAW2JPRPJvGWTmTp8UU6bwVdP5r43O/H1L2/y6+6vWTB1h1FxRUSkgmRlwtFNEL0D0pMuDvfyg0adILCNbkH7r52HNvDl+leJPL6dk/HHGNf/eW67brrRscQFFbWf5udbn5t7TeWd76bRqmEXGvgFE9riWiMjO4X1Hz9E9N9rSTp3nCVPtKdmYEsGTv7M6FgiuThl0X/q1ClGjBhBaGgoq1atwtPTE4AxY8bQpEkTAIcq+n8/ULHP/2uEYxT9lxvT71nueqU1YV3H0zKoEwAWs4WJg17nkQXX8MzYr3NOKRMREdeQlQHbvoL46Lzjkk7D3ysg4SQEX6PCHyAlLZFG/lfQt8No5n/zoNFxpBLJbz9tUPf7mDKvKzsi1zJvSjGuS3VhmekpbF4+i/0bw0k8G42bhye+dZvRuscY2vefktOu9+2vA9mn9982a7tBaUUK55Sn98+ZM4dz586xePHinIIfwNfXl9DQUMCxiv79sRX7/IdPV8ylA2XVoE4LurW+icUrnsw1fNPeH6jlE8jhOF3LLyLiag6sy7/gv1TUVojba5c4Dq9L64HcNfBF+rQfgbtbFaPjSCWS336a2Wzmxq4TuKrVQGp41zEwnfHWLJ7I3l8/pOeolxkz529ufmIt7frdR1pyvNHRRErMKYv+8PBwevbsSXBwcL7j/f39CQgIAODzzz+nR48eeHt707hxYzumzJaWkX16f0Wy2SDmbMW+RmkN7zONLRE/sSNyHQCHY3fx255lvD1lMys2/R+xZw4ZG1BERMpNRioc3128tsf+0jX+Ika7fD8NwGQyYzI5ZYlQriK3LKNj2DSadRqCb90m1GnUjit6jaPL0KeNjiZSYk53en9cXBwxMTGMGDEizzir1cquXbvo0KFDzrCaNWty//33c+LECV5//fUSv15mZiZxcaXvIv9Egjs2m3+uYWZTwT3z+3jm//hSCalgvWxHad/Rs3ikJ5c6Z34yMvwB92K1fXTk+/kOb9O4Oz+/nB3WZrPxxlcTmDjodfx863NH/xnMWzaZF+76vhhZMoiOPlHc6BUiI9kCBAIQGxuL+3kH6UGxFFxpXkTsRetN0eIPVcOaVatYbRNOwuG9cXj4OOCpauWsJNtTyeYI2/38ONL3QHnvp5Uti2N+Xvkp7vvmVSOQIztX0LL7aKp6F+97rWQ5nOc9KytHWm+cXUBAAG5uJS/hna7oT0rK7hHIlM+FgMuXL+fkyZO5Tu3v168fAMuWLSvV68XFxREUFFSqaQECW3Tj1md+zzXs39vyFeXhAfkPf+ZrOJ+Se9jjTz7Nzp/fLmXK/C16eDeNA9qU2/P9uOldalb3p0vrMACu73QHKza/xy+7vqZnSOFvSEREBL3Hty23LKXh51ufT6dnn7N61VWdOX2+gnpntANXmhcRe9F6U7Rbej/M+BtfKXb7QWE3s+fI70U3dHLlvT2tDBxhu58fR/oecKTlylE/r/zcPns3tRsU/b5dd/e7rHh7NO9MrEOtBm0IbN6Vxu0G0rTj4HzrkJKKiIggaJhzvGdl5UjrjbOLioqiQYMGJZ7O6Yr+oKAgLBYL69evzzX86NGjTJ48GXCs6/mzMtLs8jrWzHS7vE5ZDOxyDwO73JNr2GsT1xfQWkREnE1yasmuZ0sqYXsRqXj9O4+jf+dxRscwXL3gqxn3WiRxkZuIO/gHMfs28P3cW2jcbgA3Tf0mT+Ffq/4VBiUVKZrTFf0eHh6MHTuWxYsXM3jwYMLCwoiKimLRokX4+/sTExNTrkV/QEAAUVFRpZ4+NcPEvMsOYiSkZh+tz4+P58Uj/K/+CBdS8rZJSM07bOGbL9CwZvleY3ToB3/SHWR/LDg4uEyfQ3nISLYQ+U32402bNuNezXlPTXKleRGxF603RctINhP5rQ1sRR0Fs+HuncmGTT9Wih78HWl76iwcYbufH0f6HnCk5cpRP6/8LN7sz5liXhFrtrhRL7g79YK7EzrwYfb9+jErF4whZt8GGrTunavtkGk/lCiHM71nZeVI642z+7ffupJyuqIfYO7cubi7u7N8+XLWrFlDt27dWLp0KTNmzODgwYMFdvBXGm5ubqU6heJStXfCmcSLf1tteU/Pz8+FlOK1A2jfsg7VPEqXryBR7uAo5w+4u7uX+XMoq9QEiPzncWBgIFWrGxqnTFxpXkTsRetN8SS0gJMRRbUy0biTO0FBxn6v20th29OUtERiTh8EICMrnbMJcRyM2Y5nFe+ce6pXRo6w3c+PI30PaD+tdNy3l37amvVbA5By4WTZczjRe1ZWjrTeVFZOWfR7e3uzcOFCFi5cmGv47t27CQkJwWx2rB5HW/jnLvrLW/2alHvBLyIiUhqtrs3upC8lvuA2fs0gKNRukRxaRPRfPLLgmpy/v/n9bb75/W2ubNqbVyeuMy6YSCX35czeBHcbhX+TTnj61CE+7iC/f/EEVarVoMEV1xT9BCIOxCmL/vzEx8cTHR1NWFhYruFZWVlkZGSQkZGBzWYjNTUVk8lElSr2uxdu9xawMbLodmV5fhEREUfg4QWdR0PEWjixH2zWi+PcPKBBe2h6NTjY7/OGadesT7n0ni4i5avRlQPY/9sSNn71NOkpF/D0qUv9lr3od+9iPKv7GR1PpERcZpO7a9cuIG8nfh999BGenp7ceuutHDt2DE9PT1q2bGnXbA1rQ+MK+m6o5gGdGlfMc5dE9KkIbvivO38f3Zhr+Ic/PcttLzTi8UU35AxLTU9mylvdGPJUDdZuD7d3VBERqWAe1aBtGHS+7eKwVv2g50Ro3gvMFuOyiVRGBe2n/evh+X1446sJJZrG1XUe9BjDn/6Fe/93kvsXp3LXm8e4YdLH1FaHfeKEXL7oHzduHDabLde/I0eO2D3frVeBuQI6KxrWCao4wK1/P171PFc27Z1neFjX8bwyYW2uYe5uVXj2jqUM6/mgndKJiIgRPKpdfOzXFCwOsL0SqYwK2k8D2Pj3d1Srkvci68KmERHn4jJF/6RJk7DZbHTt2tXoKPmqVxNuuLLodv/27P/M1/n30n+pK4OgY+NyiVcme4/9Sa3qAfj55u2MpLZPICZT7sXMYrZQy6d0PU+KiIiISPEVtp9mtVr55ve3GdT9vmJPIyLOx2WKfmfQrw10K6Ij3n979j+fkv24IE3rwG3dcYhbHX2y+gVGXvOY0TFERERE5DKF7af9tOUDeoQMw8O9arGnERHno6LfjkwmGH5VdvFfllq9XRCM7wtVHKAbxj/3fk9wg074eNU2OoqIiIiIXKKw/bT0jFTWbF1C/053FnsaEXFODlA2Vi5mE4S1hyvqw6cb4eSF4k/rVSX7Gv7QRo5xhB/g4PHt7Ixcx+NHfudw3C6iT+3nmTu+prZPoNHRRERERCq1wvbTYs8eJjE1nunv3UhCylnOJsTx818fcvJ8lPbtRFyMin6DNKkD/w2Dv2PgtwNw4ARkWfO2MwENasHVLaBDY8c4un+p2659ktuufRKAl8LHcWO3CRw6voMdkWvp22E03298h5+3fEjUyX08uvA6Hh35IX6+9Xjug5s5eHwbVT282HfsTyYOet3gORERERFxLUXtp/3vgb8A2BG5jrXbw+nXaWzOdJdOo4JfxLk5WAlZuVjMEBKU/S8zC2Lj4dApWLole/ydPaFlIFR1kt6OHx35fp5hYV3vJazrvXmGP3PHV3ZIJCIiIiKQ/37av9o160O7Zn1KNI2IOA9d0+8g3CwQVBvaNbw4rJGf8xT8IiIiIiIi4nhU9IuIiIiIiIi4KBX9IiIiIiIiIi5K1/RLgTxrGJ3gIkfKIiIiImI0R9o3cqQsRantbXSCbI6SQyoHFf1SoPZDjU4gIiIiIvnRflrp3NPH6AQi9qfT+0VERERERERclIp+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhEREREREREXpaJfRERERERExEWp6BcRERERERFxUSr6RURERERERFyUin4RERERERERF6WiX0RERERERMRFqegXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERbkZHUAc16J1cCbR6BTZanvDPX2MTiHi2rYvhZR4o1MUn2cNaD/U6BQiIsZwpO/sivg+zly8AduZhPJ9Uhdnql0dtzt7GR3DoTnScmXPz0tFvxToTCLEnTc6hYjYS0o8JJ0xOoWIiBSHq39n284kwIkLRsdwKjajAzgBR1qu7Pl56fR+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhERERERF/ZS+Dj6TTPRb5qJ/o9aGDWzAXM+Hcvp8zFGR3NY14U/z/iV7+QZfuT8KTxeGc1v0fsMSCX25ErLgIp+EREREREXF9KkJ589FcuSJ4/x+OhPOHh8G89/NNzoWCJiByr6RURERERcnJvFg1o+Afj51ufKpr0I63Ivfx/9g6RUx7h9mYhUHBX9IiIiIiKVyOnzx9mw60vMZgtms8XoOCJSwdyMDiAiIiIiIhVrx6F13PSkNzablbSMFABu6fUwnh5eAMz48BY6Bl9PWNd7ATgYs41Zn4xmwYPb8HCvalhuR9c3fAYX0lLIsGbSo0Er5l57JxazjqtWJv/5YT4rD++gTjUftt/5ktFx8uXUS+SOHTsYPHgwvr6++Pj4MGTIEGJjY6levTojR440Op6IiIiIiENoFdSFBQ9t560pm7jtuqe4olE37rxhZs74SYPfJHzNi5xPOo3VauXNrydy/5B5KviLsGzoI/x1x4tsH/cSp5Iv8GXERqMjiZ2NC+nDd7f81+gYhXLaI/2rV6/mxhtvpFGjRkyfPh1PT0/ef/99BgwYQGJiIu3btzc6YqWWmZ7C5uWz2L8xnMSz0bh5eOJbtxmte4yhff8pRscTKZHMNIj9G05HQlYGeFSDgDbg1xQqw4/5Ow9t4Mv1rxJ5fDsn448xrv/z3HbddKNjiYhICVRx96S+X3MAmgS0JfZMJPOWTWbq8EUA+PnW5+ZeU3nnu2m0atiFBn7BhLa41sjIhvKpUo3zacl5hsenJQFQ1c0jpx1ApjWL9KxMTJjsF1IqVHGXgV5BrTly/pRds5WUUxb9p06dYsSIEYSGhrJq1So8PT0BGDNmDE2aNAFQ0W+wNYsnEv33WnqPeRO/hu1IT7nAqaPbSDhzzOhoIiVy8gDs+SG72L98uGcNaD8MvGoZEs1uUtISaeR/BX07jGb+Nw8aHUdERMrBmH7PctcrrQnrOp6WQZ0AGNT9PqbM68qOyLXMm7LZ4ITGalmrHl9HbCTLas11uv5fsZFYTGaa1fDPGdbvs5lsP3mEG5q05+bgLkbElQpQkmXA0TnlMao5c+Zw7tw5Fi9enFPwA/j6+hIaGgqo6Dda5JZldAybRrNOQ/Ct24Q6jdpxRa9xdBn6tNHRRIrtzBHY+U3egv9fKfGw5TNITbBnKvvr0nogdw18kT7tR+DuVsXoOCIiUg4a1GlBt9Y3sXjFkznDzGYzN3adwFWtBlLDu46B6Yw3of11nEi6wN0rFrA17hCR8ScI3/s7z/72BXe07U2Nql45bX8eMZ1jE/5HSmY6a4/tMTC1lKeSLAOOzimL/vDwcHr27ElwcHC+4/39/QkICCAtLY177rmHpk2bUr16dYKDg3nrrbfsnLZy8qoRyJGdK0hNPGt0FJFSsdkgYg1gK7xdehIc3WSXSCIiIuVqeJ9pbIn4iR2R63KGmUxmTCanLBHKVSPfOqwf/SznUpMYuvQVOr7/GHP+XM7Uzjfy1nV35mnv6e7BoOad+PbgXwaklYpQ0mXAkTnd6f1xcXHExMQwYsSIPOOsViu7du2iQ4cOAGRmZhIQEMBPP/1E06ZN2blzJ/3798ff359bb721WK+XmZlJXFxcuc5DYRLSLEAgALGxsSRWybLba18uI8MfcC/VtNfd/S4r3h7NOxPrUKtBGwKbd6Vxu4E07TgYk6nk1zplZGQQHX2iVFnKS0Zy7s/G/bxxn01ZudK8VJTkkx4kna1bjJY2YnbZ8GwWi9mtiF8IHFxZ1nkj2Pt7QetNyek9y+Zs65YjcITtfn4caZkuyXL16Mj38x3epnF3fn657Nuuivi8amdkGl6otKvbiGXDphU4/nxaMulZmdSp5kOmNYsfDm2ld9AVdkyYW2ZGJieiow17/YI40npT0uWqqGWgLErzeQUEBODmVvI1w+h1qcSSkrI7TsivcFy+fDknT57MObXfy8uL559/Pmd8+/btGTRoEL/++muxi/64uDiCgoLKHryYvGvV56652R/+VVd1JvFsjN1e+3K3z95N7QZtSjVtveCrGfdaJHGRm4g7+Acx+zbw/dxbaNxuADdN/abEhX9ERARBw9qWKkt58fOtz6fTL342p88b99mUlSvNS0W5pddUxt/0ajFamrBmmuh7dRiRx3dUeK6KtOjh3TQOKN06b4SIiAh6j7ff94LWm5LTe5bN2dYtR2Dv9bu4HGmZdqTlqiI+r+3jXuIKvwbl+pzlLT41iRHfvEF6ViZZNivXNQrhnnbGdX4YERFB+6Ahhr1+QRxpvamI5WrkN2/we0wEp1MSaLLgfv7bZTATOvQrcrrSfF5RUVE0aFDy/E5X9AcFBWGxWFi/fn2u4UePHmXy5MlAwdfzZ2Rk8Msvv/DII49UdEwBzBY36gV3p15wd0IHPsy+Xz9m5YIxxOzbQIPWvY2OJ1Ios9lSsvamkrUXERFxRP07j6N/53FGx3AKjXzrsHHMC0bHEIOFD3rQ6AhFcrqi38PDg7Fjx7J48WIGDx5MWFgYUVFRLFq0CH9/f2JiYgos+u+//36qV6/O2LFji/16AQEBREVFlVP6oiWkWVj4z+09N23aTHUDT+9fvNmfM3nvUlFqNeu3BiDlwskSTxscHGzXzyE/GckWIr/Jfrxp02bcqznvaaquNC8VJSGmKjG/FKelDczw8/pvsFRx7tP7D/3gT/oFo1MUn72/F7TelJzes2zOtm45AkfY7ufHkZZpR1quKuLzqv3RFjhbjjuilYDWm6I50nJVms8rICCgVK/ldEU/wNy5c3F3d2f58uWsWbOGbt26sXTpUmbMmMHBgwfz7eBv6tSp/PHHH6xZswYPD49iv5abm1upTqEorfhLlsHAwEBqVLPbS+fhvr300345szfB3Ubh36QTnj51iI87yO9fPEGVajVocMU1Jc/i7m7XzyE/qQkQ+c/jwMBAqlY3NE6ZuNK8VBRrPTi9DdISi2ppIqAVNGpW3x6xKlSUO6TnMzwlLZGY0wcByMhK52xCHAdjtuNZxTvnns9GsPf3gtabktN7lq2gdUsK5gjb/fw40jLtSMtVRXxeGe7OfcmcEdzc7Vu3FJcjrTeOtFzZ8/NyyqLf29ubhQsXsnDhwlzDd+/eTUhICGZz7h5HH3zwQVavXs2aNWvw8/OzZ9RKq9GVA9j/2xI2fvU06SkX8PSpS/2Wveh372I8q+szEMdnNkOzq+HvlUW0c4PGV9knk1Eiov/ikQUXf6z75ve3+eb3t7myaW9enbjOuGAiIiIiUiSnLPrzEx8fT3R0NGFhYbmGT5kyhTVr1rB27Vrq1Knc9xu1p86DHqPzoMeMjiFSJvVCICMVDqzPf7zFA9oNAW8X/x2rXbM+5dK7s4iIiIjYn8sU/bt27QJyd+J39OhR3nrrLapUqUKTJk1yhvfs2ZMff/zR3hFFxAk16gy1m8DRzRC7J3tYtZpQr232jwIeBl6CIyIiIiJSFJcu+hs1aoTNpqNTIlI23n7QrMfFoj/0VirttckiIuKc4s4e4cVPRmOxuJOVlckDw+bTtN6VOeNnf3I7sWcPYbVmcVP3SVzf6Q4D0xYs4mws7d9/lLUjn6ZLvRa5xh2KP8H4lYtIz8pkcItOTO18I8kZafT//AX2nT3OvH7/YUSr7oU+/6nkCzyw+n1OJ1+gmnuVPPdon7vlR8L3/oa72Y0O/o1549pxhT7fzN+/ZtXRnVS1uPPugAk0qF67yNdLz8pk7PfzOJF0nkxrFm9eO47QgKbM/P1r1h3L3hk5GB/HI1fdxP2hNxTznZOS8H1jHJ0DmgFwf8cbGNKic54214U/T8va9Xi73105wwpbPo3kMkX/pEmTmDRpktExREREREQcTh3fBrw+6VfMZjPbDq7h0zWzePL28Jzxt/d7hgZ1WpCemca9r4ZwTftRuLsVv/Nre5m1cSm9GrTKd9wTGz7l+Z630iWwBdd99jxDW1xFQx8/vhgylXe2ryrW8z+67mOe7n4zrWrn30HvwKYdmBx6AyaTidu+ncuGqL30Cmqdb9s9p6P54/h+1o16llVHdvHMr1/wfwMmFPl6a47uxsejGuGDHmRT7EFe/HM5Xwx+iOndhzG9+zAArvrwCYa2cPFOhQwU5FObVSOfKnD895Fb8faommd4YcunkcxFNxEREREREWdmsbjldHadnHqBpvXa5RrfoE72UUl3iwdmkxmTyWT3jEXZFHuQgGq+1L/saPm/9p05Ttd6wZhMJgY07cAv0fuwmM0EeNUo1vNnWa38fSaalzd9y7XhM3hv59o8bZrXDMh5b9wtblgKeZ9+i97HwKahAFzbqC1bTxwu1us1reFPWlYGNpuN+NQk6njmPr1wz+loalSpRv3qtYo1X1JysYnxXBs+g9u+ncvJpPO5xlltVhZs+5mJHa7PNbyo5dNIKvpFRERERCqBgzHbmfJWN+Ytu58Oza/Nt81n616iR8jNuFnc7ZyuaC9uXMa0LoMKHG+95LLemlW9OJda5H13czmZfJ6dJ4/xUKcwfrjlcd7fvY7I+BP5tv0teh/HE87SvX7LAp/vbGoiNap6AWAymciyWov1eo18/EjOTCdk8SPcu/Id7rvsFP5P9/7KyNZXl2jepGT23/06q0c+zY3NO/Lo+iW5xn20ewNDgjtT9bJ1pKjl00gq+kVEREREKoHm9dszd/IfzBj3DfOW3Z9n/Nrt4RyM2cq4/s8bkK5wP0Ruo6N/U2p7FtypzqUH3eNTk6hZ1btEr1GzqhdB1WvTtk4QVdzc6dGgFX+fjs7Tbu+ZGB7f8Cmf3DSl0DMialb14nxqEgA2mw3LZbcVL+j1PtqzgcY+fuz+z6usG/Us41e+kzONzWZjacRmhgXr1P6K5FfNB4DhLbuy/cSRnOGpmel8uvc37mjbO1f74iyfRlLRLyIi5eal8HH0m2ai3zQT/R+1MGpmA+Z8OpbT52OMjiYiUqmlZ6blPPaq6ksV99y3n9m8fyUrNv0fj478MOcyAEey49RRNkT9zY1fzmb10V08svYjYhPP5WrTunZ9NscexGazseLwDno0KPgofEJ6CvH/FOT/qurmQUMfP2ISzmKz2dh+4gjNavjnanPswmnu+nE+Hwy8L6cwBIhJOJvnSH6PBq1ZeXgHAOui/ibUv0mu8QW9ng1yiseaVb04n5acM83vMftpXbt+zhkEUv6S0lNzPstfovfRrObFZeDw+VPEpyUz5OuXeXzDJ6w4tJ2P9mwo1vJpJJfpyE9ERBxDSJOeTL/9c6y2LI6fieStpffx/EfDefP+342OJiJSae058hsf/fQsZrMFm83GhJteY/O+FSSknKVvh9G8HH4HtX3r8fii/gA8eVs4tXwCDE590eNdh/B41yEA3PXjAu5tdy2B3jVZeXgHZ1MTGdX6amb2HMmElYvIsGZxU/OONP2nYL91+evsOHmEau5V2RwbySvXjOHzfX+Qkpmep/f7l68Zw9jv55FhzaJ/k3Zc4deAuKR43vjrB2b3Hs3j6z/hTEoC96xYCMC0LoPo36QdY76fx9dDHs5VjLfxa0DHgKb0+fRZqljcWXTDeAA+3L2eIB8/rmnYJt/Xa+Tjx5jv3+ba8BkkZ6TzXI9bc57z072/MbJ14XcgkLLZf/Y4E356F2+PqribLbzd765cy9nGMS8AsP7Y33y+/w/GtOkFkO/y6ShU9IuISLlys3jk7Cj6+dYnrMu9vL18CkmpF/Cq6lPE1CIiUhE6NO9Lh+Z9Cxz/+TNxdkxTNpf2gN+/ycUOCZvXDMi3x/XPBz+UZ9ie01E83nVonuEd/BuzeuTTuYYFeNVgdu/RACy5aUqeaTKyMmnsUyffo+9PX30LT199S65hYy85NTy/1/PyqMrXQx/O81wA8y65PZxUjNCApmwaOyvXsOY18/4A1rvhFfRueEWe4ZffocERqOgXEZEKc/r8cTbs+hKz2YLZbDE6joiICACv9b2j3J7L3eLGewMnltvziZQ3x7tgR0REnNqOQ+u46UlvbnyiGqNm1mfXoQ0M6/Egnh7ZR0BOn49h9AsNOZd4EoDU9GTumNOCw7G7Ch0nIiIiIiWnol9ERMpVq6AuLHhoO29N2cRt1z3FFY26cecNM3PG+/nW55ZeU1n4zVQAPvrpWXq0GUqTwJBCx4mIiIhIyen0filQ7ZLd5aRCOVIWESlcFXdP6vs1B6BJQFtiz0Qyb9lkpg5flNNm8NWTue/NTnz9y5v8uvtrFkzdUaxxIiKSzbNG2aa3WSH5n87Fq9UEUxkOBZY1S35MtatjK/+ndWmm2o55uzhH4kjLlT0/LxX9UqB7+hidQERcwZh+z3LXK60J6zqelkGdALCYLUwc9DqPLLiGZ8Z+nXPqf1HjREQkW/u8fdCVSGoC/JrdAT2ht0JVB6sX3e7sZXQEcUGVdbnS6f0iIlKhGtRpQbfWN7F4xZO5hm/a+wO1fAI5HJf3ev3CxomIiIhI8anoFxGRCje8zzS2RPzEjsh1AByO3cVve5bx9pTNrNj0f8SeOZTTtrBxIiIiIlIyKvpFRKTcPDryfV4avyrP8DaNu/PzyzbaNeuDzWbjja8mMHHQ6/j51ueO/jOYt2wyQKHjRERERKTkVPSLiIhd/bjpXWpW96dL6zAAru90Bynpifyy6+tCx4mIiIhIyakjPxERsauBXe5hYJd7cg17beL6XOMLGiciIiIiJaMj/SIiIiIiIiIuSkW/iIiIiIiIiItS0S8iIiIiIiLiolT0i4iIiIiIiLgoFf0iIiIiIiIiLkpFv4iIiIiIiIiL0i37RESk3B2J28MbX43HbDJjMbsxdfi7BNZumjP+w5+eZeXmxTSs25oX71lRrGlEREREpOR0pF9ERMqdr3cdXvjP97w2aQO39nmUj1c9n2t8WNfxvDJhbYmmEREREZGSU9EvIiLlrqZ3Xbw8fQGwWNwxmy25xtf2CcRkMpdoGhEREREpORX9IiJSYdIyUvjwp2cY1uOBCp1GRERERPKna/pFpNLYvhRS4ks3rc168fHWz8FUhp9MPWtA+6Gln95ZZGVl8uKS0Qzv/QhNAkMqbBoRERGR4ijLvmB5s+f+oIp+Eak0UuIh6UzZnyf5XNmfw9XZbDZe/eJuOrbsz9Vth1TYNCIiIiLFVV77gs5GRb+IiJS7v/avZMPOzzlx7gjrtofTrF57Ore8gYSUs/TtMJrvN77Dz1s+JOrkPh5deB2PjvyQw7E780wzafAbRs+KiIiIiFNT0S8iIuWuc6sb+G5WcoHjw7reS1jXe3MN8/OtV+g0IiIiIlJy6shPRERERERExEWp6BcRERERERFxUTq9X0TkMi+Fj+PnLR8AYDaZqeUTSPtmfblr4Iv4+dY3OJ2IiIiIVDRX2h/UkX4RkXyENOnJZ0/FsuTJYzw++hMOHt/G8x8NNzqWiIiIiNiJq+wPqugXEcmHm8WDWj4B+PnW58qmvQjrci9/H/2DpNQLRkcTERERETtwlf1BFf0iIkU4ff44G3Z9idlswWy2GB1HREREROzMmfcHdU2/iEg+dhxax01PemOzWUnLSAHgll4P4+nhBcCvu5by0c/P5Zrm2Mm/mTToTW7qPtHueUVERESkfLnK/qBTF/07duzg6aefZt26ddhsNvr27cv8+fMJDg4mLCyM8PBwoyOKi7DZIOnsJX9bjcsi9tEqqAuPjvyA9MxU1u/4nG0HVnHnDTNzxvcIGUqPkKE5f/+2exnv/fgE/TrdYURcERGpYDYbJJ+7+Lc1y7gsIs7EmdcbV9kfdNqif/Xq1dx44400atSI6dOn4+npyfvvv8+AAQNITEykffv2RkcUF2CzQeweOLYFEk9dHL55CTToAI07g9lp1yIpTBV3T+r7NQegSUBbYs9EMm/ZZKYOX5Sn7an4aN5aeh+z7vqRqh7V7B3VLv7c+wPv/fgEUSf3UssnkCFXT+GW3lONjiUiYhdx++DoZkg4cXHY5iXQoB007gIWd+OyiTiqE/vg6F9wIe7isM0fQ/320OQqsHgYFq3YXGV/0CnLlVOnTjFixAhCQ0NZtWoVnp6eAIwZM4YmTZoAqOiXMrPZIGIdRG3JOy49GQ79BmePQYdh2thXBmP6Pctdr7QmrOt4WgZ1yhlutVqZ/entjLzmMZrWu9LAhBVnf9RfPPP+YIb3foQnbvuUfcf+5M2vJ1DFoxo3dZtgdDwRkQp18Fc4sjHv8IwUOLwRzhyF0OHg5gQFjIi9HPo9+9/lMlKz16ezR/5Zb6rYPVqZOOv+oFN25DdnzhzOnTvH4sWLcwp+AF9fX0JDQwEV/VJ2cXvzL/gvFR8FBzbYJ48Yq0GdFnRrfROLVzyZa/iS1TOpVtWHIT0mG5Ss4n214TVaBnXmroEv0si/Nf07j2PI1ZP5bO1so6OJiFSokwfyL/gvdSEW9q+2Tx4RZ3AqMv+C/1IX4mCfE643zro/6JRFf3h4OD179iQ4ODjf8f7+/gQEBAAwadIkgoKC8PHxoX79+jz44IOkp6fbM644IZsNjv1VvLbHd0FmWsXmEccwvM80tkT8xI7IdQDsPvwbKzb9H9NuXWxssAq258hvdGp5Q65hnVrewIlzRzkVH21QKhGRinesiB///xW3F9KTKjaLiLMo6qDZv07shbTEis1SEZxxf9DpTu+Pi4sjJiaGESNG5BlntVrZtWsXHTp0yBl2//338/LLL+Pl5cXp06cZPnw4s2bN4tlnny3W62VmZhIXF1d0w3KSkGYBAgGIjY0lsYqT9XbhItIvuJFwMqBYba2ZsH/TWXybJFdwqvKTkZx7OXM/XzmWs4wMf6DoazEeHfl+vsPbNO7Ozy/bAEhMiWdO+BimjXgfH6/aJcyRQXT0iaIb2llB78/ZhFhqVc+9Pvz799mEWOrUaGCPeHnY+32srOtNWeg9y1bc7x65yBG+JzOSLcRHBxarrc0K+zedo2YL56n8tX5KRchMMXP2WL1itbXZYP+meGoF26/yL8n3sSPuDwYEBODmVvIS3umK/qSk7C9Tk8mUZ9zy5cs5efJkrlP7r7jiipzHNpsNs9nMgQMHiv16cXFxBAUFlT5wCXnXqs9dc7OPnF11VWcSz8bY7bXlojaNr+aN+34tdvtnp7/Alxteq8BE5cvPtz6fTr+4nJ0+XzmWs0UP76ZxQJtyea5v/5jP2QuxzP/moVzDr+90Bzf3eqiAqbJFRETQe3zbcslRnsrz/bEHe7+PlXW9KQu9Z9mcbd1yBI7wPdmsXnsWPLSt2O1fevENPv55RgUmKl9aP6UiNPZvw6JHdhe7/WsvvcUHK5+uwES5lff3sb33B6OiomjQoOQHW5yu6A8KCsJisbB+/fpcw48ePcrkydnXUFx+Pf/s2bOZOXMmSUlJ1K5dm9mzdR2qFC457UIJ2ydUUBJxVKP6Ps6ovo8bHcMualUP5GxC7jOeziWeyBknIhUvJS2RO19qyXPjltEyqLPRccosOTWBcXNa8OI9K2lWr53RcfJV4n2B1JK1F3FFSSVcb1KcfB/aWfYHTTabzWZ0iJL6z3/+w+LFixk0aBBhYWFERUWxaNEi/P392blzJ3v37qVVq1Z5ptu7dy9LlixhwoQJxf6FxIjT+xduzN6JHt81luo6vd8QNhsc+i6AjCQLkPesklxMNpoNisXd02qXbOUhI9lC5DfZy1mzQbG4V6scy9mhH/xJv2D8KbYePhk0Heh4p/cX9P7MWjKaE+eO8ub9v+UMW/Tdo6zf+TkfP3HEjglzs/f7WFnXm7LQe5atPL573l/xFIdidzLjzuUcO7mPSW+EMmnwmwzsck9Om7izRxj/ejvGXPcMt/Seyo7IdTz6znW88J8f6NTy+px2+45t4sG3r+bJ2z+jZ8iwEuVYs+1TXvlsHG9N2ZSrWM/KyuTBt6/Gx8sPqzWL5LQLvDbpFyxmS06bA9FbmTKvK4+NWkLvdsP5bO1LbIn4iZfGr8rzOo7wPWmzweEV/qSfd6PIfQFsNA2Lw6O68yzjWj+lIthscGRlXdLi3Sl6vYEmA+Oo4pNZ8cH+4Sj7glC677lKc3o/wNy5c3F3d2f58uWsWbOGbt26sXTpUmbMmMHBgwcL7OCvdevWtGvXjjFjxrB27dpivZabm1upTqEorfhLLgsPDAykhmPd4rFSsXaGA+uKble3hYkmLYp37ZKjSE2AyH8eBwYGUrW6oXHsJsodHKEbT3d3d7t+rxRXQe/Pzb0e4oF53Xnvxye5ruMY9h37k2W/vcWEQa/bPeOl7P0+Vtb1piz0nmUr63dPekYq3/4xn0dHfghAw7qtuCfsZeZ/8xDtml1Dfb/mZFmzmP3p7QQ36JRzSmm7Zn24uedDvPL5nbwzdSc+XrVJSU/ixU9v47qOYwos+HdEruPlz8bl+6Ne3w6j2LT3e2Z/chtvP/AXHu5Vgeyeq+POHWHGf77Fas1i/GtXEr7mRW67bjoAaRkpzP70dvp2uI3e7YYDcH3ncSxe8SSH43bTJCD3Ka6O8j1pugr2/Vx0u9pNTDRt7VxnPmn9lIpi7gJ7VxbdrlYjaHZF8frQKi+Osi8I9v2ec8re+729vVm4cCFxcXEkJCTw008/0a1bN3bv3k1ISAhmc8GzlZGRQUREhB3TirMK6gC1mxTextMXWl1rnzwiRmkZ1Jnnxi3jz73fMeG1dnyw8mnuvOEFbuo2wehoIpXC5v0rSM9IoVPwxaP1g6++j5CmvZj96e1kZWUSvuZFjp7Yw6MjPsjV79GdN7yAr5cfb3w1HoD/LX8AqzWLSYPeLHWeyUPfJiU9kf/7MfuU1n3HNvHpmlk8cut71PSuS22fQB66ZREfr5rB/qjsW+G8+/1/ychM477Bc3Oep6Z3Xa5o3J3VWz8udZaKVj8E6uZ/LClHlerQ+vrC24hUJvXagn/ek65zqeINV/S3Tx5x0iP9+YmPjyc6OpqwsLCcYefPn2fp0qUMGTIEX19fdu3axcyZM+nfX0uYFM1sgXZDIPJXiN4BWZf8LGgyQd2W0PIa8PAyLKKI3XRpHUaX1mFFNxSRcrfz0Hqa1e+AxZJ7t+2R4e9x72shzA4fwy87v+S/oz7KczcNdzcPHhu9hPvf7MzsT8ewdvunvDphPdXKcFjXy9OX/478iGkL+9Ku2TUs+n4aA666J9d3xNVth3B9p3HM+fR27g57ie82Lsj3dVsHdWHHweKdfWkEkxna3giHf4eobZfdotcEdZtDy2uzCxgRyWYyQduBUK0mRG3Nu97UaQ4t+6KzS+zIZYr+Xbt2Abk78TOZTHz88cdMnTqV9PR06taty7Bhw3juuecMSinOxmyBFr2haTc4fQjSksHNI/sMgCoq9l3SjU9Uo2XQVQAM7fEAPUKG5oyb/cntxJ49hNWaxU3dJ3F9pzs4EreHN74aj9lkxmJ2Y+rwdwms3dSo+CLiguLOHsbPt36e4bV8AvjPgFm8/uW99Ay5mWvaj8x3+iYBbbm511Q+XTOLW3o9TNsmV5c5U0jTntza51Ge+2Ao9esEM/6mV/K0mTDodSa+3oHnPhjKbdc9xRWNu+Vp41ejAbFnD5U5T0Uym6FZD2jc5Z99gSSwuEPtxipaRApiMkOzq6HxVXD6MKQngtkdajeCqj5GpytcUft2+e0PAry19H4ORG/Basvijutn0LnVDUbNQh4uXfT7+PiwalXezmFESsriUfRpSuIa6tZoyKsT1+U77vZ+z9CgTgvSM9O499UQrmk/Cl/vOrzwn+/x8vRl874VfLzqeaaNWGzf0CLi0tIyUvCq6ptneFZWJis2vUdVDy8OxGwlOTUh3yP4yakJrN3+KVU9vNhz5DeyrFm5Otg7ee4Yd71y8RbHVmsWGVlp3PTkxcPX/jUb8e4je3I979jrn+XTNbMY0ee/VHH3zPO6nh5e3NpnGm9+PZHbrp2e77x5uFUlLSOl6DfBAVjcwb+l0SlEnIvFHfyLuETG0RS1b5ff/uDxM5EcO7mXuZP/4OyFOKa/F6aivyJMmjSJSZMmGR1DRJzcmQvHmTq/N7WrBzJpyFxqetfNGdegTgsA3C0emE1mTCZTrvEWizvmS3akRUTKQw2vOiQkn80zfMnqmcScPsD/HtjC4+/2Z/63D/Hw8HfztJu3bDIWsxvzpmzmgXndcnWwB1Dbpx4LHtqe8/e+Y3/y7g//5ZUJ63KGuVny9nb97zCLueDdSYv5nzaW/NskJJ+lhledAqcXEbG3ovbt8tsfrO0TiIdbVbKyMklMjcfHy8+umYvilB35iYhUlA8fP8RrE9fTrc0gFn77cL5tPlv3Ej1Cbs61E5yWkcKHPz3DsB4P2CuqiFQSzeuHcuRE7qPse4/9ySerX+DBW94hqG5Lpo34gJ82L+aPv7/N1e6XnV+xZtsSHhv1MY38W3PfkLf4eNUMDkRvzWljsbhR3695zj8/3/pYzLmH+ddsVCHzdjhuFy2COlXIc4uIlEVR+3aX7g96VfUloFYTxr0UzCPz+zDymsfsnLZwKvpFRC7h+88vs72vvJXImG15xq/dHs7BmK2M6/98zrCsrExeXDKa4b0foUlgiN2yikjl0LnVAOLOHuZkfBQAKelJzP70dq4NvT3ntnvtmvXm5l5Tef2Le4hPPAXAmQuxvPHVeG67djqtGmb3VdKv4xi6tRnMnPAxpGekGjND/7DZbOw6tIEurdRJqIg4lqL27S7fH9wS8TPnEuL44L8HeXfa3/xv+QNkZWXaO3aBVPSLiPwjJT2JLGsWADsPb6CeX/Nc4zfvX8mKTf/HoyM/zLk1qM1m49Uv7qZjy/5c3XaIvSOLSCXQyL817Zr1YdWWjwBY8M1DWLMyc93+DmDcDTOp4V2XN768F5vNxsufjaNe7WaMvvbJXO0evHkhCSnncm65Z5QdketISU+kd7tbDc0hInKpovbt8t0fxEb1arUwm81Uq1KdjKw0sqyOU/S7zDX9IiJlFXVyH69/eQ+eHt5YLO48ePNCNu9bQULKWfp2GM3L4XdQ27cejy/Kvu3nk7eFE3l8Oxt2fs6Jc0dYtz2cZvXaM2nwG8bOiIi4nDuun8ELS0Zyc6+HeOiWd/Jt4+FWhXce3pnz9+x7VubbzqdaLT576niBr9WuWR8+fuJIsXL9/LKt0PH9O4+jf+dx+Y77fP3LjLjmMap6VCvWa4mI2MNf+1fm2bfr3PKGQvcHQ1tcx9ptn/LQ/3qSnpHKkKun4OFe1eA5uUhFv4jIP4IbdGT+g1tzDat/ydH+z5+JyzNNLZ8b+G5WcoVnE5HKLaRpT8b0e4bYM4doHNDG6DhllpyawBUNu3Fzz4eMjiIikkvnVoXv2+W3Pwjw6Mj3KyhR2anoFxEREXECYV3vNTpCualWtTq393vK6BgiIpWCrukXERERERERcVEq+kVERERERERclE7vF5FKw7OG0QmyOUqOyzlqroI4W14RERExVln3HWxWSD6X/bhaTTCV4RC6PfdjVPSLSKXRfqjRCRyb3h8RERFxZWXd10lNgF8XZj8OvRWqVi97JnvQ6f0iIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qJU9IuIiIiIiIi4KBX9IiIiIiIiIi5KRb+IiIiIiIiIi1LRLyIiIiIiIuKiVPSLiIiIiIiIuCgV/SIiIiIiIiIuSkW/iIiIiIiIiItS0S8iIiIiIiLiolT0i4iIiIiIiLgoFf0iIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qLcjA4gYi/bl0JKvNEpwLMGtB9qdArH5CifkbMrz2Vs6LYtHEpJLp8nK4OmntVY2qGj0TFExMnpO01EKiMV/VJppMRD0hmjU0hh9Bk5nkMpyexNSjQ6hohIudB3mohURjq9X0RERERERMRFqegXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERanoFxEpxMPz+/DqF3fnGR539gj9ppnYffhXA1KJiIiIiBSPin4RERERERERF6WiX0RERERERMRFqegXERERERERcVFOXfTv2LGDwYMH4+vri4+PD0OGDCE2Npbq1aszcuRIo+NJJXH7rMZGRxAREREREcmX0xb9q1evpmvXruzfv5/p06cza9YsoqOjGTBgAImJibRv397oiCIilZLNZiPz0cfJnDoNm9Waa1zmMzPIvG8KtsxMg9KJiJSMzWYj84mnyHzwYWxZWbnHHThIxsBBWDf8YlA6sZesdIjZCdu/hr/CYedyOBkBl23mxIWlJcKxLRf/PrAO4o+DzWZYpGJzMzpAaZw6dYoRI0YQGhrKqlWr8PT0BGDMmDE0adIEQEW/VLj53zzE9oNrOXPhOONfa09Q3ZZMv/0zo2NJOfOq6ktS6vk8wxNT4gFwd6tq50SOz2QyYZn2MJkTJmH97Asso0YAkPXdD9i2bsPt7bmY3Jxy8yMilZDJZMLy8EPZ32nhn2O5bRQAtrQ0Mue8jKlvH8y9ehqcUirSmSOw61vITMs9/OQBqOoD7YeBt58h0cQObDY4uhkif8ld4J/Yn/2vVkMIGQTuDrxL6JR7XXPmzOHcuXMsXrw4p+AH8PX1JTQ0lNWrV6vol1LrN81U6Hj/mo34+IkjTBz0OpB9ev/CqdvtkEyMEFS3FRt2fkGWNQuL2ZIzfH/UJsxmC/X9mhuYznGZ6vhhmXwfWS+9irlzJ6hSBevCRZjv+Q+mhkFGxxMRKRFT7VpYHpxC1guzMXXuiDk4GOu7iyEjA8ukCUbHkwp0Ljr76L6tgCP6qRdgy2dw1e3g6WvfbGIfx7bAwQ0Fjz97LHsZ6XgrmB20unbQWIULDw+nZ8+eBAcH5zve39+fgICAXMNSUlIICQkhLi6OxMREe8QUJ/XZU7E5j/cc/Z0ZH97M/Ae3Uqt6IADmSwo/cX2Duk/im9/m8cpndzK05wN4V63BvqhNvL/yKfp3uhNvzxpGR3RY5j69sW7cRObslzBVqYIppC2WQTcZHUtEpFTMV3fH2u86sma/Avf8B+v3P2B5ZQ6matWMjiYV6MC6ggv+f2WkwOGNcEV/u0QSO8pIzT7CX5TzxyFuH9RrW/GZSsPpiv64uDhiYmIYMWJEnnFWq5Vdu3bRoUOHPOOefvppGjVqRFxcXIleLzMzs8TTlEVCmgXILi5jY2NJrJJV+ARSbBkZ/oB7ke1q+Vz8wcinWi0AfL3q5BpethwZREefKJfnKnWG5NzLmft5x1jOivsZ2ZN/zUa8cf/vvL9iOk8tvonklPME1G7Krb2nMbTnA0bHy1d5LmOZGRllmt5y/0QyR43BZjbj9vyzZcoRHR1dpixl5ajrjSPTe5bNEb/bHF1FbSvL/J024V4yJ91P1nMzMY8eifmK1qXOoe80x5d61p0Lcf7FaGkjdg94tTiOxcMJLvCWYju73xtrVo1itLRxaFMG1honKzRPQEAAbqW4RNLpiv6kpCQg+/qqyy1fvpyTJ0/mObV/y5YtrFixgldffZVhw4aV6PXi4uIICrLfqajetepz19zsjcBVV3Um8WyM3V7b1S16eDeNA9oYHYOIiAh6jzf2Z0A/3/p8Ov3icnb6vGMsZ47yGV2uWb12PP+fb42OUWzluYy5vTMfU+NGpZ7eunpt9oO0NGwHDmLqclWpniciIoKgPteWOkd5cNT1xpHpPctWkd9tR+L28MZX4zGbzFjMbkwd/i6BtZvmajP7k9uJPXsIqzWLm7pP4vpOdxB39ggvfjIai8WdrKxMHhg2n6b1riz0tTKzMrjrlSsY0PkuRvZ9LNe4r395gzXbPsFidqdFg1DuH/IWAPGJp5i37H7OJ56iikc1Zv7nu2LNV0VtK8v6nWbyrIpl+C1kzZ2H+Z9r+0tD32nO4cau43ng5gXFaGnCZoWwa29lz5HfKzyX2M9joz7m2tDbitHSRPJpCw0bNsRWgT37RUVF0aBBgxJP53RFf1BQEBaLhfXr1+cafvToUSZPngzk7sQvMzOTe+65h7fffhurutcUEbEb27FjWN99D8vE8diOHiPr9TcxLfwfJl9d9ChSXny96/DCf77Hy9OXzftW8PGq55k2YnGuNrf3e4YGdVqQnpnGva+GcE37UdTxbcDrk37FbDaz7eAaPl0ziydvDy/0tb7buJCGdVrlO65L6xsZ2uMBTCYTL3w8kh2R62nXrDcLv32Ysdc/R8O6+U/nlNyyL/MzWXS5n6sr6SWdFke9oFtKrSTLgNlswYQJG453tofTLZkeHh6MHTuWxYsXM3jwYMLCwoiKimLRokX4+/sTExOTq+h/+eWX6dChA7169WLdunUlfr2AgACioqLKbwaKkJBmYeHG7MebNm2muk7vLzeHfvAn/UL5P29D/ytK1D44ONiuy1R+MpItRH6T/XjTps24V3OM5ayiPqPKpjyXsf6RERxITyu64WVsmZlkzn4FU4f2mAfegC09HevWbWS9+RZuT08v8fMFBwezUuuN09F7lq0iv9tqetfNeWyxuOe7g9qgTgsA3C0emE3m7N7oLRd3AZNTL9C0XrtCXyclLZHN+36k15XDOZeQ97LHSzs1tVjcsZgtZFmzOHpiD+FrZhN37jDXhY5hYJe7izVfFbWtLO13WnnTd5pzSDpRhai1xW1tY9mKT3H31EFGV3J6d3VO7y5OSxvu3pkcPXa0QvNc3m9dcTld0Q8wd+5c3N3dWb58OWvWrKFbt24sXbqUGTNmcPDgwZwO/g4ePMiCBQvYtm1bqV/Lzc2tVKdQlFZ88sXHgYGB1FDfMOUmyh3SK+B5Z931Q4nau7u723WZyk9qAkT+8zgwMJCq1Q2Nk6OiPqPKpjyXMbdjh6EUO8jWDz6C06exvDADAJOHB26PPULm5Iew/rwac7+SndbqpvXGKek9y2aP77a0jBQ+/OkZHhg2v8A2n617iR4hN+Nmye5f4GDMduZ+PZFT56N4ZuzXhT7/5+teZljPB4s8BXz34V85cz6GNo2v5mxCHJGxO5g28gPq+7Vg2oJraN/sGur5NStyfipqW1na77Ryz6HvNKdgqw+nt8E/d+ktVJ0WJpq0qFfhmcS+/Hzh1z1Q9MF7E407Gb9eF8RsdIDS8Pb2ZuHChcTFxZGQkMBPP/1Et27d2L17NyEhIZjN2bP166+/cuLECYKDg/Hz82Pw4MEkJSXh5+fHhg2F3HdBRERKzbp7D9YvvsLy0AOYatbIGW5q1gzzmNvI+t8CbCcrtqMbkcokKyuTF5eMZnjvR2gSGJJvm7XbwzkYs5Vx/Z/PGda8fnvmTv6DGeO+Yd6y+wt8/nMJJzh4fBsdg/sVmuPoib0s+v5Rpo/5HJPJRHXPmtT1DaJJQFs83KoQ0rQXR07sKd1MihjAZIJmPYrRzgJNulR8HrG/qtWhQeEnQmW383HcnvvBSY/05yc+Pp7o6GjCwsJyht16661cd911OX//8ccfjBs3ju3bt1OnTh0jYoqIuDxz2zaYV+TfWZdl1Agso/LefUVESsdms/HqF3fTsWV/rm47JN82m/evZMWm/+P5/3yXc2AkPTMND7cqAHhV9aWKe/aphcmpCVhtWbluR3o4dhfnE0/x+KIbOH0hhsysdJrV70DnlhfvT3by3DFe/uwOnrz9M3y9/ADwcK9K3ZqNOH0+hto+9TgQvZV+HcdWwLtgX+br+2G+vvAfQMR1BLSCjGTYvyb/8WY3uHIQlNNNnsQBBV8DmekQ93f+46v6Qugt4F7VvrlKwmWK/l27dgG5O/GrVq0a1S65d2qdOnUwmUwOe9qFiIiISEn8tX8lG3Z+zolzR1i3PZxm9dozafAbbN63goSUs/TtMJqXw++gtm89Hl+UXaQ/eVs4R0/+zUc/PYvZbMFmszHhptcAWLcjnLSMFIb2mJLzGqHB1xEanH0QZeXm9zmXEEfnlv05eyGOrza8xj03vsSi7x/lfNJpXvnsTgBGXvMYnVvdwMRBrzPrk9FkZWXQueUAGpWwHxwRRxAUCrUawdHNcPyf67ur+kK9NlD/SqjibWw+qVhmC7QZAPVDIGobxEeD1QrVamR//gGtwOJhdMrCuXTRf7k+ffqQmJhop0TiCto168PPLzteD5yVQWp6Mo8uvJZjJ/fywM0LuKb9yDxtPvzpWVZuXkzDuq158Z4VxZ7uUq99cQ9/7v2Obm0G82ABt+UJXzObrQdWkWXN5M4bZtK2SY8S3YbqQtIZ5oSPJTntAi0bdGbCoNdyjd9+cC3v/fgEbm4eVPXw4rFRH+NTrVbO+JfC7+BcwomceRzzYlPq1mgIQJ92I7ip+8RC51FEXFfnVjfw3azkfIf/6/Nn8na8V8sngA7N++YZfjhuN7ddW3Bnm/07j8v1HPfc+BJAgT3/N6/fgdcmrs93nIgz8aoNTa++WPR3Gon6QahETCaoGZT9zxm5TNE/adIkJk2aZHQMESkn7m5VePaOpXy3seD744Z1HU+/jmOZ+/WkEk13qbHXP8u1obexdnv+O6yb9v1IakYyL41flWt4SW5DFb52NteG3k7fDqN48ZPb2BG5jnbN+uSMr+fXnFcmrMXDvSrf/rGA5b++xZjrnwHg0PGdJF7Wg5C7xYNXJ64r1vyJiJTEfYPfNDqCiIiUM6fsyE9EXJ/FbKFWERfI1fYJxGTK/TVWnOku5edbv9Dx63d8Tmp6EtMWXstL4eNITk3IdRuqqfN788Of7xb6HLsO/0LX1jcC0L3NYHZG5j7qVbdGEB7/XAjmdtkttz5e/Tyjrn0iV/ssWxaPLLiGp967iZjTB4s9ryIiIiJS+ajoFxEpxJkLx3GzuPPy+NU0r9+eLze8SnziSSJjdzC8zyPMvucnVm5+j+OnIwt8juTUC1T75xxAb8+aXEg5m2+7+MRTfPv7/7jhqrsA2BG5jgZ+wdT09s/Vbu79f/DKhLXc2udRXv3irnKaUxERERFxRSr6RUQKUb1aLTq3zL42tlPLGzgUu7PEt6GqVqU6KWnZ/YkkpsTj41krT5uUtERmfnwrk4f9j9o+gUB2XwK39pmWp+2/PWOHNO1JfMKJMs+jiIiIiLguFf0iUikkpybkuTa+ONo17UNE1F8ARET9Rf3azXPdhspms3Egeiv1/ZqTlZXJmQuxeZ4jpGkvNu37AYCNf3/Llc165xqfkZnO8x8N55ZeD9O6YZecvGcT4njh45G89NkdHIjZwufrXiY9M430jFQAok9F4FlFvQiJiIiISMFcpiM/EXE9z31wMwePb6Oqhxf7jv3JxEGv57oN1fcb3+HnLR8SdXIfjy68jkdHfoifb718p8vvNlQAH/08gz/2LOdc4gkeXXgds+/5ifjEkzm3obq+8zhe++JuHllwDR5uVXl05IcA+d6GKvrUAd794b88e8fXuV7j1j6P8tJnd7Dst7doUb8jVzbNLvrnfDqW/476kBWb32PfsT9Jy0jhi/Wv0LnlDYzs+xgLp24HIO7sEd78agK39pnG6fPHeWrxjVT18MJmszFl2P8q/oMQEREREadlstlsuh+ZA4lPhmeXZj9+dijUqGZsHlfyx2JIOmN0iuxbvnS709gMqQnw68Lsxz3GO84tZyryM3p7+QPcdu10anjXqZgXAFZvXYJXVV+6XnFjhb1GcZTnMtbu91/Ym2T8rU5be3mzo3tPQzM46nrjyPSeZXOU7Y8zqahtpb7TLtL6WXJ6z8RZ6Ui/iFQK9rgN1bWht1X4a4iIiIiIlISu6RcRERERERFxUSr6RURERERERFyUTu+XSsOzhtEJsjlKDkek96Z8lOf72NTTMToWcZQcIuLcHOW7xFFyiEjloKJfKo32Q41OIEXRZ+R4lnboaHQEEZFyo+80EamMdHq/iIiIiIiIiItS0S8iIiKGeuedd+jTp0/Ov8DAQJ588skCh1/qt99+44UXXgAgOTmZbt26UaNGDcLDw/O8js1m45577qFXr17079+fqKgoADZt2pTzGh07diQ0NBSAs2fPcvvtt1fw3IuIiFQsnd4vIiIihrr33nu59957AYiMjGTIkCE88sgj1KxZM9/hl5ozZw6LFy8GoEqVKixdupQFCxbk+zrLly+nSpUqbNiwgS1btvDYY4+xZMkSrrrqKtatWwfAG2+8QUpKCgC1atXC19eX3bt307Zt24qYdRERkQqnI/0iIiLiEDIyMrj99tuZP38+NWvWLHL4hQsXOH/+PLVr1wbAYrEQEBBQ4PNHRETQqVMnAEJDQ/nll1/ytPnkk08YNWpUzt8DBgzgyy+/LPO8iYiIGEVFv4iIiDiExx57jLCwMHr06FGs4fv376dJkybFfv6QkBBWrlyJzWZj5cqVnDx5Mtf4iIgIPDw8aNy4cc6wZs2asWvXrpLPjIiIiIPQ6f0iIiJiuB9++IEdO3bw008/FWt4aQwYMICNGzdyzTXX0K5dO6688spc45csWcLo0aPL/DoiIiKOREW/iIiIGCo2NpZp06axatUqzGZzkcP/FRwczKFDh0r0Ws899xwAq1evpkqVKrnGff7553lO+Y+MjNT1/CIi4tRU9IuIiIihZs6cyYULF3JdS9+3b19OnDiR7/Cnn34aAF9fX3x9fTlz5kzOdf0333wz27Ztw8vLiz///JPXX38dgLFjx/Laa69xyy234ObmRsOGDXnrrbdynvfPP/+kadOm+Pn55cr2448/MmHChAqbdxERkYqmol9EREQM9fbbb/P2228XOK4w//3vf1mwYEHOrfy++uqrfNt9+OGHADm99F+uS5cufP/997mGnT17lvPnzxMSElJoBhEREUemol9EREScVo8ePfJ08FdeatWqxccff1whzy0iImIv6r1fRERERERExEWp6BcRERERERFxUSr6RURERERERFyUin4RERERERERF6WiX0RERERERMRFqfd+KdD2pZASb3SKbJ41oP1Qo1OIiIiIMxu6bQuHUpKNjkFTz2os7dDR6BgiUkmo6JcCpcRD0hmjU4iIiIiUj0MpyexNSjQ6hoiIXen0fhEREREREREXpaJfRERERERExEXp9H4REREREREpd+mZcPICZGSB2QS1vKF6VaNTVT4q+kVERERERKRcnEmE3w/A38fhxHmw2nKPr1ENmtSB7s2huT+YTMbkrExU9IuIiIiIiEiZJKTC13/B9qNgK6RdfDJsO5r9L8AXhl8FzeraLWalpKJfRERERERESm13NHy6EZLSSjZd3HmY9zP0agWDOoBFPc5VCBX9IiIiIiIiUip/RkL4xsKP7hfGBqzfl31ZwJ09VfhXBL2lIiIiIiIiUmJ7YiD8z8ILfrMJfD2z/5kLuX5/dzR89me5RxRU9IsBbp/V2OgIIiIiIiJSBklp/xzhL+IQf/Wq8Nyw7H9F9dy/6RDsjCq/jJLNqYv+HTt2MHjwYHx9ffHx8WHIkCHExsZSvXp1Ro4caXS8ErPZsm9p8a/Le7oUERFxJjbrxcfJ54reMRQREeexfGt2533l7fNNkJpR/s9bmTlt0b969Wq6du3K/v37mT59OrNmzSI6OpoBAwaQmJhI+/btjY5YbDZb9q9ar/wA/1t9cfgbK+Hn3ZCZZVy28jT/m4cY/1p7zlw4zvjX2jPz4xFGRxIRkQpgzYTDG2HzJxeHbf0cNn0EsX+r+L/Un3t/YPxr7Rn4WBVun9WYL9e/ZnQkuYzNZiPziafIfPBhbFm5d8psBw6SMXAQ1g2/GJROxBgXUmDLkYp57sRU2HK4Yp67snLKjvxOnTrFiBEjCA0NZdWqVXh6egIwZswYmjRpAuA0Rb/NBsu2ZndecbkLKfD9DjhwAu7pA+4Wu8crln7TCr+5pn/NRnz8xBEmDnodyD69f+HU7XZIJiIi9paVAduXwrljecclnIQ9P2T/36K37s28P+ovnnl/MMN7P8ITt33KvmN/8ubXE6jiUY2buk0wOp78w2QyYXn4ITInTMIa/jmW20YBYEtLI3POy5j69sHcq6fBKUXsa2MkZFmLbldavx6Aq4Mr7vkrG6cs+ufMmcO5c+dYvHhxTsEP4OvrS2hoKKtXr3aaov+vw/kX/JeKiINvt8GwTvbJVFKfPRWb83jP0d+Z8eHNzH9wK7WqBwJgNjvorxUiIlLuDmzIv+C/1LG/wMcfAlrbJ5Oj+mrDa7QM6sxdA18EoJF/a46e2MNna2er6Hcwptq1sDw4hawXZmPq3BFzcDDWdxdDRgaWSfqspPLZd7xinz82Hs6nZHf+J2XnlKf3h4eH07NnT4KD8//5x9/fn4CAAADGjRuHh4cH3t7eOf9WrFhhz7gFstlgXREF/782RjrutS21fAJy/vlUqwWAr1ednGE1vOsYnFBEROwhIxWO7ype22NbKjaLM9hz5Dc6tbwh17BOLW/gxLmjnIqPNiiVFMR8dXdM/a4ja/YrWP/YiPX7H7D8dxqmatWMjiZiV1YbxJyr+NeJPlPxr1FZON2R/ri4OGJiYhgxIu/14FarlV27dtGhQ4dcw++9917mzZtXqtfLzMwkLi6uVNMW5UyyGzHnAorVNj0TNuw8wxX+KRWSJT8ZGf6Au91erzAZGRlER58wOobLyEi2ANlnYsTGxuJ+3kU6jhCpQFpvinb+cDWsmbWK1fZCHBzaG4dH9cwKTmW8granZxNiqVU9937Av3+fTYilTo0G9ojnkCpqu5+ZUbYjKJYJ95I56X6ynpuJefRIzFeU7nSVzIwMoqON/WFH32klp/cs24VUC2mZgbmGmU0F98zv45n/40slpObtxHx/VDy+JJYhqesJCAjAza3kJbzTFf1JSUlA9vVVl1u+fDknT54s11P74+LiCAoKKrfnu1S9lj0Z/tSGYrd/bPpMtq14o0Ky5GfRw7tpHNDGbq9XmIiICHqPb2t0DJfh51ufT6dn72xcdVVnTp+PMTiRiOPTelO0W3o/zPgbXyl2+0EDb2bPkd8rMJFjcKTtqbOoqO2+2zvzMTVuVOrpTZ5VsQy/hay58zD/c21/aURERBDU59pST18e9J1WcnrPstUIaMEdr0TkGvbvbfmK8vCA/Ic/83X26fyXmvPSa2xa9nwpU7qmqKgoGjQo+Q/CTnd6f1BQEBaLhfXr1+cafvToUSZPngzk7cRvyZIl1KpVi9atW/PCCy+QmekYRxXSUy4U3ejS9qkJFZTEvhr6X2F0BBERqQApaSXbTiWXsL2rqVU9kLMJuc8mPJd4ImecOCi37L6KTBb1WSSVkzXLPtccW7PS7fI6lYHTHen38PBg7NixLF68mMGDBxMWFkZUVBSLFi3C39+fmJiYXEX/lClTeOmll/Dz82Pr1q2MGjWK1NRUnn++eL8aBQQEEBUVVSHzYrXBu39mciHNAhTehbHJZOPLd2fgXeXZCsmSn0M/+JNest8limXWXT+UeJrg4OAK+xwqo4xkC5HfZD/etGkz7tUq5+lpIiWh9aZoGckWIr+1ga2obvltuHtlsf7PHypFD/4FbU/bNL6av/avZEy/p3OG/bVvBf41G1XqU/uh4rb7/SMjOJCeVu7PW1LBwcGsNHi/Rt9pJaf3LFuWFeb+aiPrku/6hNTso/X58fG8eIT/1R+z71B2uYTUvMNmPzeNlv+7vxwSu45/+60rKacr+gHmzp2Lu7s7y5cvZ82aNXTr1o2lS5cyY8YMDh48mKuDv9DQ0JzHnTp14rnnnuOZZ54pdtHv5uZWqlMoiqv3Bfh2e9Ht2gWZaNWsXoXlyE+UOzjK72vu7u4V+jlUNqkJEPnP48DAQKpWNzSOiFPQelM8Cc3h5IGiWplo3MmNoKDK8b1e0Pb05l4P8cC87rz345Nc13EM+479ybLf3mLCP7e4rcwqarvvduwwOEDR7+YA+zX6Tis5vWcX1asJUWcv/m215T09Pz8XUorXDqBd89r4VeL3uDw5ZdHv7e3NwoULWbhwYa7hu3fvJiQkBLO54KsWzGYzNputwPH21rsVRJyA/bEFt6ntDTd3tl8mERGR0mp5HVw4AamFnClWuwkEhRY8vrJoGdSZ58Yt470fn+DL9a9Qs3oAd97wgm7XJyIOr7l/7qK/vNWoll0DSflwyqI/P/Hx8URHRxMWFpZr+GeffcYNN9yAj48Pu3bt4rnnnmP48OEGpczLzQL39IbvtsMfByHtku4GzCZo1xCGdSq4N0wRERFHUsULOt8GEWvgZET27Wn/ZfGABldCs55g1uXQAHRpHUaX1mFFNxSHYb6+H+br+xkdQ8RQXZvD2r0V9/zdm1MpLv+yF5cp+nftyr4x8OWd+P3vf/9jwoQJZGRkEBgYyJgxY3j88ccNSFgwNwsM6Qg3XAl7YiAxFaq4Q+t64FvAbS0cVbtmffj5Zcc5k0JEROyviheE3ARpiXD6MGSlg4cX+DUFNw+j04mISFn5+0CrQNhXyNnKpeVuyf5RQcqPyxf9l/fy78iqukPHxkanEBERKR9VvKF+iNEpRESkItzcGV76HjLKuT/DsHbZnf9J+XG6W/YVZNKkSdhsNrp27Wp0FBEREREREZdWpzoM6lB0u3979n/m6/x76b9Us7rQq2X55JOLXKboFxEREREREfvpEQzXtC68zb89+59PyX5ckMAa8J9eUEif7FJKLnN6v4iIiIiIiNiPyZR9tN/TA1bsLLyoL0wLfxjXE7yqlG8+yaaiX0RERERERErFZILr22Z37PfpHxB7vvjTVnGDmzpA9xbZdy6TiqGiX0RERERERMqkYW2YNhD2xsKvERARB1nW/Nv6+0C3FnBVU6imu7pUOBX9IiIiIiIiUmZmM7Spn/0vMwuOx8Ohk7Bsa/b4MVdnnxGg0/jtS90kiIiIiIiISLlys2Qf/W/f6OKwZnVV8BtBRb+IiIiIiIiIi1LRLyIiIiIiIuKidE2/FMizhtEJLnKkLCIiIiWhbVjJVdR71tSzWsU8cQk5Sg4RqRxU9EuB2g81OoGIiIjz0/bUcSzt0NHoCCIidqfT+0VERERERERclIp+ERERERERERelol9ERERERETERanoFxEREREREXFRKvpFREREREREXJSKfhEREREREREXpaJfRERERERExEWp6BcRERERERFxUSr6RURERERERFyUin4RERERERERF6WiX0RERERERMRFqegXERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERbkZHUDEXhatgzOJRqeA2t5wTx+jU4hUPtuXQkp86ae3WS8+3vo5mMrws7lnDWg/tPTTi4hI6ZRlW6DtgDgrFf1SaZxJhLjzRqcQEaOkxEPSmfJ5ruRz5fM8IiJiX+W1LdB2QJyJTu8XERERERERcVEq+kVERERERERclIp+ERERERERERelol9ERERERETERakjPxERkcu8FD6On7d8AIDZZKaWTyDtm/XlroEv4udb3+B0IiJS0bQdEFeiI/0iIiL5CGnSk8+eimXJk8d4fPQnHDy+jec/Gm50LBERsRNtB8RVqOgXERHJh5vFg1o+Afj51ufKpr0I63Ivfx/9g6TUC0ZHExERO9B2QFyFin4REZEinD5/nA27vsRstmA2W4yOIyIidqbtgDgzXdMvIiKSjx2H1nHTk97YbFbSMlIAuKXXw3h6eAHw666lfPTzc7mmOXbybyYNepObuk+0e14RESlfRW0HZnx4Cx2Dryes670AHIzZxqxPRrPgwW14uFc1LLfI5Zy66N+xYwdPP/0069atw2az0bdvX+bPn09wcDBhYWGEh4cbHVFERJxUq6AuPDryA9IzU1m/43O2HVjFnTfMzBnfI2QoPUKG5vz92+5lvPfjE/TrdIcRcUVEpJwVtR2YNPhNHnq7Bz1ChlHdsxZvfj2R+4fMU8EvDsdpi/7Vq1dz44030qhRI6ZPn46npyfvv/8+AwYMIDExkfbt2xsdUVxEZnoKm5fPYv/GcBLPRuPm4Ylv3Wa07jGG9v2nGB2vxFIT4Ojmi39H/gINO0H1usZlEnFEVdw9qe/XHIAmAW2JPRPJvGWTmTp8UZ62p+KjeWvpfcy660eqelSzd1QRkRJJS4JjWy/+fXADNOwIPgHGZXJERW0H/Hzrc3Ovqbzz3TRaNexCA79gQltca2Rkh2K1QUQc/Hbg4rBNh6BXS6jqblyuysgpi/5Tp04xYsQIQkNDWbVqFZ6engCMGTOGJk2aAKjol3KzZvFEov9eS+8xb+LXsB3pKRc4dXQbCWeOGR2tRGw2OPQ7HN4I2C4Oj/07+1+dFtB2AFg8DIso4tDG9HuWu15pTVjX8bQM6pQz3Gq1MvvT2xl5zWM0rXelgQlFRApns8HRTRD5a/bjf8Xtzf5XuwmE3AhuVYzL6Mjy2w4M6n4fU+Z1ZUfkWuZN2VzEM1QeZxPh3fVwPD738B92wKo9MLobtG9oSLRKySk78pszZw7nzp1j8eLFOQU/gK+vL6GhoYCKfik/kVuW0TFsGs06DcG3bhPqNGrHFb3G0WXo00ZHK5FDv8PhP8hV8F/q1AHY+Q3YrHaNJeI0GtRpQbfWN7F4xZO5hi9ZPZNqVX0Y0mOyQclERIrn6GY4+Evugv9SZw7D9qVgzbJvLmeR33bAbDZzY9cJXNVqIDW86xiYznEkpsK8VXkL/n+lZ8IHv8CeaLvGqtScsugPDw+nZ8+eBAcH5zve39+fgICL5yd9//33hIaG4uXlRUBAAC+//LK9oooL8KoRyJGdK0hNPGt0lFJLS/znCH8RzhyB04cqPI6I0xreZxpbIn5iR+Q6AHYf/o0Vm/6PabcuNjaYiEgR0lMg8rei28VHw8mIis/jrC7fDgCYTGZMJqcsqyrEun1wNqnwNjbg6y3ZlwBIxXO60/vj4uKIiYlhxIgRecZZrVZ27dpFhw4dcob99NNP3HvvvXz44Yf07t2b5ORkjh0r/mnZmZmZxMXFlUt2MVZGhj9Q8guIrrv7XVa8PZp3JtahVoM2BDbvSuN2A2nacTAmk6kUOTKIjj5R4unK4vTu6mDzLUZLGwc3ppFW9XSFZxKxt5J8Bzw68v18h7dp3J2fX87eQ0lMiWdO+BimjXgfH6/aJcxi/+8BEanczuzzxpZVoxgtbUT+mU5m9VMVHckQxd0WFGc7ULYcrrkdyLLCb/sDyT62XPh+8plE+G3XKZrUSrNLNlcQEBCAm1vJS3inK/qTkrJ/Nsqv2Fq+fDknT57MdWr/U089xVNPPcW112Z3quHj40Pbtm2L/XpxcXEEBQWVLbQ4hNtn76Z2gzYlnq5e8NWMey2SuMhNxB38g5h9G/h+7i00bjeAm6Z+U+LCPyIigqBhxV8Gy8PM/3zHVa0GFONXaBMnDqfQfYyWeXE9ix7eTeOAkn8HFOTbP+Zz9kIs8795KNfw6zvdwc29HipgqmwRERH0Hm/f7wERqdym3/4ZvdvdWoyWJhJOmFx2/7e8twWl5arbgRoBLbjjleKfKvLIM3PZtGxm0Q0FgKioKBo0aFDi6Zyu6A8KCsJisbB+/fpcw48ePcrkydnXU/5b9CclJbF582YGDBhAq1atOHfuHF26dOHNN9/M6fBPpDjMFjfqBXenXnB3Qgc+zL5fP2blgjHE7NtAg9a9jY5XJLPZUvy2puK3FanMRvV9nFF9Hzc6hohIsZjNFmw2W7EOVuhU9ZLp33kc/TuPMzqGQzCVYJ+zNO2ldJyu6Pfw8GDs2LEsXryYwYMHExYWRlRUFIsWLcLf35+YmJicov/cuXPYbDa++uorVqxYQd26dXnwwQcZNmwYW7duLdaXXkBAAFFRURU8V2IPizf7cya5fJ6rZv3WAKRcOFniaYODg+2+TJ3Y6su5iOJswG3UqldVy7y4pEM/+JN+wegU2Yz4HhCRyu3UTh/O/F2csxNteNawuex3lKNsC1x1O5CeZeJ/v1vJtJoo6vR+gJlPTqbVm3dXfDAXcWm/dSXhdEU/wNy5c3F3d2f58uWsWbOGbt26sXTpUmbMmMHBgwdzOvirXr06AA888ACNGzcGYNasWdSpU4eoqCgaNiz6PhFubm6lOoVCHI/79tJN9+XM3gR3G4V/k054+tQhPu4gv3/xBFWq1aDBFdeUPIe7u92XqRpVYWOxzrQy0aSzB/W1zIsLinKHdKND/MOI7wERqdxqe8NvfxenpYnGnVz3O8pRtgWuvB3oHAd/HCy6XTUP6NOuNm462F/hnLLo9/b2ZuHChSxcuDDX8N27dxMSEoLZnH1E09fXl0aNGpWqszWRfzW6cgD7f1vCxq+eJj3lAp4+danfshf97l2MZ3U/o+MVi7cf+LeCE/sKb1etFgS0sk8mERERsR/PGlAvBI7vKrxdVV+oZ/wl7+LErmkNW49AWmbh7fqHoILfTpyy6M9PfHw80dHRhIWF5Ro+YcIE3nzzTa6//nrq1KnDU089RceOHYt1lF8EoPOgx+g86DGjY5TZFf0hKwNOR+Y/vlotCL0FLCW/wYGIiIg4gVbXQVY6nNif/3hPX+gwHNyq2DeXuJa6PjD+GnhnHaRm5N/m+rbQq6VdY1VqLlP079qV/bPlpT33Azz66KOcO3eO0NBQrFYrPXr04OuvvzYgoYixLO7QbgicOQLR2+B8LNis2cV+g3bg31IFv4iIiCszW6DtjVD/SojaDvHR/+wL1ID67bLP9rN4GJ1SXEHTujB9EGyMhE2H4EIKeLjBFfXg6mAIqmV0wsrF5Yt+s9nMnDlzmDNnjgGpRByLyQR+TbL/iUheR+L28MZX4zGbzFjMbkwd/i6BtZvmaffw/D4E1W3FgzcvIDU9mUcXXsuxk3t54OYFXNN+pAHJRUSKx2SCWo2y/0leRW0HUtOTeXv5FOLOHsZqzWLmXd9zNG4Pi75/FICUtARs2Jj/4FajZsFheFeF69pk/xNjuUzRP2nSJCZNmmR0DBERcWK+3nV44T/f4+Xpy+Z9K/h41fNMG7E4V5uNf39HtSrVc/52d6vCs3cs5buNC+wdV0REyllR24GPfn6Ovh1G06F535xhrRpexasT1wHw9S9vkJaRYu/YIoXSTThFRET+UdO7Ll6evgBYLO6YL7t/sNVq5Zvf32ZQ9/tyhlnMFmr5lO4WOiIi4liK2g7siFzLH3u+4eH5fViyamae6dds+4Rr2o+yS1aR4lLRLyIicpm0jBQ+/OkZhvV4INfwn7Z8QI+QYXi4VzUomYiI2ENB24FDx3fQueUNvDx+DQditrIjcl3OuOhTEbhZPAio1di+YUWKoKJfRETkEllZmby4ZDTDez9Ck8CQnOHpGams2bqE/p3uNDCdiIhUtIK2AwA+Xn50DL4es9lMx+DrORS7M2fc6q1L6NthtL3jihRJRb+IiMg/bDYbr35xNx1b9ufqtkNyjYs9e5jE1Himv3cji75/lE37fuDnvz40JqiIiFSIwrYDACFNe3EgJruTvojov6hXu3nOuPU7P6d3u1vtFVWk2FymIz8REZGy+mv/Sjbs/JwT546wbns4zeq1p3PLG0hIOUvfDqP53wN/AbAjch1rt4fTr9NYAJ774GYOHt9GVQ8v9h37k4mDXjdyNkREpJSK2g7cPXA2r31xN+mZqTTyb8NVrQYAsPfYnwTWaoqvl5/BcyCSl8lms9mMDiFiD7O/g7jzRqeAAF947EajU4hUPn8shqQzRqfI5lUbuukqARERu3OUbYG2A2JPOr1fRERERERExEWp6BcRERERERFxUSr6RURERERERFyUOvKTSqO2t9EJsjlKDpHKxrOG0QkucqQsIiKViaN8/zpKDqkc1JGfiIiIiIiIiIvS6f0iIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qJU9IuIiIiIiIi4KBX9IiIiIiIiIi5KRb+IiIiIiIiIi1LRLyIiIiIiIuKiVPSLiIiIiIiIuCgV/SIiIiIiIiIuSkW/iIiIiIiIiItS0S8iIiIiIiLiolT0i4iIiIiIiLgoFf0iIiIiIiIiLkpFv4iIiIiIiIiLUtEvIiIiIiIi4qJU9IuIiIiIiIi4KBX9IiIiIiIiIi5KRb+IiIiIiIiIi1LRLyIiIiIiIuKiVPSLiIiIiIiIuCgV/SIiIiIiIiIuSkW/iIiIiIiIiIv6fzJlFy7wgjjuAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, - "execution_count": 3, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -50,17 +58,25 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/matplotlib.py:274: UserWarning: Style JSON file 'iqp.json' not found in any of these locations: /Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/styles/iqp.json, iqp.json. Will use default style.\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 4, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -87,17 +103,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -119,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -145,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -155,7 +171,7 @@ " 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -166,17 +182,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 8, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -187,17 +203,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 9, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -215,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -254,7 +270,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.9.6" } }, "nbformat": 4, diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 884acf75d..49858f970 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -50,12 +50,12 @@ ], "source": [ "from qiskit.circuit.library import EfficientSU2\n", - "from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit\n", "\n", "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", "\n", - "circuit_ckt = QCtoCCOCircuit(qc)\n", + "circuit_ckt = qc_to_cco_circuit(qc)\n", "\n", "qc.draw(\"mpl\", scale=0.8)" ] @@ -249,9 +249,9 @@ } ], "source": [ - "from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit\n", + "from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit\n", "\n", - "circuit_ckt_wirecut = QCtoCCOCircuit(qc_0)\n", + "circuit_ckt_wirecut = qc_to_cco_circuit(qc_0)\n", "\n", "settings = OptimizationSettings(rand_seed=12345)\n", "\n", diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index bb80f5e33..2da714d1f 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -12,7 +12,7 @@ DeviceConstraints, ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - PrintActionListWithNames, + print_actions_list, ) @@ -51,7 +51,7 @@ def testCircuit(): return interface -def test_BestFirstSearch(testCircuit): +def test_BestFirstSearch(testCircuit: SimpleGateList): settings = OptimizationSettings(rand_seed=12345) settings.setEngineSelection("CutOptimization", "BestFirst") @@ -72,7 +72,7 @@ def test_BestFirstSearch(testCircuit): 27, 4, ) # lower and upper bounds are the same in the absence of LOCC. - assert PrintActionListWithNames(out.actions) == [ + assert print_actions_list(out.actions) == [ [ "CutTwoQubitGate", [12, CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), None], diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index e42f3697f..488d12a60 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -4,8 +4,8 @@ from qiskit import QuantumCircuit, QuantumRegister from qiskit.circuit import Qubit, Instruction, CircuitInstruction from circuit_knitting.cutting.cut_finding.cco_utils import ( - QCtoCCOCircuit, - CCOtoQCCircuit, + qc_to_cco_circuit, + cco_to_qc_circuit, ) from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, @@ -77,13 +77,15 @@ def InternalTestCircuit(): ), ], ) -def test_QCtoCCOCircuit(test_circuit, known_output): - test_circuit_internal = QCtoCCOCircuit(test_circuit) +def test_qc_to_cco_circuit( + test_circuit: QuantumCircuit, known_output: list[CircuitElement, str] +): + test_circuit_internal = qc_to_cco_circuit(test_circuit) assert test_circuit_internal == known_output -def test_CCOtoQCCircuit(InternalTestCircuit): - qc_cut = CCOtoQCCircuit(InternalTestCircuit) +def test_cco_to_qc_circuit(InternalTestCircuit: SimpleGateList): + qc_cut = cco_to_qc_circuit(InternalTestCircuit) assert qc_cut.data == [ CircuitInstruction( operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 0d9e3825c..71f6d0919 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -79,9 +79,9 @@ def test_GateCutInterface(self): # the following two methods are the same in the absence of wire cuts. assert ( - list(circuit_converted.exportOutputWires(name_mapping="default")) - == list(circuit_converted.exportOutputWires(name_mapping=None)) - == [0, 1, 2, 3] + circuit_converted.exportOutputWires(name_mapping="default") + == circuit_converted.exportOutputWires(name_mapping=None) + == {0: 0, 1: 1, 2: 2, 3: 3} ) def test_WireCutInterface(self): @@ -95,9 +95,9 @@ def test_WireCutInterface(self): CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) - circuit_converted.insertWireCut( - 2, 1, 1, 4, "LO" - ) # cut first input wire of trial_circuit[2] and map it to wire id 4. + + # cut first input wire of trial_circuit[2] and map it to wire id 4. + circuit_converted.insertWireCut(2, 1, 1, 4, "LO") assert list(circuit_converted.output_wires) == [0, 4, 2, 3] assert circuit_converted.cut_type[2] == "LO" diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 60d177ef4..2a2cb1795 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -2,8 +2,9 @@ from numpy import array from pytest import fixture, raises from qiskit import QuantumCircuit +from typing import Callable from qiskit.circuit.library import EfficientSU2 -from circuit_knitting.cutting.cut_finding.cco_utils import QCtoCCOCircuit +from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, CircuitElement, @@ -15,27 +16,19 @@ DeviceConstraints, ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - PrintActionListWithNames, - DisjointSubcircuitsState, + print_actions_list, ) from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import ( LOCutsOptimizer, - cut_optimization_search_funcs, ) -from circuit_knitting.cutting.cut_finding.cut_optimization import ( - CutOptimizationFuncArgs, -) -from circuit_knitting.cutting.cut_finding.cutting_actions import ( - disjoint_subcircuit_actions, -) -from circuit_knitting.cutting.cut_finding.best_first_search import BestFirstSearch +from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization @fixture def gate_cut_test_setup(): qc = EfficientSU2(4, entanglement="linear", reps=2).decompose() qc.assign_parameters([0.4] * len(qc.parameters), inplace=True) - circuit_internal = QCtoCCOCircuit(qc) + circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) settings.setEngineSelection("CutOptimization", "BestFirst") @@ -53,7 +46,7 @@ def wire_cut_test_setup(): qc.cx(3, 4) qc.cx(3, 5) qc.cx(3, 6) - circuit_internal = QCtoCCOCircuit(qc) + circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) settings.setEngineSelection("CutOptimization", "BestFirst") @@ -64,14 +57,16 @@ def wire_cut_test_setup(): def multiqubit_test_setup(): qc = QuantumCircuit(3) qc.ccx(0, 1, 2) - circuit_internal = QCtoCCOCircuit(qc) + circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) settings.setEngineSelection("CutOptimization", "BestFirst") return interface, settings -def test_no_cuts(gate_cut_test_setup): +def test_no_cuts( + gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): # QPU with 4 qubits requires no cutting. qubits_per_QPU = 4 num_QPUs = 2 @@ -84,12 +79,14 @@ def test_no_cuts(gate_cut_test_setup): output = optimization_pass.optimize(interface, settings, constraint_obj) - assert PrintActionListWithNames(output.actions) == [] # no cutting. + assert print_actions_list(output.actions) == [] # no cutting. assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" -def test_GateCuts(gate_cut_test_setup): +def test_GateCuts( + gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): # QPU with 2 qubits requires cutting. qubits_per_QPU = 2 num_QPUs = 2 @@ -102,7 +99,7 @@ def test_GateCuts(gate_cut_test_setup): output = optimization_pass.optimize() - cut_actions_list = output.CutActionsList() + cut_actions_list = output.cut_actions_sublist() assert cut_actions_list == [ { @@ -129,7 +126,9 @@ def test_GateCuts(gate_cut_test_setup): ).all() # matches known stats. -def test_WireCuts(wire_cut_test_setup): +def test_WireCuts( + wire_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): qubits_per_QPU = 4 num_QPUs = 2 @@ -141,7 +140,7 @@ def test_WireCuts(wire_cut_test_setup): output = optimization_pass.optimize() - cut_actions_list = output.CutActionsList() + cut_actions_list = output.cut_actions_sublist() assert cut_actions_list == [ { @@ -164,7 +163,9 @@ def test_WireCuts(wire_cut_test_setup): # check if unsupported search engine is flagged. -def test_SelectSearchEngine(gate_cut_test_setup): +def test_SelectSearchEngine( + gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): qubits_per_QPU = 4 num_QPUs = 2 @@ -184,7 +185,9 @@ def test_SelectSearchEngine(gate_cut_test_setup): # The cutting of multiqubit gates is not supported at present. -def test_MultiqubitCuts(multiqubit_test_setup): +def test_MultiqubitCuts( + multiqubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): # QPU with 2 qubits requires cutting. qubits_per_QPU = 2 num_QPUs = 2 @@ -203,7 +206,9 @@ def test_MultiqubitCuts(multiqubit_test_setup): ) -def test_UpdatedCostBounds(gate_cut_test_setup): +def test_UpdatedCostBounds( + gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): qubits_per_QPU = 3 num_QPUs = 2 @@ -211,22 +216,14 @@ def test_UpdatedCostBounds(gate_cut_test_setup): constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) - func_args = CutOptimizationFuncArgs() - func_args.entangling_gates = interface.getMultiQubitGates() - func_args.search_actions = disjoint_subcircuit_actions - func_args.max_gamma = settings.getMaxGamma() - func_args.qpu_width = constraint_obj.getQPUWidth() - state = DisjointSubcircuitsState(interface.getNumQubits(), 2) - bfs = BestFirstSearch(settings, cut_optimization_search_funcs) - bfs.initialize([state], func_args) - # Perform cut finding with the default cost upper bound. - state, _ = bfs.optimizationPass(func_args) + cut_opt = CutOptimization(interface, settings, constraint_obj) + state, _ = cut_opt.optimizationPass() assert state is not None # Update and lower cost upper bound. - bfs.updateUpperBoundCost((2, 4)) - state, _ = bfs.optimizationPass(func_args) - assert ( - state is None - ) # Since any cut has a cost of at least 3, the returned state must be None. + cut_opt.updateUpperBoundCost((2, 4)) + state, _ = cut_opt.optimizationPass() + + # Since any cut has a cost of at least 3, the returned state must be None. + assert state is None diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 4eaf5e9f9..7e62f56f0 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -1,4 +1,5 @@ from pytest import fixture +from typing import Callable from circuit_knitting.cutting.cut_finding.circuit_interface import ( CircuitElement, SimpleGateList, @@ -11,7 +12,7 @@ ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( DisjointSubcircuitsState, - PrintActionListWithNames, + print_actions_list, ) from circuit_knitting.cutting.cut_finding.search_space_generator import ActionNames @@ -34,7 +35,14 @@ def testCircuit(): return interface, state, two_qubit_gate -def test_ActionApplyGate(testCircuit): +def test_ActionApplyGate( + testCircuit: Callable[ + [], + tuple[ + SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] + ], + ] +): """Test the application of a gate without any cutting actions.""" _, state, two_qubit_gate = testCircuit @@ -49,7 +57,14 @@ def test_ActionApplyGate(testCircuit): assert actions_list == [] # no actions when the gate is simply applied. -def test_CutTwoQubitGate(testCircuit): +def test_CutTwoQubitGate( + testCircuit: Callable[ + [], + tuple[ + SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] + ], + ] +): """Test the action of cutting a two qubit gate.""" interface, state, two_qubit_gate = testCircuit @@ -60,7 +75,7 @@ def test_CutTwoQubitGate(testCircuit): updated_state = cut_gate.nextStatePrimitive(state, two_qubit_gate, 2) actions_list = [] for state in updated_state: - actions_list.extend(PrintActionListWithNames(state.actions)) + actions_list.extend(print_actions_list(state.actions)) assert actions_list == [ [ "CutTwoQubitGate", @@ -81,7 +96,14 @@ def test_CutTwoQubitGate(testCircuit): assert interface.cut_type[2] == "LO" -def test_CutLeftWire(testCircuit): +def test_CutLeftWire( + testCircuit: Callable[ + [], + tuple[ + SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] + ], + ] +): """Test the action of cutting the first (left) input wire to a two qubit gate.""" _, state, two_qubit_gate = testCircuit cut_left_wire = ActionCutLeftWire() @@ -91,7 +113,7 @@ def test_CutLeftWire(testCircuit): updated_state = cut_left_wire.nextStatePrimitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: - actions_list.extend(PrintActionListWithNames(state.actions)) + actions_list.extend(print_actions_list(state.actions)) assert actions_list[0][0] == "CutLeftWire" assert actions_list[0][1][1] == CircuitElement( name="cx", params=[], qubits=[0, 1], gamma=3 @@ -99,7 +121,14 @@ def test_CutLeftWire(testCircuit): assert actions_list[0][2][0][0] == 1 # the first input ('left') wire is cut. -def test_CutRightWire(testCircuit): +def test_CutRightWire( + testCircuit: Callable[ + [], + tuple[ + SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] + ], + ] +): """Test the action of cutting the second (right) input wire to a two qubit gate.""" _, state, two_qubit_gate = testCircuit cut_right_wire = ActionCutRightWire() @@ -109,7 +138,7 @@ def test_CutRightWire(testCircuit): updated_state = cut_right_wire.nextStatePrimitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: - actions_list.extend(PrintActionListWithNames(state.actions)) + actions_list.extend(print_actions_list(state.actions)) assert actions_list[0][0] == "CutRightWire" assert actions_list[0][1][1] == CircuitElement( name="cx", params=[], qubits=[0, 1], gamma=3 diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 87fa6d85b..df18606fa 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -1,4 +1,5 @@ from pytest import mark, raises, fixture +from typing import Callable from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( DisjointSubcircuitsState, ) @@ -39,7 +40,7 @@ def testCircuit(): return state, two_qubit_gate -def test_StateUncut(testCircuit): +def test_StateUncut(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, _ = testCircuit assert list(state.wiremap) == [0, 1] @@ -57,7 +58,7 @@ def test_StateUncut(testCircuit): assert state.getSearchLevel() == 0 -def test_ApplyGate(testCircuit): +def test_ApplyGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction(None).nextState( @@ -81,7 +82,7 @@ def test_ApplyGate(testCircuit): assert next_state.getSearchLevel() == 1 -def test_CutGate(testCircuit): +def test_CutGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutTwoQubitGate").nextState( @@ -113,7 +114,7 @@ def test_CutGate(testCircuit): ) # equal to lowerBoundGamma for single gate cuts. -def test_CutLeftWire(testCircuit): +def test_CutLeftWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutLeftWire").nextState( @@ -156,7 +157,7 @@ def test_CutLeftWire(testCircuit): assert next_state.upperBoundGamma() == 4 -def test_CutRightWire(testCircuit): +def test_CutRightWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutRightWire").nextState( @@ -189,7 +190,7 @@ def test_CutRightWire(testCircuit): assert next_state.getSearchLevel() == 1 -def test_CutBothWires(testCircuit): +def test_CutBothWires(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutBothWires").nextState( diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index 442fbc68d..1758275ca 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -6,16 +6,16 @@ @pytest.mark.parametrize( "max_gamma, max_backjumps ", - [(0, 1), (-1, 0), (1,-1)], + [(0, 1), (-1, 0), (1, -1)], ) -def test_OptimizationParameters(max_gamma, max_backjumps): +def test_OptimizationParameters(max_gamma: int, max_backjumps:int): """Test optimization parameters for being valid data types.""" with pytest.raises(ValueError): _ = OptimizationSettings(max_gamma=max_gamma, max_backjumps=max_backjumps) -def test_GateCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): +def test_GateCutTypes(LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False): """Test default gate cut types.""" op = OptimizationSettings() op.setGateCutTypes() @@ -23,7 +23,7 @@ def test_GateCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): assert op.gate_cut_LOCC_with_ancillas is False -def test_WireCutTypes(LO=True, LOCC_ancillas=False, LOCC_no_ancillas=False): +def test_WireCutTypes(LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False): """Test default wire cut types.""" op = OptimizationSettings() op.setWireCutTypes() diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index 282286bbd..8b2cb7101 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -5,7 +5,7 @@ @pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)]) -def test_DeviceConstraints(qubits_per_QPU, num_QPUs): +def test_DeviceConstraints(qubits_per_QPU: int, num_QPUs: int): """Test device constraints for being valid data types.""" with pytest.raises(ValueError): @@ -13,7 +13,7 @@ def test_DeviceConstraints(qubits_per_QPU, num_QPUs): @pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(2, 4), (1, 3)]) -def test_getQPUWidth(qubits_per_QPU, num_QPUs): +def test_getQPUWidth(qubits_per_QPU: int, num_QPUs: int): """Test that getQPUWidth returns number of qubits per qpu.""" assert DeviceConstraints(qubits_per_QPU, num_QPUs).getQPUWidth() == qubits_per_QPU From 40fd700c130cae0defb0e1a6d588519fb9d196d4 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 14 Feb 2024 09:13:51 -0500 Subject: [PATCH 072/128] add tests, fix some mypy errors. --- .../cutting/cut_finding/best_first_search.py | 11 +- .../cutting/cut_finding/cco_utils.py | 10 +- .../cutting/cut_finding/circuit_interface.py | 38 +++--- .../cutting/cut_finding/cut_finding.py | 1 + .../cutting/cut_finding/cut_optimization.py | 28 +++-- .../cutting/cut_finding/cutting_actions.py | 115 +++++++++++++----- .../cut_finding/disjoint_subcircuits_state.py | 38 +++--- .../cutting/cut_finding/lo_cuts_optimizer.py | 23 ++-- .../cut_finding/optimization_settings.py | 13 +- .../cut_finding/search_space_generator.py | 30 ++--- .../cut_finding/test_best_first_search.py | 2 + test/cutting/cut_finding/test_cco_utils.py | 2 + .../cut_finding/test_circuit_interfaces.py | 11 ++ .../cut_finding/test_cut_finder_roundtrip.py | 2 + .../cut_finding/test_cutting_actions.py | 3 + .../test_disjoint_subcircuits_state.py | 42 +++++-- .../cut_finding/test_optimization_settings.py | 12 +- .../test_quantum_device_constraints.py | 2 + 18 files changed, 256 insertions(+), 127 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index 9a278919d..c05962fe5 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -15,8 +15,8 @@ import heapq import numpy as np +from numpy.typing import NDArray from typing import TYPE_CHECKING -from numpy import array from itertools import count from .optimization_settings import OptimizationSettings @@ -76,7 +76,7 @@ def __init__(self, rand_seed: int): self.rand_gen = np.random.default_rng(rand_seed) self.unique = count() - self.pqueue = list() + self.pqueue: list[int | DisjointSubcircuitsState | tuple] = list() def put( self, @@ -248,7 +248,7 @@ def __init__( def initialize( self, initial_state_list: list[DisjointSubcircuitsState], - *args: CutOptimizationFuncArgs, + *args, ) -> None: """Clear the priority queue and push an initial list of states into it.""" self.pqueue.clear() @@ -265,7 +265,8 @@ def initialize( self.put(initial_state_list, 0, args) def optimizationPass( - self, *args: CutOptimizationFuncArgs + self, + *args, ) -> ( tuple[None, None] | tuple[ @@ -324,7 +325,7 @@ def minimumReached(self) -> bool: return self.minimum_reached - def getStats(self, penultimate: bool = False) -> array[int, int, int, int]: + def getStats(self, penultimate: bool = False) -> NDArray[np.int_]: """Return a Numpy array containing the number of states visited (dequeued), the number of next-states generated, the number of next-states that are enqueued after cost pruning, and the number diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index 38d4709c1..a230df6aa 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -17,6 +17,7 @@ from qiskit.circuit import Instruction, Gate from .optimization_settings import OptimizationSettings from typing import TYPE_CHECKING + if TYPE_CHECKING: from .cut_optimization import CutOptimizationFuncArgs from .disjoint_subcircuits_state import DisjointSubcircuitsState @@ -47,9 +48,9 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: circuit_list_rep = [] for inst in circuit.data: if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: - circuit_element = "barrier" + circuit_element: CircuitElement | str = "barrier" else: - gamma = None + gamma: int | float | None = None if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: gamma = QPDBasis.from_instruction(inst.operation).kappa name = inst.operation.name @@ -83,6 +84,7 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: qc_cut = QuantumCircuit(num_qubits) for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): if cut_types[k] is None: # only append gates that are not cut. + assert isinstance(op, CircuitElement) op_name = op.name op_qubits = op.qubits op_params = op.params @@ -125,6 +127,10 @@ def greedyBestFirstSearch( search-space functions. """ + assert search_space_funcs.goal_state_func is not None + assert search_space_funcs.cost_func is not None + assert search_space_funcs.next_state_func is not None + if search_space_funcs.goal_state_func(state, *args): return state diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 06243f9ba..aad30e395 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -10,17 +10,15 @@ # that they have been altered from the originals. """Quantum circuit representation compatible with cut-finding optimizer.""" - from __future__ import annotations import copy +import numpy as np import string -from array import array +from numpy.typing import NDArray from abc import ABC, abstractmethod from typing import NamedTuple, Hashable, Iterable -import numpy as np - class CircuitElement(NamedTuple): """Named tuple for specifying a circuit element.""" @@ -28,7 +26,7 @@ class CircuitElement(NamedTuple): name: str params: list[float | int] qubits: list[tuple | int | str] - gamma: float | int + gamma: float | int | None class CircuitInterface(ABC): @@ -166,13 +164,13 @@ class SimpleGateList(CircuitInterface): wire IDs defines a subcircuit. """ - circuit: list[CircuitElement | None] - new_circuit: list[CircuitElement] - cut_type: str | None + circuit: list[list[str | None] | list[CircuitElement | None]] + new_circuit: list[CircuitElement | list[str | int]] + cut_type: list[str | None] qubit_names: NameToIDMap num_qubits: int - new_gate_ID_map: array[int] - output_wires: array[int] + new_gate_ID_map: NDArray[np.int_] + output_wires: NDArray[np.int_] def __init__( self, input_circuit: list[CircuitElement], init_qubit_names: list[Hashable] = [] @@ -215,7 +213,7 @@ def getNumWires(self) -> int: return self.qubit_names.getNumItems() def getMultiQubitGates(self) -> list[int | CircuitElement | None]: - """Extract the multiqubit gates from the circuit and prepends the + """Extract the multiqubit gates from the circuit and prepend the index of the gate in the circuits to the gate specification. The elements of the resulting list therefore have the form @@ -227,16 +225,17 @@ def getMultiQubitGates(self) -> list[int | CircuitElement | None]: The is the list index of the corresponding element in self.circuit. """ - subcircuit = list() + subcircuit: list[list[int | CircuitElement | None]] = list() for k, gate in enumerate(self.circuit): if gate[0] != "barrier": + assert isinstance(gate[0], CircuitElement) if len(gate[0].qubits) > 1 and gate[0].name != "barrier": subcircuit.append([k] + gate) return subcircuit def insertGateCut(self, gate_ID: int, cut_type: str) -> None: - """Mark the specified gate as being cut. The cut type in this release + """Mark the specified gate as being cut. The cut type in this release can only be "LO". """ @@ -287,6 +286,7 @@ def insertWireCut( self.new_gate_ID_map[gate_ID:] += 1 # Update the output wires + assert isinstance(self.circuit[gate_ID][0], CircuitElement) qubit = self.circuit[gate_ID][0].qubits[input_ID - 1] self.output_wires[qubit] = dest_wire_ID @@ -307,7 +307,7 @@ def getWireNames(self) -> list[Hashable | tuple[str, Hashable]]: def exportCutCircuit( self, name_mapping: None | str | dict[Hashable, Hashable] = "default" - ) -> list[CircuitElement | list[str | Hashable | Hashable]]: + ) -> list[CircuitElement | list[str | Hashable]]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -325,7 +325,7 @@ def exportCutCircuit( return out def exportOutputWires( - self, name_mapping: None | str | dict[Hashable, Hashable] = "default" + self, name_mapping: None | str | dict[Hashable, Hashable] = "default" ) -> dict[Hashable, Hashable | tuple[str, Hashable]]: """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. If None @@ -344,7 +344,7 @@ def exportOutputWires( return out def exportSubcircuitsAsString( - self, name_mapping: None | str | dict[Hashable, int] = "default" + self, name_mapping: None | str | dict[Hashable, int] = "default" ) -> str: """Return a string that maps qubits/wires in the output circuit to subcircuits per the Circuit Knitting Toolbox convention. This @@ -362,8 +362,8 @@ def exportSubcircuitsAsString( return "".join(out) def makeWireMapping( - self, name_mapping: None | str | dict[Hashable, Hashable] - ) -> list[Hashable]: + self, name_mapping: None | str | dict[Hashable, Hashable] + ) -> NDArray[np.int_]: """Return a wire-mapping list given an input specification of a name mapping. If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. If "default" @@ -419,7 +419,7 @@ def sortOrder(self, name: Hashable) -> int | float: return self.qubit_names.getID(name) def replaceWireIDs( - self, gate_list: list[CircuitElement], wire_map: list[tuple | int | str] + self, gate_list: list[CircuitElement], wire_map: NDArray[np.int_] ) -> None: """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map. diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 7ad601042..f381e3b37 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -70,6 +70,7 @@ def find_cuts( wire_cut_actions = [] gate_ids = [] + for action in opt_out.actions: if action[0].getName() == "CutTwoQubitGate": gate_ids.append(action[1][0]) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 0775b7052..717b386fc 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -13,9 +13,9 @@ from __future__ import annotations -from dataclasses import dataclass import numpy as np -import array +from dataclasses import dataclass +from numpy.typing import NDArray from .search_space_generator import ActionNames from .cco_utils import selectSearchEngine, greedyBestFirstSearch from .cutting_actions import disjoint_subcircuit_actions @@ -27,27 +27,29 @@ from .disjoint_subcircuits_state import ( DisjointSubcircuitsState, ) -from .circuit_interface import SimpleGateList +from .circuit_interface import SimpleGateList, CircuitElement from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints + @dataclass class CutOptimizationFuncArgs: """Class for passing relevant arguments to the CutOptimization search-space generating functions. """ - entangling_gates = None - search_actions = None - max_gamma = None - qpu_width = None + + entangling_gates: list[int | CircuitElement | None] | None = None + search_actions: ActionNames | None = None + max_gamma: float | int | None = None + qpu_width: float | int | None = None def CutOptimizationCostFunc( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> tuple[int | float, int | float]: """Return the cost function. The particular cost function chosen here - aims to minimize the gamma while also (secondarily) giving preference to + aims to minimize the gamma while also (secondarily) giving preference to circuit partitionings that balance the sizes of the resulting partitions, by minimizing the maximum width across subcircuits. """ @@ -64,7 +66,7 @@ def CutOptimizationUpperBoundCostFunc( def CutOptimizationMinCostBoundFunc( func_args: CutOptimizationFuncArgs, -) -> tuple[int | float, int | float]: +) -> tuple[int | float, int | float] | None: """Return an a priori min-cost bound defined in the optimization settings.""" if func_args.max_gamma is None: # pragma: no cover @@ -75,7 +77,7 @@ def CutOptimizationMinCostBoundFunc( def CutOptimizationNextStateFunc( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs -) -> list[disjoint_subcircuit_actions]: +) -> list[DisjointSubcircuitsState]: """Generate a list of next states from the input state.""" # Get the entangling gate spec that is to be processed next based @@ -127,7 +129,7 @@ def greedyCutOptimization( device_constraints: DeviceConstraints, search_space_funcs: SearchFunctions = cut_optimization_search_funcs, search_actions: ActionNames = disjoint_subcircuit_actions, -) -> greedyBestFirstSearch: +) -> DisjointSubcircuitsState | None: func_args = CutOptimizationFuncArgs() func_args.entangling_gates = circuit_interface.getMultiQubitGates() func_args.search_actions = search_actions @@ -282,7 +284,7 @@ def minimumReached(self) -> bool: return self.search_engine.minimumReached() - def getStats(self, penultimate: bool = False) -> array: + def getStats(self, penultimate: bool = False) -> NDArray[np.int_]: """Return the search-engine statistics.""" return self.search_engine.getStats(penultimate=penultimate) @@ -304,7 +306,7 @@ def maxWireCutsCircuit(circuit_interface: SimpleGateList) -> int: gates in the circuit. """ - return sum([len(x[1]) - 1 for x in circuit_interface.getMultiQubitGates()]) + return sum([len(x[1].qubits) for x in circuit_interface.getMultiQubitGates()]) def maxWireCutsGamma(max_gamma: float | int) -> int: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index ef3315588..9b588948c 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -15,7 +15,9 @@ from __future__ import annotations from abc import ABC, abstractmethod +from typing import Hashable from .search_space_generator import ActionNames +from .circuit_interface import SimpleGateList from .disjoint_subcircuits_state import DisjointSubcircuitsState from .circuit_interface import CircuitElement @@ -44,7 +46,12 @@ def nextStatePrimitive(self, state, gate_spec, max_width): subcircuit cannot exceed max_width. """ - def nextState(self, state, gate_spec, max_width): + def nextState( + self, + state: DisjointSubcircuitsState, + gate_spec: CircuitElement, + max_width: int | float, + ) -> list[DisjointSubcircuitsState]: """Return a list of search states that result from applying the action to gate_spec in the specified DisjointSubcircuitsState state, subject to the constraint that the number of resulting @@ -69,13 +76,16 @@ def getName(self) -> None: return None - def getGroupNames(self) -> None: + def getGroupNames(self) -> list[None | str]: """Return the group name of ActionApplyGate.""" return [None, "TwoQubitGates"] def nextStatePrimitive( - self, state: DisjointSubcircuitsState, gate_spec: CircuitElement, max_width: int + self, + state: DisjointSubcircuitsState, + gate_spec: list[int | CircuitElement | None], + max_width: int | float, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionApplyGate to state given the two-qubit gate @@ -110,24 +120,29 @@ def nextStatePrimitive( return [new_state] -### Adds ActionApplyGate to the object disjoint_subcircuit_actions +### Adds ActionApplyGate to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionApplyGate()) class ActionCutTwoQubitGate(DisjointSearchAction): """Action of cutting a two-qubit gate.""" - def getName(self): + def getName(self) -> str: """Return the look-up name of ActionCutTwoQubitGate.""" return "CutTwoQubitGate" - def getGroupNames(self): + def getGroupNames(self) -> list[str]: """Return the group name of ActionCutTwoQubitGate.""" return ["GateCut", "TwoQubitGates"] - def nextStatePrimitive(self, state, gate_spec, max_width): + def nextStatePrimitive( + self, + state: DisjointSubcircuitsState, + gate_spec: list[int | CircuitElement | None], + max_width: int | float, + ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutTwoQubitGate to state given the gate_spec. """ @@ -170,7 +185,9 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] @staticmethod - def getCostParams(gate_spec): + def getCostParams( + gate_spec: CircuitElement, + ) -> tuple[int | float, int, int | float]: """ Get the cost parameters. @@ -183,7 +200,13 @@ def getCostParams(gate_spec): gamma = gate_spec[1].gamma return (gamma, 0, gamma) - def exportCuts(self, circuit_interface, wire_map, gate_spec, args): + def exportCuts( + self, + circuit_interface: SimpleGateList, + wire_map: list[Hashable], + gate_spec: list[int | CircuitElement | None], + args, + ) -> None: """Insert an LO gate cut into the input circuit for the specified gate and cut arguments. """ @@ -191,7 +214,7 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, args): circuit_interface.insertGateCut(gate_spec[0], "LO") -### Adds ActionCutTwoQubitGate to the object disjoint_subcircuit_actions +### Adds ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionCutTwoQubitGate()) @@ -200,17 +223,22 @@ class ActionCutLeftWire(DisjointSearchAction): """Action class that implements the action of cutting the left (first) wire of a two-qubit gate""" - def getName(self): + def getName(self) -> str: """Return the look-up name of ActionCutLeftWire.""" return "CutLeftWire" - def getGroupNames(self): + def getGroupNames(self) -> list[str]: """Return the group name of ActionCutLeftWire.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive(self, state, gate_spec, max_width): + def nextStatePrimitive( + self, + state: DisjointSubcircuitsState, + gate_spec: list[int, CircuitElement, None], + max_width: int, + ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutLeftWire to state given the gate_spec. """ @@ -251,7 +279,13 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] - def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): + def exportCuts( + self, + circuit_interface: SimpleGateList, + wire_map: list[Hashable], + gate_spec: CircuitElement, + cut_args, + ) -> None: """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. """ @@ -259,11 +293,16 @@ def exportCuts(self, circuit_interface, wire_map, gate_spec, cut_args): insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutLeftWire to the object disjoint_subcircuit_actions +### Adds ActionCutLeftWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) -def insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args): +def insertAllLOWireCuts( + circuit_interface: SimpleGateList, + wire_map: list[Hashable], + gate_spec: CircuitElement, + cut_args, +) -> None: """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments. """ @@ -279,17 +318,22 @@ class ActionCutRightWire(DisjointSearchAction): """Action class that implements the action of cutting the right (second) wire of a two-qubit gate""" - def getName(self): + def getName(self) -> str: """Return the look-up name of ActionCutRightWire.""" return "CutRightWire" - def getGroupNames(self): + def getGroupNames(self) -> list[str, str]: """Return the group name of ActionCutRightWire.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive(self, state, gate_spec, max_width): + def nextStatePrimitive( + self, + state: DisjointSubcircuitsState, + gate_spec: CircuitElement, + max_width: int | float, + ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutRightWire to state given the gate_spec. """ @@ -331,8 +375,12 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] def exportCuts( - self, circuit_interface, wire_map, gate_spec, cut_args - ): # pragma: no cover + self, + circuit_interface: SimpleGateList, + wire_map: list[Hashable], + gate_spec: CircuitElement, + cut_args, + ) -> None: # pragma: no cover """Insert an LO wire cut into the input circuit for the specified gate and cut arguments. """ @@ -340,7 +388,7 @@ def exportCuts( insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutRightWire to the object disjoint_subcircuit_actions +### Adds ActionCutRightWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionCutRightWire()) @@ -349,17 +397,22 @@ class ActionCutBothWires(DisjointSearchAction): """Action class that implements the action of cutting both wires of a two-qubit gate""" - def getName(self): + def getName(self) -> str: """Return the look-up name of ActionCutBothWires.""" return "CutBothWires" - def getGroupNames(self): + def getGroupNames(self) -> list[str]: """Return the group name of ActionCutBothWires.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive(self, state, gate_spec, max_width): + def nextStatePrimitive( + self, + state: DisjointSubcircuitsState, + gate_spec: list[int | CircuitElement | None], + max_width: int | float, + ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutBothWires to state given the gate_spec. """ @@ -403,14 +456,18 @@ def nextStatePrimitive(self, state, gate_spec, max_width): return [new_state] def exportCuts( - self, circuit_interface, wire_map, gate_spec, cut_args - ): # pragma: no cover - """Insert an LO wire cut into the input circuit for the specified + self, + circuit_interface: SimpleGateList, + wire_map: list[Hashable], + gate_spec: CircuitElement, + cut_args, + ) -> None: # pragma: no cover + """Insert LO wire cuts into the input circuit for the specified gate and cut arguments. """ insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutBothWires to the object disjoint_subcircuit_actions +### Adds ActionCutBothWires to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.defineAction(ActionCutBothWires()) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index adda7ec11..dbb44c54b 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -15,8 +15,9 @@ import copy import numpy as np -from typing import Hashable, Iterable +from numpy.typing import NDArray from collections import Counter +from typing import Hashable, Iterable from .circuit_interface import CircuitElement, SimpleGateList @@ -87,7 +88,7 @@ class DisjointSubcircuitsState: state resides, with 0 being the root of the search tree. """ - def __init__(self, num_qubits: int = None, max_wire_cuts: int = None): + def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = None): """An instance of :class:`DisjointSubcircuitsState` must be initialized with a specification of the number of qubits in the circuit and the maximum number of wire cuts that can be performed.""" @@ -106,20 +107,20 @@ def __init__(self, num_qubits: int = None, max_wire_cuts: int = None): ) if num_qubits is None or max_wire_cuts is None: - self.wiremap = None - self.num_wires = None + self.wiremap: NDArray[np.int_] | None = None + self.num_wires: int | None = None - self.uptree = None - self.width = None + self.uptree: NDArray[np.int_] | None = None + self.width: NDArray[np.int_] | None = None - self.bell_pairs = None - self.gamma_LB = None - self.gamma_UB = None + self.bell_pairs: list[tuple] | None = None + self.gamma_LB: float | None = None + self.gamma_UB: float | None = None - self.no_merge = None - self.actions = None - self.level = None - self.cut_actions_list = None + self.no_merge: list | None = None + self.actions: list | None = None + self.cut_actions_list: list | None = None + self.level: int | None = None else: max_wires = num_qubits + max_wire_cuts @@ -253,7 +254,7 @@ def findRootBellPair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: r1 = self.findWireRoot(bell_pair[1]) return (r0, r1) if (r0 < r1) else (r1, r0) - def lowerBoundGamma(self) -> float: + def lowerBoundGamma(self) -> int | float: """Calculate a lower bound for gamma using the current counts for the different types of circuit cuts. """ @@ -262,7 +263,7 @@ def lowerBoundGamma(self) -> float: return self.gamma_LB * calcRootBellPairsGamma(root_bell_pairs) - def upperBoundGamma(self) -> float: + def upperBoundGamma(self) -> int | float: """Calculate an upper bound for gamma using the current counts for the different types of circuit cuts. """ @@ -360,7 +361,7 @@ def verifyMergeConstraints(self) -> bool: return True - def assertDoNotMergeRoots(self, wire_1: int, wire_2: int) -> bool: + def assertDoNotMergeRoots(self, wire_1: int, wire_2: int) -> None: """Add a constraint that the subcircuits associated with wires IDs wire_1 and wire_2 should not be merged. """ @@ -369,6 +370,7 @@ def assertDoNotMergeRoots(self, wire_1: int, wire_2: int) -> bool: wire_2 ), f"{wire_1} cannot be the same subcircuit as {wire_2}" + assert isinstance(self.no_merge, list) self.no_merge.append((wire_1, wire_2)) def mergeRoots(self, root_1: int, root_2: int) -> None: @@ -403,7 +405,7 @@ def getSearchLevel(self) -> int: return self.level - def setNextLevel(self, state: DisjointSubcircuitsState) -> int: + def setNextLevel(self, state: DisjointSubcircuitsState) -> None: """Set the search level of self to one plus the search level of the input state. """ @@ -451,7 +453,7 @@ def calcRootBellPairsGamma(root_bell_pairs: Iterable[Hashable]) -> float: def print_actions_list( - action_list: list[DisjointSubcircuitsState.actions], + action_list: list[DisjointSubcircuitsState], ) -> list[list[str | list | tuple]]: """Return a list specifying action objects that represent cutting actions assoicated with an instance of :class:`DisjointSubcircuitsState`. diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index d550d4840..d8b267aae 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -20,7 +20,8 @@ from .cut_optimization import CutOptimizationUpperBoundCostFunc from .search_space_generator import SearchFunctions, SearchSpaceGenerator -from numpy import array +import numpy as np +from numpy.typing import NDArray from .disjoint_subcircuits_state import DisjointSubcircuitsState from .quantum_device_constraints import DeviceConstraints from .optimization_settings import OptimizationSettings @@ -54,22 +55,22 @@ class LOCutsOptimizer: Member Variables: - circuit_interface (CircuitInterface) defines the circuit to be cut. + circuit_interface (:class:`CircuitInterface`) defines the circuit to be cut. - optimization_settings (OptimizationSettings) defines the settings + optimization_settings (:class:`OptimizationSettings`) defines the settings to be used for the optimization. - device_constraints (DeviceConstraints) defines the capabilties of + device_constraints (:class:`DeviceConstraints`) defines the capabilties of the target quantum hardware. search_engine_config (dict) maps names of stages of optimization to the corresponding SearchSpaceGenerator functions and actions that are used to perform the search for each stage. - cut_optimization (CutOptimization) is the object created to + cut_optimization (:class:`CutOptimization`) is the object created to perform the circuit cutting optimization. - best_result (DisjointSubcircuitsState) is the lowest-cost + best_result (:class:`DisjointSubcircuitsState`) is the lowest-cost DisjointSubcircuitsState object identified in the search. """ @@ -95,9 +96,9 @@ def __init__( def optimize( self, - circuit_interface: SimpleGateList = None, - optimization_settings: OptimizationSettings = None, - device_constraints: DeviceConstraints = None, + circuit_interface: SimpleGateList | None = None, + optimization_settings: OptimizationSettings | None = None, + device_constraints: DeviceConstraints | None = None, ) -> DisjointSubcircuitsState | None: """Method to optimize the cutting of a circuit. @@ -168,8 +169,8 @@ def getResults(self) -> DisjointSubcircuitsState | None: return self.best_result - def getStats(self, penultimate=False) -> array[int | float]: - """Return the optimization results.""" + def getStats(self, penultimate=False) -> dict[str, NDArray[np.int_]]: + """Return a dictionary containing optimization results.""" return { "CutOptimization": self.cut_optimization.getStats(penultimate=penultimate) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index e7bf34419..1d6cc1a16 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -14,6 +14,7 @@ from __future__ import annotations from dataclasses import dataclass +from typing import Dict @dataclass @@ -93,16 +94,18 @@ def getMaxBackJumps(self) -> int: """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def getRandSeed(self) -> int: + def getRandSeed(self) -> int | None: """Return the random seed.""" return self.rand_seed def getEngineSelection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" + assert self.engine_selections is not None return self.engine_selections[stage_of_optimization] def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: """Set the name of the search engine to employ.""" + assert self.engine_selections is not None self.engine_selections[stage_of_optimization] = engine_name def setGateCutTypes(self) -> None: @@ -121,11 +124,11 @@ def setWireCutTypes(self) -> None: self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas - def getCutSearchGroups(self) -> list[str]: + def getCutSearchGroups(self) -> list[None | str]: """Return a list of search-action groups to include in the optimization for cutting circuits into disjoint subcircuits. """ - + out: list out = [None] if self.gate_cut_LO or self.gate_cut_LOCC_with_ancillas: @@ -141,5 +144,7 @@ def getCutSearchGroups(self) -> list[str]: return out @classmethod - def from_dict(cls, options: dict[str, int]) -> OptimizationSettings: + def from_dict( + cls, options: dict # dict[str, None | int | bool | dict[str, str]] + ) -> OptimizationSettings: return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 338b02993..ccc76f48f 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -14,7 +14,7 @@ from dataclasses import dataclass -from typing import Callable, Iterable, TYPE_CHECKING +from typing import Callable, TYPE_CHECKING from .disjoint_subcircuits_state import DisjointSubcircuitsState @@ -43,13 +43,15 @@ def __init__(self): self.action_dict = dict() self.group_dict = dict() - def copy(self, list_of_groups: list[str] = None) -> ActionNames: + def copy( + self, list_of_groups: list[DisjointSearchAction | None] | None = None + ) -> ActionNames: """Return a copy of :class:`ActionNames` that contains only those actions whose group affiliations intersect with list_of_groups. The default is to return a copy containing all actions. """ - action_list = getActionSubset(self.action_dict.values(), list_of_groups) + action_list = getActionSubset(list(self.action_dict.values()), list_of_groups) new_container = ActionNames() for action in action_list: @@ -101,7 +103,7 @@ def getGroup(self, group_name: str) -> list[DisjointSearchAction] | None: def getActionSubset( - action_list: list, action_groups: Iterable[DisjointSearchAction] + action_list: list, action_groups: list[DisjointSearchAction | None] | None ) -> list[DisjointSearchAction]: """Return the subset of actions in action_list whose group affiliations intersect with action_groups. @@ -163,27 +165,27 @@ class SearchFunctions: """ cost_func: Callable[ - [DisjointSubcircuitsState, SearchFunctions], + [DisjointSubcircuitsState, CutOptimizationFuncArgs], int | float | tuple[int | float, int | float], - ] = (None,) + ] | None = None next_state_func: Callable[ [DisjointSubcircuitsState, CutOptimizationFuncArgs], list[DisjointSubcircuitsState], - ] = (None,) + ] | None = None goal_state_func: Callable[ [DisjointSubcircuitsState, CutOptimizationFuncArgs], bool - ] = (None,) + ] | None = None - upperbound_cost_func: None | Callable[ + upperbound_cost_func: Callable[ [DisjointSubcircuitsState, CutOptimizationFuncArgs], tuple[int | float, int | float], - ] = (None,) + ] | None = None - mincost_bound_func: None | Callable[ + mincost_bound_func: Callable[ [CutOptimizationFuncArgs], None | tuple[int | float, int | float] - ] = None + ] | None = None @dataclass @@ -203,5 +205,5 @@ class SearchSpaceGenerator: functions by a search engine. """ - functions: SearchFunctions = None - actions: ActionNames = None + functions: SearchFunctions | None = None + actions: ActionNames | None = None diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 2da714d1f..256627eca 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from pytest import fixture from numpy import inf from circuit_knitting.cutting.cut_finding.circuit_interface import ( diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index 488d12a60..5e3e9c370 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import pytest from pytest import fixture from qiskit.circuit.library import EfficientSU2 diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 71f6d0919..6689548ca 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -1,8 +1,15 @@ +from __future__ import annotations + from circuit_knitting.cutting.cut_finding.circuit_interface import ( CircuitElement, SimpleGateList, ) +from circuit_knitting.cutting.cut_finding.cut_optimization import ( + maxWireCutsCircuit, + maxWireCutsGamma, +) + class TestCircuitInterface: def test_CircuitConversion(self): @@ -30,6 +37,7 @@ def test_CircuitConversion(self): assert circuit_converted.getMultiQubitGates() == [ [4, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None] ] + assert circuit_converted.circuit == [ [CircuitElement(name="h", params=[], qubits=[0], gamma=None), None], [CircuitElement(name="barrier", params=[], qubits=[0], gamma=None), None], @@ -38,6 +46,9 @@ def test_CircuitConversion(self): [CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], ] + assert maxWireCutsCircuit(circuit_converted) == 2 + assert maxWireCutsGamma(7) == 2 + # Assign by hand a different qubit mapping by specifiying init_qubit_names. circuit_converted = SimpleGateList(trial_circuit, ["q0", "q1"]) assert circuit_converted.qubit_names.item_dict == {"q0": 0, "q1": 1} diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 2a2cb1795..f5a3db102 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import numpy as np from numpy import array from pytest import fixture, raises diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 7e62f56f0..a8a599c34 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from pytest import fixture from typing import Callable from circuit_knitting.cutting.cut_finding.circuit_interface import ( @@ -114,6 +116,7 @@ def test_CutLeftWire( actions_list = [] for state in updated_state: actions_list.extend(print_actions_list(state.actions)) + # TO-DO: Consider replacing actions_list to a NamedTuple. assert actions_list[0][0] == "CutLeftWire" assert actions_list[0][1][1] == CircuitElement( name="cx", params=[], qubits=[0, 1], gamma=3 diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index df18606fa..6a90379d2 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from pytest import mark, raises, fixture from typing import Callable from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( @@ -40,7 +42,11 @@ def testCircuit(): return state, two_qubit_gate -def test_StateUncut(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_StateUncut( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, _ = testCircuit assert list(state.wiremap) == [0, 1] @@ -58,7 +64,11 @@ def test_StateUncut(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, li assert state.getSearchLevel() == 0 -def test_ApplyGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_ApplyGate( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction(None).nextState( @@ -82,7 +92,11 @@ def test_ApplyGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, lis assert next_state.getSearchLevel() == 1 -def test_CutGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_CutGate( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutTwoQubitGate").nextState( @@ -114,7 +128,11 @@ def test_CutGate(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[ ) # equal to lowerBoundGamma for single gate cuts. -def test_CutLeftWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_CutLeftWire( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutLeftWire").nextState( @@ -157,7 +175,11 @@ def test_CutLeftWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, l assert next_state.upperBoundGamma() == 4 -def test_CutRightWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_CutRightWire( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutRightWire").nextState( @@ -190,7 +212,11 @@ def test_CutRightWire(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, assert next_state.getSearchLevel() == 1 -def test_CutBothWires(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]]]): +def test_CutBothWires( + testCircuit: Callable[ + [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] + ] +): state, two_qubit_gate = testCircuit next_state = disjoint_subcircuit_actions.getAction("CutBothWires").nextState( @@ -227,9 +253,7 @@ def test_CutBothWires(testCircuit: Callable[[], tuple[DisjointSubcircuitsState, assert next_state.getSearchLevel() == 1 - assert ( - next_state.lowerBoundGamma() == 9 - ) # The 3^n scaling which is possible with LOCC. + assert next_state.lowerBoundGamma() == 9 # 3^n scaling. assert next_state.upperBoundGamma() == 16 # The 4^n scaling that comes with LO. diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index 1758275ca..af0b7537b 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import pytest from circuit_knitting.cutting.cut_finding.optimization_settings import ( OptimizationSettings, @@ -8,14 +10,16 @@ "max_gamma, max_backjumps ", [(0, 1), (-1, 0), (1, -1)], ) -def test_OptimizationParameters(max_gamma: int, max_backjumps:int): +def test_OptimizationParameters(max_gamma: int, max_backjumps: int): """Test optimization parameters for being valid data types.""" with pytest.raises(ValueError): _ = OptimizationSettings(max_gamma=max_gamma, max_backjumps=max_backjumps) -def test_GateCutTypes(LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False): +def test_GateCutTypes( + LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False +): """Test default gate cut types.""" op = OptimizationSettings() op.setGateCutTypes() @@ -23,7 +27,9 @@ def test_GateCutTypes(LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_anci assert op.gate_cut_LOCC_with_ancillas is False -def test_WireCutTypes(LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False): +def test_WireCutTypes( + LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False +): """Test default wire cut types.""" op = OptimizationSettings() op.setWireCutTypes() diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index 8b2cb7101..c33024eb6 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import pytest from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( DeviceConstraints, From 5cdcb68156865dfda7183f079f4ccaa124366e18 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 20 Feb 2024 13:55:19 -0500 Subject: [PATCH 073/128] Correct mypy errors, fix bugs in tests. --- .../cutting/cut_finding/best_first_search.py | 52 ++++---- .../cutting/cut_finding/cco_utils.py | 14 ++- .../cutting/cut_finding/circuit_interface.py | 117 ++++++++++-------- .../cutting/cut_finding/cut_finding.py | 4 + .../cutting/cut_finding/cut_optimization.py | 39 ++++-- .../cutting/cut_finding/cutting_actions.py | 80 +++++++----- .../cut_finding/disjoint_subcircuits_state.py | 84 +++++++++---- .../cut_finding/optimization_settings.py | 6 +- .../cut_finding/search_space_generator.py | 9 +- .../tutorials/04_automatic_cut_finding.ipynb | 42 ++----- .../tutorials/LO_circuit_cut_finder.ipynb | 12 +- test/cutting/cut_finding/__init__.py | 1 - .../cut_finding/test_circuit_interfaces.py | 4 +- .../cut_finding/test_cut_finder_roundtrip.py | 11 +- 14 files changed, 281 insertions(+), 194 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index c05962fe5..b08dbb14d 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -16,7 +16,8 @@ import heapq import numpy as np from numpy.typing import NDArray -from typing import TYPE_CHECKING +from numpy.random._generator import Generator +from typing import TYPE_CHECKING, Callable, cast from itertools import count from .optimization_settings import OptimizationSettings @@ -66,17 +67,17 @@ class BestFirstPriorityQueue: queue.PriorityQueue if parallelization is ultimately required). """ - def __init__(self, rand_seed: int): + def __init__(self, rand_seed: int | None): """A BestFirstPriorityQueue object must be initialized with a specification of a random seed (int) for the pseudo-random number - generator. If None is used as the random seed, then a seed is + generator. If None is used as the random seed, then a seed is obtained using an operating-system call to achieve a randomized initialization. """ - self.rand_gen = np.random.default_rng(rand_seed) - self.unique = count() - self.pqueue: list[int | DisjointSubcircuitsState | tuple] = list() + self.rand_gen: Generator = np.random.default_rng(rand_seed) + self.unique: count[int] = count() + self.pqueue: list[tuple] = list() def put( self, @@ -95,12 +96,7 @@ def put( def get( self, - ) -> ( - tuple[None, None, None] - | tuple[ - DisjointSubcircuitsState, int, int | float | tuple[int | float, int | float] - ] - ): + ) -> tuple: """Pop and return the lowest cost state currently on the queue, along with the search depth of that state and its cost. None, None, None is returned if the priority queue is empty. @@ -109,7 +105,7 @@ def get( if self.qsize() == 0: # pragma: no cover return None, None, None - best = heapq.heappop(self.pqueue) + best: tuple = heapq.heappop(self.pqueue) return best[-1], (-best[1]), best[0] @@ -243,12 +239,12 @@ def __init__( self.num_next_states = 0 self.num_enqueues = 0 self.num_backjumps = 0 - self.penultimate_stats = None + self.penultimate_stats: NDArray | None = None def initialize( self, initial_state_list: list[DisjointSubcircuitsState], - *args, + *args: CutOptimizationFuncArgs, ) -> None: """Clear the priority queue and push an initial list of states into it.""" self.pqueue.clear() @@ -266,7 +262,7 @@ def initialize( def optimizationPass( self, - *args, + *args: CutOptimizationFuncArgs, ) -> ( tuple[None, None] | tuple[ @@ -282,7 +278,7 @@ def optimizationPass( """ if self.mincost_bound_func is not None: - self.mincost_bound = self.mincost_bound_func(*args) + self.mincost_bound = self.mincost_bound_func(*args) # type: ignore prev_depth = None @@ -304,6 +300,8 @@ def optimizationPass( self.num_backjumps += 1 prev_depth = depth + state = cast(DisjointSubcircuitsState, state) + self.goal_state_func = cast(Callable, self.goal_state_func) if self.goal_state_func(state, *args): self.penultimate_stats = self.getStats() self.updateUpperBoundGoalState(state, *args) @@ -311,7 +309,9 @@ def optimizationPass( return state, cost + self.next_state_func = cast(Callable, self.next_state_func) next_state_list = self.next_state_func(state, *args) + depth = cast(int, depth) self.put(next_state_list, depth + 1, args) # If all states have been explored, then the minimum has been reached @@ -325,11 +325,13 @@ def minimumReached(self) -> bool: return self.minimum_reached - def getStats(self, penultimate: bool = False) -> NDArray[np.int_]: + def getStats(self, penultimate: bool = False) -> NDArray[np.int_] | None: """Return a Numpy array containing the number of states visited (dequeued), the number of next-states generated, the number of next-states that are enqueued after cost pruning, and the number - of backjumps performed. + of backjumps performed. Return None if no search is performed. + If the bool penultimate is set to True, return the stats that + correspond to the penultimate step in the search. """ if penultimate: @@ -345,7 +347,7 @@ def getStats(self, penultimate: bool = False) -> NDArray[np.int_]: dtype=int, ) - def getUpperBoundCost(self) -> int | float | tuple[int | float, int | float]: + def getUpperBoundCost(self) -> int | float | tuple[int | float, int | float] | None: """Return the current upperbound cost""" return self.upperbound_cost @@ -360,7 +362,7 @@ def updateUpperBoundCost( if cost_bound is not None and ( self.upperbound_cost is None or cost_bound < self.upperbound_cost ): - self.upperbound_cost = cost_bound + self.upperbound_cost = cost_bound # type: ignore def updateUpperBoundGoalState( self, goal_state: DisjointSubcircuitsState, *args: CutOptimizationFuncArgs @@ -372,16 +374,17 @@ def updateUpperBoundGoalState( if self.upperbound_cost_func is not None: bound = self.upperbound_cost_func(goal_state, *args) else: # pragma: no cover - bound = self.cost_func(goal_state, *args) + assert self.cost_func is not None + bound = self.cost_func(goal_state, *args) # type: ignore if self.upperbound_cost is None or bound < self.upperbound_cost: - self.upperbound_cost = bound + self.upperbound_cost = bound # type: ignore def put( self, state_list: list[DisjointSubcircuitsState], depth: int, - args: CutOptimizationFuncArgs, + args: tuple[CutOptimizationFuncArgs, ...], ) -> None: """Push a list of (next) states onto the best-first priority queue. @@ -390,6 +393,7 @@ def put( self.num_next_states += len(state_list) for state in state_list: + assert self.cost_func is not None cost = self.cost_func(state, *args) if self.upperbound_cost is None or cost <= self.upperbound_cost: diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index a230df6aa..0d3b475e5 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -16,7 +16,7 @@ from qiskit import QuantumCircuit from qiskit.circuit import Instruction, Gate from .optimization_settings import OptimizationSettings -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, cast, Callable if TYPE_CHECKING: from .cut_optimization import CutOptimizationFuncArgs @@ -84,7 +84,7 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: qc_cut = QuantumCircuit(num_qubits) for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): if cut_types[k] is None: # only append gates that are not cut. - assert isinstance(op, CircuitElement) + op = cast(CircuitElement, op) op_name = op.name op_qubits = op.qubits op_params = op.params @@ -127,9 +127,13 @@ def greedyBestFirstSearch( search-space functions. """ - assert search_space_funcs.goal_state_func is not None - assert search_space_funcs.cost_func is not None - assert search_space_funcs.next_state_func is not None + search_space_funcs.goal_state_func = cast( + Callable, search_space_funcs.goal_state_func + ) + search_space_funcs.cost_func = cast(Callable, search_space_funcs.cost_func) + search_space_funcs.next_state_func = cast( + Callable, search_space_funcs.next_state_func + ) if search_space_funcs.goal_state_func(state, *args): return state diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index aad30e395..e282a918e 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -17,7 +17,7 @@ import string from numpy.typing import NDArray from abc import ABC, abstractmethod -from typing import NamedTuple, Hashable, Iterable +from typing import NamedTuple, Hashable, Iterable, cast, Sequence, Union class CircuitElement(NamedTuple): @@ -25,8 +25,8 @@ class CircuitElement(NamedTuple): name: str params: list[float | int] - qubits: list[tuple | int | str] - gamma: float | int | None + qubits: Sequence[int | tuple[str, int]] + gamma: int | float | None class CircuitInterface(ABC): @@ -50,7 +50,7 @@ def getMultiQubitGates(self): specifies the multiqubit gates in the input circuit. The returned list is of the form: - [ ... [ ] ...] + [ ... [ ] ...] The can be any object that uniquely identifies the gate in the circuit. The can be used as an argument in other @@ -67,7 +67,7 @@ def getMultiQubitGates(self): starting with zero. Derived classes are responsible for constructing the mappings from external qubit identifiers to the corresponding qubit IDs. - The can be of the form + The can be of the form None [] [None] @@ -87,7 +87,7 @@ def getMultiQubitGates(self): @abstractmethod def insertGateCut(self, gate_ID, cut_type): """Derived classes must override this function and mark the specified - gate as being cut. The cut type can only be "LO" in this release. + gate as being cut. The cut types can only be "LO" in this release. """ @abstractmethod @@ -115,7 +115,7 @@ class SimpleGateList(CircuitInterface): """Derived class that converts a simple list of gates into the form needed by the circuit-cutting optimizer code. - Elements of the list must be instances of :class:`CircuitElement`. + Elements of the input list must be instances of :class:`CircuitElement`. The only exception to this is a barrier when one is placed across all the qubits in a circuit. That is specified by the string: "barrier". @@ -165,7 +165,7 @@ class SimpleGateList(CircuitInterface): """ circuit: list[list[str | None] | list[CircuitElement | None]] - new_circuit: list[CircuitElement | list[str | int]] + new_circuit: Sequence[CircuitElement | str | list[str | int]] cut_type: list[str | None] qubit_names: NameToIDMap num_qubits: int @@ -173,7 +173,9 @@ class SimpleGateList(CircuitInterface): output_wires: NDArray[np.int_] def __init__( - self, input_circuit: list[CircuitElement], init_qubit_names: list[Hashable] = [] + self, + input_circuit: Sequence[CircuitElement | str], + init_qubit_names: list[Hashable] = [], ): self.qubit_names = NameToIDMap(init_qubit_names) @@ -200,7 +202,7 @@ def __init__( self.output_wires = np.arange(self.num_qubits, dtype=int) # Initialize the list of subcircuits assuming no cutting - self.subcircuits = list(list(range(self.num_qubits))) + self.subcircuits: Sequence[list[int] | int] = list(list(range(self.num_qubits))) def getNumQubits(self) -> int: """Return the number of qubits in the input circuit.""" @@ -212,24 +214,26 @@ def getNumWires(self) -> int: return self.qubit_names.getNumItems() - def getMultiQubitGates(self) -> list[int | CircuitElement | None]: + def getMultiQubitGates( + self, + ) -> Sequence[Sequence[int | CircuitElement | None | list]]: """Extract the multiqubit gates from the circuit and prepend the index of the gate in the circuits to the gate specification. The elements of the resulting list therefore have the form [ ] - The and have the forms + The and have the forms described above. The is the list index of the corresponding element in self.circuit. """ - subcircuit: list[list[int | CircuitElement | None]] = list() + subcircuit: Sequence[Sequence[int | CircuitElement | None | list]] = list() for k, gate in enumerate(self.circuit): if gate[0] != "barrier": - assert isinstance(gate[0], CircuitElement) - if len(gate[0].qubits) > 1 and gate[0].name != "barrier": + if len(gate[0].qubits) > 1 and gate[0].name != "barrier": # type: ignore + subcircuit = cast(list, subcircuit) subcircuit.append([k] + gate) return subcircuit @@ -275,19 +279,23 @@ def insertWireCut( # Replace src_wire_ID with dest_wire_ID in the part of new_circuit that # follows the wire-cut insertion point - wire_map = np.arange(self.qubit_names.getArraySizeNeeded(), dtype=int) + wire_map = list(range(self.qubit_names.getArraySizeNeeded())) wire_map[src_wire_ID] = dest_wire_ID + self.new_circuit = cast( + Sequence[Union[CircuitElement, list[Union[str, int]]]], self.new_circuit + ) self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) # Insert a move operator + self.new_circuit = cast(list, self.new_circuit) self.new_circuit.insert(gate_pos, ["move", src_wire_ID, dest_wire_ID]) self.cut_type.insert(gate_pos, cut_type) self.new_gate_ID_map[gate_ID:] += 1 # Update the output wires - assert isinstance(self.circuit[gate_ID][0], CircuitElement) - qubit = self.circuit[gate_ID][0].qubits[input_ID - 1] + op = cast(CircuitElement, self.circuit[gate_ID][0]) + qubit = op.qubits[input_ID - 1] self.output_wires[qubit] = dest_wire_ID def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: @@ -297,7 +305,7 @@ def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: self.subcircuits = list_of_list_of_wires - def getWireNames(self) -> list[Hashable | tuple[str, Hashable]]: + def getWireNames(self) -> list[Hashable]: """Return a list of the internal wire names used in the circuit, which consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. @@ -306,26 +314,28 @@ def getWireNames(self) -> list[Hashable | tuple[str, Hashable]]: return list(self.qubit_names.getItems()) def exportCutCircuit( - self, name_mapping: None | str | dict[Hashable, Hashable] = "default" - ) -> list[CircuitElement | list[str | Hashable]]: + self, + name_mapping: None | str = "default", + ) -> Sequence[CircuitElement | list[str | int]]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping then the defaultWireNameMapping() method defines the name mapping. - Otherwise, the name_mapping is assumed to be a dictionary that maps - internal wire names to desired names. """ wire_map = self.makeWireMapping(name_mapping) out = copy.deepcopy(self.new_circuit) + out = cast(Sequence[Union[CircuitElement, list[Union[str, int]]]], out) + wire_map = cast(list[int], wire_map) self.replaceWireIDs(out, wire_map) return out def exportOutputWires( - self, name_mapping: None | str | dict[Hashable, Hashable] = "default" + self, + name_mapping: None | str = "default", ) -> dict[Hashable, Hashable | tuple[str, Hashable]]: """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. If None @@ -333,8 +343,6 @@ def exportOutputWires( used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping then the defaultWireNameMapping() method defines the name mapping. - Otherwise, the name_mapping is assumed to be a dictionary that maps - internal wire names to desired names. """ wire_map = self.makeWireMapping(name_mapping) @@ -344,32 +352,35 @@ def exportOutputWires( return out def exportSubcircuitsAsString( - self, name_mapping: None | str | dict[Hashable, int] = "default" + self, + name_mapping: None | str = "default", ) -> str: """Return a string that maps qubits/wires in the output circuit to subcircuits per the Circuit Knitting Toolbox convention. This - method only works with mappings to numeric qubit/wire names, such - as provided by "default" or a custom name_mapping. + method only works with mappings to numeric qubit/wire names. """ wire_map = self.makeWireMapping(name_mapping) + wire_map = cast(list[int], wire_map) - out = list(range(self.getNumWires())) + out: list[int] | list[str] = list(range(self.getNumWires())) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): + subcircuit = cast(list[int], subcircuit) for wire in subcircuit: + out = cast(list[str], out) out[wire_map[wire]] = alphabet[k] + out = cast(list[str], out) return "".join(out) def makeWireMapping( - self, name_mapping: None | str | dict[Hashable, Hashable] - ) -> NDArray[np.int_]: + self, name_mapping: None | str | dict + ) -> Sequence[int | tuple[str, int]]: """Return a wire-mapping list given an input specification of a name mapping. If None is provided as the input name_mapping, then - the original qubit names are mapped to themselves. If "default" + the original qubit names are mapped to themselves. If "default" is used as the name_mapping, then the defaultWireNameMapping() - method is used to define the name mapping. Otherwise, name_mapping - itself is assumed to be the dictionary to use. + method is used to define the name mapping. """ if name_mapping is None: @@ -378,16 +389,17 @@ def makeWireMapping( name_mapping[name] = name elif name_mapping == "default": - name_mapping = self.defaultWireNameMapping() + name_mapping = self.defaultWireNameMapping() # type: ignore - wire_mapping = [None for x in range(self.qubit_names.getArraySizeNeeded())] + wire_mapping: list[int | tuple[str, int]] = list() for k in self.qubit_names.getIDs(): - wire_mapping[k] = name_mapping[self.qubit_names.getName(k)] + name_mapping = cast(dict, name_mapping) + wire_mapping.append(name_mapping[self.qubit_names.getName(k)]) return wire_mapping - def defaultWireNameMapping(self) -> dict[list[Hashable], int]: + def defaultWireNameMapping(self) -> dict[Hashable, int]: """Return a dictionary that maps wire names in :func:`self.getWireNames()` to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric IDs that are adjacent to the numeric @@ -400,14 +412,14 @@ def defaultWireNameMapping(self) -> dict[list[Hashable], int]: name_pairs.sort(key=lambda x: x[1]) - name_map = dict() + name_map: dict[Hashable, int] = dict() for k, pair in enumerate(name_pairs): name_map[pair[0]] = k return name_map def sortOrder(self, name: Hashable) -> int | float: - """Order numeric IDs of wires to enable defaultWireNameMapping.""" + """Order numeric IDs of wires to enable :func:`defaultWireNameMapping`.""" if isinstance(name, tuple): if name[0] == "cut": @@ -419,15 +431,20 @@ def sortOrder(self, name: Hashable) -> int | float: return self.qubit_names.getID(name) def replaceWireIDs( - self, gate_list: list[CircuitElement], wire_map: NDArray[np.int_] + self, + gate_list: Sequence[CircuitElement | list[str | int]], + wire_map: list[int], ) -> None: """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map. """ for inst in gate_list: - if type(inst) == CircuitElement: + if isinstance(inst, CircuitElement): for k in range(len(inst.qubits)): - inst.qubits[k] = wire_map[inst.qubits[k]] + inst.qubits[k] = wire_map[inst.qubits[k]] #type: ignore + elif isinstance(inst, list): + for k in range(1, len(inst)): + inst[k] = wire_map[inst[k]] #type: ignore class NameToIDMap: @@ -436,19 +453,15 @@ class NameToIDMap: and natural numbers (e.g., qubit IDs). """ - next_ID: int - item_dict: dict[Hashable] - ID_dict: dict[Hashable] - def __init__(self, init_names: list[Hashable]): """Allow the name dictionary to be initialized with the names in init_names in the order the names appear in order to force a preferred ordering in the assigment of item IDs to those names. """ - self.next_ID = 0 - self.item_dict = dict() - self.ID_dict = dict() + self.next_ID: int = 0 + self.item_dict: dict[Hashable, int] = dict() + self.ID_dict: dict[int, Hashable] = dict() for name in init_names: self.getID(name) @@ -511,7 +524,7 @@ def getItems(self) -> Iterable[Hashable]: return self.item_dict.keys() - def getIDs(self) -> Iterable[Hashable]: + def getIDs(self) -> Iterable[int]: """Return the keys of the dictionary of ID's assigned to hashable items loaded thus far.""" return self.ID_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index f381e3b37..7e5f28632 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -15,9 +15,11 @@ from qiskit import QuantumCircuit from qiskit.circuit import CircuitInstruction +from typing import cast from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints +from .disjoint_subcircuits_state import DisjointSubcircuitsState from .circuit_interface import SimpleGateList from .lo_cuts_optimizer import LOCutsOptimizer from .cco_utils import qc_to_cco_circuit @@ -71,6 +73,8 @@ def find_cuts( wire_cut_actions = [] gate_ids = [] + opt_out = cast(DisjointSubcircuitsState, opt_out) + opt_out.actions = cast(list, opt_out.actions) for action in opt_out.actions: if action[0].getName() == "CutTwoQubitGate": gate_ids.append(action[1][0]) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 717b386fc..e776dcff7 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -15,6 +15,7 @@ import numpy as np from dataclasses import dataclass +from typing import cast from numpy.typing import NDArray from .search_space_generator import ActionNames from .cco_utils import selectSearchEngine, greedyBestFirstSearch @@ -24,10 +25,8 @@ SearchFunctions, SearchSpaceGenerator, ) -from .disjoint_subcircuits_state import ( - DisjointSubcircuitsState, -) -from .circuit_interface import SimpleGateList, CircuitElement +from .disjoint_subcircuits_state import DisjointSubcircuitsState +from .circuit_interface import SimpleGateList, CircuitElement, Sequence from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints @@ -39,15 +38,17 @@ class CutOptimizationFuncArgs: search-space generating functions. """ - entangling_gates: list[int | CircuitElement | None] | None = None + entangling_gates: Sequence[ + Sequence[int | CircuitElement | None | list] + ] | None = None search_actions: ActionNames | None = None max_gamma: float | int | None = None - qpu_width: float | int | None = None + qpu_width: int | None = None def CutOptimizationCostFunc( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs -) -> tuple[int | float, int | float]: +) -> tuple[int | float, int]: """Return the cost function. The particular cost function chosen here aims to minimize the gamma while also (secondarily) giving preference to circuit partitionings that balance the sizes of the resulting partitions, @@ -82,23 +83,32 @@ def CutOptimizationNextStateFunc( # Get the entangling gate spec that is to be processed next based # on the search level of the input state + assert func_args.entangling_gates is not None + assert func_args.search_actions is not None + gate_spec = func_args.entangling_gates[state.getSearchLevel()] # Determine which search actions can be performed, taking into # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled # in the search - if len(gate_spec[1].qubits) == 2: + gate = gate_spec[1] + gate = cast(CircuitElement, gate) + if len(gate.qubits) == 2: action_list = func_args.search_actions.getGroup("TwoQubitGates") else: raise ValueError( - "At present, only the cutting of two qubit gates is supported." + "In the current version, only the cutting of two qubit gates is supported." ) - action_list = getActionSubset(action_list, gate_spec[2]) + gate_actions = gate_spec[2] + gate_actions = cast(list, gate_actions) + action_list = getActionSubset(action_list, gate_actions) # Apply the search actions to generate a list of next states next_state_list = [] + assert action_list is not None for action in action_list: + func_args.qpu_width = cast(int, func_args.qpu_width) next_state_list.extend(action.nextState(state, gate_spec, func_args.qpu_width)) return next_state_list @@ -109,6 +119,7 @@ def CutOptimizationGoalStateFunc( """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy the device constraints and the optimization settings). """ + func_args.entangling_gates = cast(list[list], func_args.entangling_gates) return state.getSearchLevel() >= len(func_args.entangling_gates) @@ -304,9 +315,15 @@ def maxWireCutsCircuit(circuit_interface: SimpleGateList) -> int: """Calculate an upper bound on the maximum number of wire cuts that can be made given the total number of inputs to multiqubit gates in the circuit. + + NOTE: There is no advantage gained by cutting wires that + only have single qubit gates acting on them, so without + loss of generality we can assume that wire cutting is + performed only on the inputs to multiqubit gates. """ - return sum([len(x[1].qubits) for x in circuit_interface.getMultiQubitGates()]) + multiqubit_wires = [len(x[1].qubits) for x in circuit_interface.getMultiQubitGates()] # type: ignore + return sum(multiqubit_wires) def maxWireCutsGamma(max_gamma: float | int) -> int: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 9b588948c..fe6926d00 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -15,7 +15,7 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Hashable +from typing import Hashable, cast, Sequence from .search_space_generator import ActionNames from .circuit_interface import SimpleGateList from .disjoint_subcircuits_state import DisjointSubcircuitsState @@ -49,8 +49,8 @@ def nextStatePrimitive(self, state, gate_spec, max_width): def nextState( self, state: DisjointSubcircuitsState, - gate_spec: CircuitElement, - max_width: int | float, + gate_spec: Sequence[int | CircuitElement | None | list], + max_width: int, ) -> list[DisjointSubcircuitsState]: """Return a list of search states that result from applying the action to gate_spec in the specified DisjointSubcircuitsState @@ -84,7 +84,7 @@ def getGroupNames(self) -> list[None | str]: def nextStatePrimitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None], + gate_spec: list[int | CircuitElement | None | list], max_width: int | float, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying @@ -92,6 +92,7 @@ def nextStatePrimitive( specification: gate_spec. """ gate = gate_spec[1] # extract the gate from gate specification. + gate = cast(CircuitElement, gate) r1 = state.findQubitRoot( gate.qubits[0] @@ -103,6 +104,7 @@ def nextStatePrimitive( # acted on by the given 2-qubit gate. # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate + assert state.width is not None if r1 != r2 and state.width[r1] + state.width[r2] > max_width: return list() @@ -140,15 +142,18 @@ def getGroupNames(self) -> list[str]: def nextStatePrimitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None], - max_width: int | float, + gate_spec: list[int | CircuitElement | None | list], + max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutTwoQubitGate to state given the gate_spec. """ + gate = gate_spec[1] + gate = cast(CircuitElement, gate) + # Cutting of multi-qubit gates is not supported in this version. - if len(gate_spec[1].qubits) != 2: # pragma: no cover + if len(gate.qubits) != 2: # pragma: no cover raise ValueError( "At present, only the cutting of two qubit gates is supported." ) @@ -158,7 +163,6 @@ def nextStatePrimitive( if gamma_LB is None: return list() - gate = gate_spec[1] q1 = gate.qubits[0] q2 = gate.qubits[1] w1 = state.getWire(q1) @@ -173,11 +177,16 @@ def nextStatePrimitive( new_state.assertDoNotMergeRoots(r1, r2) + gamma_LB = cast(int, gamma_LB) + new_state.gamma_LB = cast(int, new_state.gamma_LB) new_state.gamma_LB *= gamma_LB for k in range(num_bell_pairs): + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) + gamma_UB = cast(int, gamma_UB) + new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= gamma_UB new_state.addAction(self, gate_spec, (1, w1), (2, w2)) @@ -186,8 +195,8 @@ def nextStatePrimitive( @staticmethod def getCostParams( - gate_spec: CircuitElement, - ) -> tuple[int | float, int, int | float]: + gate_spec: list[int | CircuitElement | None | list], + ) -> tuple[int | float | None, int, int | float | None]: """ Get the cost parameters. @@ -197,20 +206,23 @@ def getCostParams( Since CKT does not support LOCC at the moment, these tuples will be of the form (gamma, 0, gamma). """ - gamma = gate_spec[1].gamma + gate = gate_spec[1] + gate = cast(CircuitElement, gate) + gamma = gate.gamma return (gamma, 0, gamma) def exportCuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None], + gate_spec: list[int | CircuitElement | None | list], args, ) -> None: """Insert an LO gate cut into the input circuit for the specified gate and cut arguments. """ + assert isinstance(gate_spec[0], int) circuit_interface.insertGateCut(gate_spec[0], "LO") @@ -236,15 +248,16 @@ def getGroupNames(self) -> list[str]: def nextStatePrimitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int, CircuitElement, None], + gate_spec: list[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutLeftWire to state given the gate_spec. """ - + gate = gate_spec[1] + gate = cast(CircuitElement, gate) # Cutting of multi-qubit gates is not supported in this version. - if len(gate_spec[1].qubits) != 2: # pragma: no cover + if len(gate.qubits) != 2: # pragma: no cover raise ValueError( "At present, only the cutting of two qubit gates is supported." ) @@ -253,7 +266,6 @@ def nextStatePrimitive( if not state.canAddWires(1): return list() - gate = gate_spec[1] q1 = gate.qubits[0] q2 = gate.qubits[1] w1 = state.getWire(q1) @@ -272,7 +284,9 @@ def nextStatePrimitive( new_state.mergeRoots(rnew, r2) new_state.assertDoNotMergeRoots(r1, r2) # Because r2 < rnew + new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) + new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= 4 new_state.addAction(self, gate_spec, (1, w1, rnew)) @@ -283,7 +297,7 @@ def exportCuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: CircuitElement, + gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: """Insert an LO wire cut into the input circuit for the specified @@ -300,13 +314,14 @@ def exportCuts( def insertAllLOWireCuts( circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: CircuitElement, + gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments. """ gate_ID = gate_spec[0] + gate_ID = cast(int, gate_ID) for input_ID, wire_ID, new_wire_ID in cut_args: circuit_interface.insertWireCut( gate_ID, input_ID, wire_map[wire_ID], wire_map[new_wire_ID], "LO" @@ -323,7 +338,7 @@ def getName(self) -> str: return "CutRightWire" - def getGroupNames(self) -> list[str, str]: + def getGroupNames(self) -> list[str]: """Return the group name of ActionCutRightWire.""" return ["WireCut", "TwoQubitGates"] @@ -331,15 +346,17 @@ def getGroupNames(self) -> list[str, str]: def nextStatePrimitive( self, state: DisjointSubcircuitsState, - gate_spec: CircuitElement, - max_width: int | float, + gate_spec: list[int | CircuitElement | None | list], + max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutRightWire to state given the gate_spec. """ + gate = gate_spec[1] + gate = cast(CircuitElement, gate) # Cutting of multi-qubit gates is not supported in this version. - if len(gate_spec[1].qubits) != 2: # pragma: no cover + if len(gate.qubits) != 2: # pragma: no cover raise ValueError( "At present, only the cutting of two qubit gates is supported." ) @@ -348,7 +365,6 @@ def nextStatePrimitive( if not state.canAddWires(1): return list() - gate = gate_spec[1] q1 = gate.qubits[0] q2 = gate.qubits[1] w2 = state.getWire(q2) @@ -367,6 +383,8 @@ def nextStatePrimitive( new_state.mergeRoots(r1, rnew) new_state.assertDoNotMergeRoots(r1, r2) # Because r1 < rnew + new_state.gamma_UB = cast(float, new_state.gamma_UB) + new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB *= 4 @@ -378,7 +396,7 @@ def exportCuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: CircuitElement, + gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: # pragma: no cover """Insert an LO wire cut into the input circuit for the specified @@ -410,15 +428,16 @@ def getGroupNames(self) -> list[str]: def nextStatePrimitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None], - max_width: int | float, + gate_spec: list[int | CircuitElement | None | list], + max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying ActionCutBothWires to state given the gate_spec. """ - + gate = gate_spec[1] + gate = cast(CircuitElement, gate) # Cutting of multi-qubit gates is not supported in this version. - if len(gate_spec[1].qubits) != 2: # pragma: no cover + if len(gate.qubits) != 2: # pragma: no cover raise ValueError( "At present, only the cutting of two qubit gates is supported." ) @@ -431,7 +450,6 @@ def nextStatePrimitive( if max_width < 2: return list() - gate = gate_spec[1] q1 = gate.qubits[0] q2 = gate.qubits[1] w1 = state.getWire(q1) @@ -447,6 +465,8 @@ def nextStatePrimitive( new_state.assertDoNotMergeRoots(r1, rnew_1) # Because r1 < rnew_1 new_state.assertDoNotMergeRoots(r2, rnew_2) # Because r2 < rnew_2 + new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) + new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.bell_pairs.append((r1, rnew_1)) new_state.bell_pairs.append((r2, rnew_2)) new_state.gamma_UB *= 16 @@ -459,7 +479,7 @@ def exportCuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: CircuitElement, + gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: # pragma: no cover """Insert LO wire cuts into the input circuit for the specified diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index dbb44c54b..13707b13b 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -17,9 +17,12 @@ import numpy as np from numpy.typing import NDArray from collections import Counter -from typing import Hashable, Iterable +from typing import Hashable, Iterable, TYPE_CHECKING, no_type_check, cast from .circuit_interface import CircuitElement, SimpleGateList +if TYPE_CHECKING: # pragma: no cover + from .cutting_actions import DisjointSearchAction + class DisjointSubcircuitsState: @@ -113,12 +116,12 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No self.uptree: NDArray[np.int_] | None = None self.width: NDArray[np.int_] | None = None - self.bell_pairs: list[tuple] | None = None + self.bell_pairs: list[tuple[int, int]] | None = None self.gamma_LB: float | None = None self.gamma_UB: float | None = None - self.no_merge: list | None = None - self.actions: list | None = None + self.no_merge: list[tuple] | None = None + self.actions: list[list] | None = None self.cut_actions_list: list | None = None self.level: int | None = None @@ -140,6 +143,7 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No self.cut_actions_list = list() self.level = 0 + @no_type_check def __copy__(self) -> DisjointSubcircuitsState: new_state = DisjointSubcircuitsState() @@ -170,10 +174,12 @@ def cut_actions_sublist(self) -> list[list | dict]: of :class:`DisjointSubcircuitState` along with the locations of these actions which are specified in terms of the associated gates and wires.""" + self.actions = cast(list[list], self.actions) cut_actions = print_actions_list(self.actions) # Output formatting for LO gate and wire cuts. # TODO: Change to NamedTuples. + self.cut_actions_list = cast(list, self.cut_actions_list) for i in range(len(cut_actions)): if (cut_actions[i][0] == "CutLeftWire") or ( cut_actions[i][0] == "CutRightWire" @@ -195,14 +201,16 @@ def cut_actions_sublist(self) -> list[list | dict]: } ) if not self.cut_actions_list: + self.cut_actions_list = cast(list[list], self.cut_actions_list) self.cut_actions_list = cut_actions - return self.cut_actions_list + return self.cut_actions_list def print(self, simple: bool = False) -> None: # pragma: no cover """Print the various properties of a DisjointSubcircuitState.""" cut_actions_list = self.cut_actions_sublist() + self.actions = cast(list[list], self.actions) if simple: print(cut_actions_list) else: @@ -220,29 +228,27 @@ def print(self, simple: bool = False) -> None: # pragma: no cover def getNumQubits(self) -> int: """Return the number of qubits in the circuit.""" - - if self.wiremap is not None: - return self.wiremap.shape[0] + self.wiremap = cast(NDArray[np.int_], self.wiremap) + return self.wiremap.shape[0] def getMaxWidth(self) -> int: """Return the maximum width across subcircuits.""" - - if self.width is not None: - return np.amax(self.width) + self.width = cast(NDArray[np.int_], self.width) + return int(np.amax(self.width)) def getSubCircuitIndices(self) -> list[int]: """Return a list of root indices for the subcircuits in the current cut circuit. """ - - if self.uptree is not None: - return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] + self.uptree = cast(NDArray[np.int_], self.uptree) + self.num_wires = cast(int, self.num_wires) + return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] def getWireRootMapping(self) -> list[int]: """Return a list of root wires for each wire in the current cut circuit. """ - + self.num_wires = cast(int, self.num_wires) return [self.findWireRoot(i) for i in range(self.num_wires)] def findRootBellPair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: @@ -254,20 +260,23 @@ def findRootBellPair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: r1 = self.findWireRoot(bell_pair[1]) return (r0, r1) if (r0 < r1) else (r1, r0) - def lowerBoundGamma(self) -> int | float: + def lowerBoundGamma(self) -> float: """Calculate a lower bound for gamma using the current counts for the different types of circuit cuts. """ + self.bell_pairs = cast(list, self.bell_pairs) root_bell_pairs = map(lambda x: self.findRootBellPair(x), self.bell_pairs) + self.gamma_LB = cast(float, self.gamma_LB) return self.gamma_LB * calcRootBellPairsGamma(root_bell_pairs) - def upperBoundGamma(self) -> int | float: + def upperBoundGamma(self) -> float: """Calculate an upper bound for gamma using the current counts for the different types of circuit cuts. """ + self.gamma_UB = cast(float, self.gamma_UB) return self.gamma_UB def canAddWires(self, num_wires: int) -> bool: @@ -275,32 +284,39 @@ def canAddWires(self, num_wires: int) -> bool: without exceeding the maximum allowed number of wire cuts. """ + self.num_wires = cast(int, self.num_wires) + self.uptree = cast(NDArray[np.int_], self.uptree) return self.num_wires + num_wires <= self.uptree.shape[0] def canExpandSubcircuit(self, root: int, num_wires: int, max_width: int) -> bool: """Return True if num_wires can be added to subcircuit root without exceeding the maximum allowed number of qubits. """ - + self.width = cast(NDArray[np.int_], self.width) return self.width[root] + num_wires <= max_width def newWire(self, qubit: Hashable) -> int: """Cut the wire associated with qubit and return the ID of the new wire now associated with qubit. """ - + self.num_wires = cast(int, self.num_wires) + self.uptree = cast(NDArray[np.int_], self.uptree) assert self.num_wires < self.uptree.shape[0], ( "Max new wires exceeded " + f"{self.num_wires}, {self.uptree.shape[0]}" ) + self.wiremap = cast(NDArray[np.int_], self.wiremap) self.wiremap[qubit] = self.num_wires self.num_wires += 1 + qubit = cast(int, qubit) return self.wiremap[qubit] def getWire(self, qubit: Hashable) -> int: """Return the ID of the wire currently associated with qubit.""" + self.wiremap = cast(NDArray[np.int_], self.wiremap) + qubit = cast(int, qubit) return self.wiremap[qubit] def findWireRoot(self, wire: int) -> int: @@ -310,6 +326,7 @@ def findWireRoot(self, wire: int) -> int: # Find the root wire in the subcircuit root = wire + self.uptree = cast(NDArray[np.int_], self.uptree) while root != self.uptree[root]: root = self.uptree[root] @@ -325,20 +342,22 @@ def findQubitRoot(self, qubit: Hashable) -> int: """Return the ID of the root wire in the subcircuit currently associated with qubit and collapse the path to the root. """ - + self.wiremap = cast(NDArray[np.int_], self.wiremap) + qubit = cast(int, qubit) return self.findWireRoot(self.wiremap[qubit]) def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: """Return True if the subcircuits represented by root wire IDs root_1 and root_2 should not be merged. """ - + self.uptree = cast(NDArray[np.int_], self.uptree) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( "Arguments must be roots: " + f"{root_1} != {self.uptree[root_1]} " + f"or {root_2} != {self.uptree[root_2]}" ) + self.no_merge = cast(list[tuple], self.no_merge) for clause in self.no_merge: r1 = self.findWireRoot(clause[0]) r2 = self.findWireRoot(clause[1]) @@ -353,6 +372,7 @@ def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: def verifyMergeConstraints(self) -> bool: """Return True if all merge constraints are satisfied.""" + self.no_merge = cast(list[tuple], self.no_merge) for clause in self.no_merge: r1 = self.findWireRoot(clause[0]) r2 = self.findWireRoot(clause[1]) @@ -379,6 +399,8 @@ def mergeRoots(self, root_1: int, root_2: int) -> None: associated with the newly merged subcircuit. """ + self.uptree = cast(NDArray[np.int_], self.uptree) + self.width = cast(NDArray[np.int_], self.width) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( "Arguments must be roots: " + f"{root_1} != {self.uptree[root_1]} " @@ -392,17 +414,23 @@ def mergeRoots(self, root_1: int, root_2: int) -> None: self.uptree[other_root] = merged_root self.width[merged_root] += self.width[other_root] - def addAction(self, action_obj, gate_spec: CircuitElement, *args) -> None: + def addAction( + self, + action_obj: DisjointSearchAction, + gate_spec: list[int | CircuitElement | None | list], + *args, + ) -> None: """Append the specified action to the list of search-space actions that have been performed. """ if action_obj.getName() is not None: + self.actions = cast(list[list], self.actions) self.actions.append([action_obj, gate_spec, args]) def getSearchLevel(self) -> int: """Return the search level.""" - + self.level = cast(int, self.level) return self.level def setNextLevel(self, state: DisjointSubcircuitsState) -> None: @@ -410,17 +438,21 @@ def setNextLevel(self, state: DisjointSubcircuitsState) -> None: level of the input state. """ + self.level = cast(int, self.level) + state.level = cast(int, state.level) self.level = state.level + 1 - def exportCuts(self, circuit_interface: SimpleGateList) -> SimpleGateList: + def exportCuts(self, circuit_interface: SimpleGateList): """Export LO cuts into the input circuit_interface for each of the cutting decisions made. """ # This wire map assumes no reuse of measured qubits that # result from wire cuts + assert self.num_wires is not None wire_map = np.arange(self.num_wires) + assert self.actions is not None for action, gate_spec, cut_args in self.actions: action.exportCuts(circuit_interface, wire_map, gate_spec, cut_args) @@ -453,9 +485,9 @@ def calcRootBellPairsGamma(root_bell_pairs: Iterable[Hashable]) -> float: def print_actions_list( - action_list: list[DisjointSubcircuitsState], + action_list: list[list], ) -> list[list[str | list | tuple]]: - """Return a list specifying action objects that represent cutting actions assoicated with an + """Return a list specifying objects that represent cutting actions assoicated with an instance of :class:`DisjointSubcircuitsState`. """ return [[x[0].getName()] + x[1:] for x in action_list] diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 1d6cc1a16..7b9d95cce 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -14,7 +14,7 @@ from __future__ import annotations from dataclasses import dataclass -from typing import Dict +from typing import cast @dataclass @@ -100,12 +100,12 @@ def getRandSeed(self) -> int | None: def getEngineSelection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" - assert self.engine_selections is not None + self.engine_selections = cast(dict[str, str], self.engine_selections) return self.engine_selections[stage_of_optimization] def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: """Set the name of the search engine to employ.""" - assert self.engine_selections is not None + self.engine_selections = cast(dict[str, str], self.engine_selections) self.engine_selections[stage_of_optimization] = engine_name def setGateCutTypes(self) -> None: diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index ccc76f48f..cdc34ed87 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -54,6 +54,7 @@ def copy( action_list = getActionSubset(list(self.action_dict.values()), list_of_groups) new_container = ActionNames() + assert action_list is not None for action in action_list: new_container.defineAction(action) @@ -92,7 +93,7 @@ def getAction(self, action_name: str) -> DisjointSearchAction | None: return self.action_dict[action_name] return None - def getGroup(self, group_name: str) -> list[DisjointSearchAction] | None: + def getGroup(self, group_name: str) -> list | None: """Return the list of action objects associated with the group_name. None is returned if there are no associated action objects. """ @@ -103,8 +104,9 @@ def getGroup(self, group_name: str) -> list[DisjointSearchAction] | None: def getActionSubset( - action_list: list, action_groups: list[DisjointSearchAction | None] | None -) -> list[DisjointSearchAction]: + action_list: list[DisjointSearchAction] | None, + action_groups: list[DisjointSearchAction | None] | None, +) -> list[DisjointSearchAction] | None: """Return the subset of actions in action_list whose group affiliations intersect with action_groups. """ @@ -117,6 +119,7 @@ def getActionSubset( groups = set(action_groups) + assert action_list is not None return [ a for a in action_list if len(groups.intersection(set(a.getGroupNames()))) > 0 ] diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 4d31283eb..3e480df02 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -19,14 +19,6 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/matplotlib.py:274: UserWarning: Style JSON file 'iqp.json' not found in any of these locations: /Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/styles/iqp.json, iqp.json. Will use default style.\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { "image/png": "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", @@ -46,7 +38,7 @@ "\n", "circuit = random_circuit(7, 6, max_operands=2, seed=1242)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", - "circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")" + "circuit.draw(\"mpl\", scale=0.8)" ] }, { @@ -61,14 +53,6 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/matplotlib.py:274: UserWarning: Style JSON file 'iqp.json' not found in any of these locations: /Users/ibrahimshehzad/ckt/lib/python3.9/site-packages/qiskit/visualization/circuit/styles/iqp.json, iqp.json. Will use default style.\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { "image/png": "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", @@ -91,7 +75,7 @@ "device_constraints = {\"qubits_per_QPU\": 4, \"num_QPUs\": 2}\n", "\n", "cut_circuit = find_cuts(circuit, optimization_settings, device_constraints)\n", - "cut_circuit.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" + "cut_circuit.draw(\"mpl\", scale=0.8, fold=-1)" ] }, { @@ -103,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -113,7 +97,7 @@ "
" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -123,7 +107,7 @@ "\n", "qc_w_ancilla = cut_wires(cut_circuit)\n", "observables_expanded = expand_observables(observables, circuit, qc_w_ancilla)\n", - "qc_w_ancilla.draw(\"mpl\", style=\"iqp\", scale=0.8, fold=-1)" + "qc_w_ancilla.draw(\"mpl\", scale=0.8, fold=-1)" ] }, { @@ -135,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -161,7 +145,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -171,7 +155,7 @@ " 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -182,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -192,7 +176,7 @@ "
" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -203,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -213,7 +197,7 @@ "
" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -231,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 49858f970..a23577c82 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -80,21 +80,21 @@ "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "None\n", + "[]\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", "Subcircuits: AABB \n", "\n" ] @@ -207,7 +207,7 @@ "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", - "None\n", + "[]\n", "Subcircuits: AAAAAAA \n", "\n", "\n", @@ -235,14 +235,14 @@ "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}]\n", + "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}]\n", + "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, CircuitElement(name='cx', params=[], qubits=[1, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", "Subcircuits: ABCDDEF \n", "\n" ] diff --git a/test/cutting/cut_finding/__init__.py b/test/cutting/cut_finding/__init__.py index 8b1378917..e69de29bb 100644 --- a/test/cutting/cut_finding/__init__.py +++ b/test/cutting/cut_finding/__init__.py @@ -1 +0,0 @@ - diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 6689548ca..842fd832a 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -119,7 +119,7 @@ def test_WireCutInterface(self): assert circuit_converted.exportCutCircuit(name_mapping=None) == [ trial_circuit[0], trial_circuit[1], - ["move", 1, 4], + ["move", 1, ("cut", 1)], CircuitElement(name="cx", params=[], qubits=[("cut", 1), 2], gamma=3), CircuitElement(name="cx", params=[], qubits=[0, ("cut", 1)], gamma=3), trial_circuit[4], @@ -144,7 +144,7 @@ def test_WireCutInterface(self): assert circuit_converted.exportCutCircuit(name_mapping="default") == [ CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), - ["move", 1, 4], + ["move", 1, 2], CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), CircuitElement(name="cx", params=[], qubits=[0, 2], gamma=3), CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index f5a3db102..b481d8cd7 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -110,7 +110,14 @@ def test_GateCuts( 9, CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), ], - } + }, + { + "Cut action": "CutTwoQubitGate", + "Cut Gate": [ + 20, + CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3.0), + ], + }, ] best_result = optimization_pass.getResults() @@ -204,7 +211,7 @@ def test_MultiqubitCuts( _ = optimization_pass.optimize() assert ( e_info.value.args[0] - == "At present, only the cutting of two qubit gates is supported." + == "In the current version, only the cutting of two qubit gates is supported." ) From dfaff48833d75616bbb1f402a88b95b0ae4034be Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 26 Feb 2024 09:43:00 -0500 Subject: [PATCH 074/128] Remove cast subscripting to make compatible with py38. --- .../cutting/cut_finding/circuit_interface.py | 7 +++---- .../cutting/cut_finding/cutting_actions.py | 14 ++++++++------ .../cut_finding/disjoint_subcircuits_state.py | 4 ++-- .../cutting/cut_finding/optimization_settings.py | 4 ++-- 4 files changed, 15 insertions(+), 14 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index e282a918e..937ed3dcd 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -283,7 +283,7 @@ def insertWireCut( wire_map[src_wire_ID] = dest_wire_ID self.new_circuit = cast( - Sequence[Union[CircuitElement, list[Union[str, int]]]], self.new_circuit + Sequence[Union[CircuitElement, list]], self.new_circuit ) self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) @@ -363,14 +363,13 @@ def exportSubcircuitsAsString( wire_map = self.makeWireMapping(name_mapping) wire_map = cast(list[int], wire_map) - out: list[int] | list[str] = list(range(self.getNumWires())) + out: Sequence[int | str] = list(range(self.getNumWires())) + out = cast(list, out) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): subcircuit = cast(list[int], subcircuit) for wire in subcircuit: - out = cast(list[str], out) out[wire_map[wire]] = alphabet[k] - out = cast(list[str], out) return "".join(out) def makeWireMapping( diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index fe6926d00..7994d50e8 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -94,14 +94,16 @@ def nextStatePrimitive( gate = gate_spec[1] # extract the gate from gate specification. gate = cast(CircuitElement, gate) + # extract the root wire for the first qubit + # acted on by the given 2-qubit gate. r1 = state.findQubitRoot( gate.qubits[0] - ) # extract the root wire for the first qubit + ) + # extract the root wire for the second qubit # acted on by the given 2-qubit gate. r2 = state.findQubitRoot( gate.qubits[1] - ) # extract the root wire for the second qubit - # acted on by the given 2-qubit gate. + ) # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate assert state.width is not None @@ -284,7 +286,7 @@ def nextStatePrimitive( new_state.mergeRoots(rnew, r2) new_state.assertDoNotMergeRoots(r1, r2) # Because r2 < rnew - new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= 4 @@ -384,7 +386,7 @@ def nextStatePrimitive( new_state.assertDoNotMergeRoots(r1, r2) # Because r1 < rnew new_state.gamma_UB = cast(float, new_state.gamma_UB) - new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB *= 4 @@ -465,7 +467,7 @@ def nextStatePrimitive( new_state.assertDoNotMergeRoots(r1, rnew_1) # Because r1 < rnew_1 new_state.assertDoNotMergeRoots(r2, rnew_2) # Because r2 < rnew_2 - new_state.bell_pairs = cast(list[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.bell_pairs.append((r1, rnew_1)) new_state.bell_pairs.append((r2, rnew_2)) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 13707b13b..373983e83 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -357,7 +357,7 @@ def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: + f"or {root_2} != {self.uptree[root_2]}" ) - self.no_merge = cast(list[tuple], self.no_merge) + self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: r1 = self.findWireRoot(clause[0]) r2 = self.findWireRoot(clause[1]) @@ -425,7 +425,7 @@ def addAction( """ if action_obj.getName() is not None: - self.actions = cast(list[list], self.actions) + self.actions = cast(list, self.actions) self.actions.append([action_obj, gate_spec, args]) def getSearchLevel(self) -> int: diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 7b9d95cce..f5345f78e 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -100,12 +100,12 @@ def getRandSeed(self) -> int | None: def getEngineSelection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" - self.engine_selections = cast(dict[str, str], self.engine_selections) + self.engine_selections = cast(dict, self.engine_selections) return self.engine_selections[stage_of_optimization] def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: """Set the name of the search engine to employ.""" - self.engine_selections = cast(dict[str, str], self.engine_selections) + self.engine_selections = cast(dict, self.engine_selections) self.engine_selections[stage_of_optimization] = engine_name def setGateCutTypes(self) -> None: From ea0b2b8b5054af571111ab6718723e7b94ec9171 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 26 Feb 2024 11:51:39 -0500 Subject: [PATCH 075/128] Make type annotations compatible with min version tests. --- .../cutting/cut_finding/circuit_interface.py | 16 ++++++++++------ .../cutting/cut_finding/cut_optimization.py | 2 +- .../cut_finding/disjoint_subcircuits_state.py | 2 +- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 937ed3dcd..175dfe0d3 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -165,7 +165,8 @@ class SimpleGateList(CircuitInterface): """ circuit: list[list[str | None] | list[CircuitElement | None]] - new_circuit: Sequence[CircuitElement | str | list[str | int]] + #new_circuit: Sequence[CircuitElement | str | list[str | int]] + new_circuit: Sequence[CircuitElement | str | Sequence] cut_type: list[str | None] qubit_names: NameToIDMap num_qubits: int @@ -316,7 +317,7 @@ def getWireNames(self) -> list[Hashable]: def exportCutCircuit( self, name_mapping: None | str = "default", - ) -> Sequence[CircuitElement | list[str | int]]: + ) -> Sequence[CircuitElement | Sequence]: #Sequence[CircuitElement | list[str | int]]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -327,8 +328,10 @@ def exportCutCircuit( wire_map = self.makeWireMapping(name_mapping) out = copy.deepcopy(self.new_circuit) - out = cast(Sequence[Union[CircuitElement, list[Union[str, int]]]], out) - wire_map = cast(list[int], wire_map) + #out = cast(Sequence[Union[CircuitElement, Sequence]], out) + #out = cast(Sequence[Union[CircuitElement, list[Union[str, int]]]], out) + wire_map = cast(list, wire_map) + #wire_map = cast(list[int], wire_map) self.replaceWireIDs(out, wire_map) return out @@ -361,7 +364,8 @@ def exportSubcircuitsAsString( """ wire_map = self.makeWireMapping(name_mapping) - wire_map = cast(list[int], wire_map) + #wire_map = cast(list[int], wire_map) + assert type(wire_map) == list[int] out: Sequence[int | str] = list(range(self.getNumWires())) out = cast(list, out) @@ -431,7 +435,7 @@ def sortOrder(self, name: Hashable) -> int | float: def replaceWireIDs( self, - gate_list: Sequence[CircuitElement | list[str | int]], + gate_list: Sequence[CircuitElement | Sequence[str | int]], wire_map: list[int], ) -> None: """Iterate through a list of gates and replace wire IDs with the diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index e776dcff7..ccb2e3209 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -119,7 +119,7 @@ def CutOptimizationGoalStateFunc( """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy the device constraints and the optimization settings). """ - func_args.entangling_gates = cast(list[list], func_args.entangling_gates) + func_args.entangling_gates = cast(list, func_args.entangling_gates) return state.getSearchLevel() >= len(func_args.entangling_gates) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 373983e83..0c9949281 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -372,7 +372,7 @@ def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: def verifyMergeConstraints(self) -> bool: """Return True if all merge constraints are satisfied.""" - self.no_merge = cast(list[tuple], self.no_merge) + self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: r1 = self.findWireRoot(clause[0]) r2 = self.findWireRoot(clause[1]) From 07e28186662c0dc9efed335fd95445b07ba07376 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 26 Feb 2024 14:27:43 -0500 Subject: [PATCH 076/128] Fix more py38 type compatibility issues. --- .../cutting/cut_finding/circuit_interface.py | 26 +++++++------------ .../cutting/cut_finding/cutting_actions.py | 8 ++---- .../cut_finding/disjoint_subcircuits_state.py | 2 +- 3 files changed, 13 insertions(+), 23 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 175dfe0d3..fce4f8916 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -165,7 +165,7 @@ class SimpleGateList(CircuitInterface): """ circuit: list[list[str | None] | list[CircuitElement | None]] - #new_circuit: Sequence[CircuitElement | str | list[str | int]] + # new_circuit: Sequence[CircuitElement | str | list[str | int]] new_circuit: Sequence[CircuitElement | str | Sequence] cut_type: list[str | None] qubit_names: NameToIDMap @@ -267,7 +267,8 @@ def insertWireCut( gate_pos = self.new_gate_ID_map[gate_ID] new_gate_spec = self.new_circuit[gate_pos] - # Gate inputs are numbered starting from 1, so we must decrement the index to match qubit numbering. + # Gate inputs are numbered starting from 1, so we must + # decrement the index to match qubit numbering. assert src_wire_ID == new_gate_spec.qubits[input_ID - 1], ( f"Input wire ID {src_wire_ID} does not match " + f"new_circuit wire ID {new_gate_spec.qubits[input_ID-1]}" @@ -283,9 +284,7 @@ def insertWireCut( wire_map = list(range(self.qubit_names.getArraySizeNeeded())) wire_map[src_wire_ID] = dest_wire_ID - self.new_circuit = cast( - Sequence[Union[CircuitElement, list]], self.new_circuit - ) + self.new_circuit = cast(Sequence[Union[CircuitElement, list]], self.new_circuit) self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) # Insert a move operator @@ -317,7 +316,7 @@ def getWireNames(self) -> list[Hashable]: def exportCutCircuit( self, name_mapping: None | str = "default", - ) -> Sequence[CircuitElement | Sequence]: #Sequence[CircuitElement | list[str | int]]: + ) -> Sequence[CircuitElement | Sequence]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as @@ -328,10 +327,7 @@ def exportCutCircuit( wire_map = self.makeWireMapping(name_mapping) out = copy.deepcopy(self.new_circuit) - #out = cast(Sequence[Union[CircuitElement, Sequence]], out) - #out = cast(Sequence[Union[CircuitElement, list[Union[str, int]]]], out) wire_map = cast(list, wire_map) - #wire_map = cast(list[int], wire_map) self.replaceWireIDs(out, wire_map) return out @@ -364,16 +360,14 @@ def exportSubcircuitsAsString( """ wire_map = self.makeWireMapping(name_mapping) - #wire_map = cast(list[int], wire_map) - assert type(wire_map) == list[int] out: Sequence[int | str] = list(range(self.getNumWires())) out = cast(list, out) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): - subcircuit = cast(list[int], subcircuit) + subcircuit = cast(list, subcircuit) for wire in subcircuit: - out[wire_map[wire]] = alphabet[k] + out[wire_map[wire]] = alphabet[k] # type: ignore return "".join(out) def makeWireMapping( @@ -435,7 +429,7 @@ def sortOrder(self, name: Hashable) -> int | float: def replaceWireIDs( self, - gate_list: Sequence[CircuitElement | Sequence[str | int]], + gate_list: Sequence[CircuitElement | Sequence[str | int]], wire_map: list[int], ) -> None: """Iterate through a list of gates and replace wire IDs with the @@ -444,10 +438,10 @@ def replaceWireIDs( for inst in gate_list: if isinstance(inst, CircuitElement): for k in range(len(inst.qubits)): - inst.qubits[k] = wire_map[inst.qubits[k]] #type: ignore + inst.qubits[k] = wire_map[inst.qubits[k]] # type: ignore elif isinstance(inst, list): for k in range(1, len(inst)): - inst[k] = wire_map[inst[k]] #type: ignore + inst[k] = wire_map[inst[k]] # type: ignore class NameToIDMap: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 7994d50e8..4ca54044c 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -96,14 +96,10 @@ def nextStatePrimitive( # extract the root wire for the first qubit # acted on by the given 2-qubit gate. - r1 = state.findQubitRoot( - gate.qubits[0] - ) + r1 = state.findQubitRoot(gate.qubits[0]) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot( - gate.qubits[1] - ) + r2 = state.findQubitRoot(gate.qubits[1]) # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate assert state.width is not None diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 0c9949281..4288266d6 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -174,7 +174,7 @@ def cut_actions_sublist(self) -> list[list | dict]: of :class:`DisjointSubcircuitState` along with the locations of these actions which are specified in terms of the associated gates and wires.""" - self.actions = cast(list[list], self.actions) + self.actions = cast(list, self.actions) cut_actions = print_actions_list(self.actions) # Output formatting for LO gate and wire cuts. From e1129af8f2e99f630916c67669a9186a5ab0c92e Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 26 Feb 2024 16:04:43 -0500 Subject: [PATCH 077/128] Fix type hints. --- circuit_knitting/cutting/cut_finding/circuit_interface.py | 3 +-- .../cutting/cut_finding/disjoint_subcircuits_state.py | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index fce4f8916..06fc1db6a 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -17,7 +17,7 @@ import string from numpy.typing import NDArray from abc import ABC, abstractmethod -from typing import NamedTuple, Hashable, Iterable, cast, Sequence, Union +from typing import NamedTuple, Hashable, Iterable, cast, Sequence class CircuitElement(NamedTuple): @@ -284,7 +284,6 @@ def insertWireCut( wire_map = list(range(self.qubit_names.getArraySizeNeeded())) wire_map[src_wire_ID] = dest_wire_ID - self.new_circuit = cast(Sequence[Union[CircuitElement, list]], self.new_circuit) self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) # Insert a move operator diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 4288266d6..0f0299df5 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -201,7 +201,6 @@ def cut_actions_sublist(self) -> list[list | dict]: } ) if not self.cut_actions_list: - self.cut_actions_list = cast(list[list], self.cut_actions_list) self.cut_actions_list = cut_actions return self.cut_actions_list @@ -210,7 +209,7 @@ def print(self, simple: bool = False) -> None: # pragma: no cover """Print the various properties of a DisjointSubcircuitState.""" cut_actions_list = self.cut_actions_sublist() - self.actions = cast(list[list], self.actions) + self.actions = cast(list, self.actions) if simple: print(cut_actions_list) else: From 5de66b8faa05386ff6bc4ee4a5d37a1d1bc294a0 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 29 Feb 2024 22:24:07 -0500 Subject: [PATCH 078/128] Get rid of camel casing in function names and fix linting errors in doc strings. --- .../cutting/cut_finding/__init__.py | 14 +- .../cutting/cut_finding/best_first_search.py | 156 ++++----- .../cutting/cut_finding/cco_utils.py | 42 ++- .../cutting/cut_finding/circuit_interface.py | 306 ++++++++---------- .../cutting/cut_finding/cut_finding.py | 6 +- .../cutting/cut_finding/cut_optimization.py | 184 +++++------ .../cutting/cut_finding/cutting_actions.py | 289 +++++++---------- .../cut_finding/disjoint_subcircuits_state.py | 193 ++++------- .../cutting/cut_finding/lo_cuts_optimizer.py | 57 ++-- .../cut_finding/optimization_settings.py | 39 +-- .../cut_finding/quantum_device_constraints.py | 10 +- .../cut_finding/search_space_generator.py | 59 ++-- .../tutorials/LO_circuit_cut_finder.ipynb | 16 +- .../cut_finding/test_best_first_search.py | 30 +- test/cutting/cut_finding/test_cco_utils.py | 10 +- .../cut_finding/test_circuit_interfaces.py | 46 +-- .../cut_finding/test_cut_finder_roundtrip.py | 44 +-- .../cut_finding/test_cutting_actions.py | 66 ++-- .../test_disjoint_subcircuits_state.py | 134 ++++---- .../cut_finding/test_optimization_settings.py | 16 +- .../test_quantum_device_constraints.py | 8 +- 21 files changed, 759 insertions(+), 966 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index b9765124b..d78feabbe 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -1 +1,13 @@ -from .cut_finding import find_cuts \ No newline at end of file +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Main automated cut finding functionality.""" +from .cut_finding import find_cuts + +__all__ = ["find_cuts"] diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index b08dbb14d..0fa11a3e8 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -29,7 +29,6 @@ class BestFirstPriorityQueue: - """Class that implements priority queues for best-first search. The tuples that are pushed onto the priority queues have the form: @@ -68,13 +67,7 @@ class BestFirstPriorityQueue: """ def __init__(self, rand_seed: int | None): - """A BestFirstPriorityQueue object must be initialized with a - specification of a random seed (int) for the pseudo-random number - generator. If None is used as the random seed, then a seed is - obtained using an operating-system call to achieve a randomized - initialization. - """ - + """Assign member variables.""" self.rand_gen: Generator = np.random.default_rng(rand_seed) self.unique: count[int] = count() self.pqueue: list[tuple] = list() @@ -85,10 +78,10 @@ def put( depth: int, cost: int | float | tuple[int | float, int | float], ) -> None: - """Push state onto the priority queue. The search depth and cost - of the state must also be provided as input. - """ + """Push state onto the priority queue. + The search depth and cost of the state must also be provided as input. + """ heapq.heappush( self.pqueue, (cost, (-depth), self.rand_gen.random(), next(self.unique), state), @@ -97,11 +90,10 @@ def put( def get( self, ) -> tuple: - """Pop and return the lowest cost state currently on the - queue, along with the search depth of that state and its cost. + """Return the lowest cost state currently on the queue, along with the search depth of that state and its cost. + None, None, None is returned if the priority queue is empty. """ - if self.qsize() == 0: # pragma: no cover return None, None, None @@ -111,23 +103,21 @@ def get( def qsize(self) -> int: """Return the size of the priority queue.""" - return len(self.pqueue) def clear(self) -> None: """Clear all entries in the priority queue.""" - self.pqueue.clear() class BestFirstSearch: + """Implement Dijkstra's best-first search algorithm. - """Class that implements best-first search. The search proceeds by - choosing the deepest, lowest-cost state in the search frontier and - generating next states. Successive calls to the optimizationPass() + The search proceeds by choosing the deepest, lowest-cost state in the search + frontier and generating next states. Successive calls to the :func:`optimization_pass` method will resume the search at the next deepest, lowest-cost state in the search frontier. The costs of goal states that are returned - are used to constrain subsequent searches. None is returned if no + are used to constrain subsequent searches. None is returned if no (additional) feasible solutions can be found, or when no (additional) solutions can be found without exceeding the lowest upper-bound cost across the goal states previously returned. @@ -138,26 +128,26 @@ class BestFirstSearch: generators in the bounded best-first priority-queue objects. cost_func (lambda state, *args) is a function that computes cost values - from search states. Input arguments to the optimizationPass() method are + from search states. Input arguments to the :func:`optimization_pass` method are also passed to the cost_func. The cost returned can be numeric or tuples of numerics. In the latter case, lexicographical comparisons are performed per Python semantics. next_state_func (lambda state, *args) is a function that returns a list of next states generated from the input state. Input arguments to the - optimizationPass() method are also passed to the next_state_func. + :func:`optimization_pass` method are also passed to the next_state_func. goal_state_func (lambda state, *args) is a function that returns True if the input state is a solution state of the search. Input arguments to the - optimizationPass() method are also passed to the goal_state_func. + :func:`optimization_pass` method are also passed to the goal_state_func. upperbound_cost_func (lambda goal_state, *args) can either be None or a function that returns an upper bound to the optimal cost given a goal_state as input. The upper bound is used to prune next-states from the search in - subsequent calls to the optimizationPass() method. If upperbound_cost_func + subsequent calls to the :func:`optimization_pass` method. If upperbound_cost_func is None, the cost of the goal_state as determined by cost_func is used as an upper bound to the optimal cost. Input arguments to the - optimizationPass() method are also passed to the upperbound_cost_func. + :func:`optimization_pass` method are also passed to the upperbound_cost_func. mincost_bound_func (lambda *args) can either be None or a function that returns a cost bound that is compared to the minimum cost across all @@ -181,7 +171,7 @@ class BestFirstSearch: cost across all vertices in the search frontier. The search is forced to terminate when the minimum cost exceeds this cost bound. - minimum_reached (Boolean) is a flag that indicates whether or not the + min_reached (Boolean) is a flag that indicates whether or not the first minimum-cost goal state has been reached. num_states_visited (int) is the number of states that have been dequeued @@ -205,36 +195,28 @@ def __init__( search_functions: SearchFunctions, stop_at_first_min: bool = False, ): - """A BestFirstSearch object must be initialized with a list of - initial states, a random seed for the numpy pseudo-random number - generators that are used to break ties, together with an object - that holds the various functions that are used by the search - engine to generate and explore the search space. A Boolean flag - can optionally be provided to indicate whether to stop the search + """Initialize an instance of :class:`BestFirstSearch`. + + In addition to specifying the optimization settings + and the functions used to perform the search, an optional Boolean flag + can be provided to indicate whether to stop the search after the first minimum-cost goal state has been reached (True), - or whether subsequent calls to the optimizationPass() method should + or whether subsequent calls to the :func:`optimization_pass` method should return any additional minimum-cost goal states that might exist - (False). The default is not to stop at the first minimum. A limit - on the maximum number of backjumps can also be optionally provided - to terminate the search if the number of backjumps exceeds the - specified limit without finding the (next) optimal goal state. + (False). """ - - self.rand_seed = optimization_settings.getRandSeed() + self.rand_seed = optimization_settings.get_rand_seed() self.cost_func = search_functions.cost_func self.next_state_func = search_functions.next_state_func self.goal_state_func = search_functions.goal_state_func self.upperbound_cost_func = search_functions.upperbound_cost_func self.mincost_bound_func = search_functions.mincost_bound_func - self.stop_at_first_min = stop_at_first_min - self.max_backjumps = optimization_settings.getMaxBackJumps() - + self.max_backjumps = optimization_settings.get_max_backjumps() self.pqueue = BestFirstPriorityQueue(self.rand_seed) - self.upperbound_cost = None self.mincost_bound = None - self.minimum_reached = False + self.min_reached = False self.num_states_visited = 0 self.num_next_states = 0 self.num_enqueues = 0 @@ -248,19 +230,17 @@ def initialize( ) -> None: """Clear the priority queue and push an initial list of states into it.""" self.pqueue.clear() - self.upperbound_cost = None self.mincost_bound = None - self.minimum_reached = False + self.min_reached = False self.num_states_visited = 0 self.num_next_states = 0 self.num_enqueues = 0 self.num_backjumps = 0 - self.penultimate_stats = self.getStats() - + self.penultimate_stats = self.get_stats() self.put(initial_state_list, 0, args) - def optimizationPass( + def optimization_pass( self, *args: CutOptimizationFuncArgs, ) -> ( @@ -270,13 +250,11 @@ def optimizationPass( int | float | tuple[int | float, int | float], ] ): - """Perform best-first search until either a goal state is found and - returned, or cost-bounds are reached or no further goal states can be - found, in which case None is returned. The cost of the returned state - is also returned. Any input arguments to optimizationPass() are passed - along to the search-space functions employed. - """ + """Perform best-first search until either a goal state is reached, or cost-bounds are reached or no further goal states can be found. + If no further goal states can be found, None is returned. The cost of the returned state is also returned. Any input arguments to + :func:`optimization_pass` are passed along to the search-space functions employed. + """ if self.mincost_bound_func is not None: self.mincost_bound = self.mincost_bound_func(*args) # type: ignore @@ -284,14 +262,14 @@ def optimizationPass( while ( self.pqueue.qsize() > 0 - and (not self.stop_at_first_min or not self.minimum_reached) + and (not self.stop_at_first_min or not self.min_reached) and (self.max_backjumps is None or self.num_backjumps < self.max_backjumps) ): state, depth, cost = self.pqueue.get() - self.updateMinimumReached(cost) + self.update_minimum_reached(cost) - if cost is None or self.costBoundsExceeded(cost): + if cost is None or self.cost_bounds_exceeded(cost): return None, None self.num_states_visited += 1 @@ -303,9 +281,9 @@ def optimizationPass( state = cast(DisjointSubcircuitsState, state) self.goal_state_func = cast(Callable, self.goal_state_func) if self.goal_state_func(state, *args): - self.penultimate_stats = self.getStats() - self.updateUpperBoundGoalState(state, *args) - self.updateMinimumReached(cost) + self.penultimate_stats = self.get_stats() + self.update_upperbound_goal_state(state, *args) + self.update_minimum_reached(cost) return state, cost @@ -316,24 +294,24 @@ def optimizationPass( # If all states have been explored, then the minimum has been reached if self.pqueue.qsize() == 0: - self.minimum_reached = True + self.min_reached = True return None, None - def minimumReached(self) -> bool: + def minimum_reached(self) -> bool: """Return True if the optimization reached a global minimum.""" + return self.min_reached - return self.minimum_reached + def get_stats(self, penultimate: bool = False) -> NDArray[np.int_] | None: + """Return statistics of the search that was performed. - def getStats(self, penultimate: bool = False) -> NDArray[np.int_] | None: - """Return a Numpy array containing the number of states visited + This is Numpy array containing the number of states visited (dequeued), the number of next-states generated, the number of next-states that are enqueued after cost pruning, and the number of backjumps performed. Return None if no search is performed. If the bool penultimate is set to True, return the stats that correspond to the penultimate step in the search. """ - if penultimate: return self.penultimate_stats @@ -347,30 +325,25 @@ def getStats(self, penultimate: bool = False) -> NDArray[np.int_] | None: dtype=int, ) - def getUpperBoundCost(self) -> int | float | tuple[int | float, int | float] | None: - """Return the current upperbound cost""" - + def get_upperbound_cost( + self, + ) -> int | float | tuple[int | float, int | float] | None: + """Return the current upperbound cost.""" return self.upperbound_cost - def updateUpperBoundCost( + def update_upperbound_cost( self, cost_bound: int | float | tuple[int | float, int | float] ) -> None: - """Update the cost upper bound based on an - input cost bound. - """ - + """Update the cost upper bound based on an input cost bound.""" if cost_bound is not None and ( self.upperbound_cost is None or cost_bound < self.upperbound_cost ): self.upperbound_cost = cost_bound # type: ignore - def updateUpperBoundGoalState( + def update_upperbound_goal_state( self, goal_state: DisjointSubcircuitsState, *args: CutOptimizationFuncArgs ) -> None: - """Update the cost upper bound based on a - goal state reached in the search. - """ - + """Update the cost upper bound based on a goal state reached in the search.""" if self.upperbound_cost_func is not None: bound = self.upperbound_cost_func(goal_state, *args) else: # pragma: no cover @@ -386,10 +359,7 @@ def put( depth: int, args: tuple[CutOptimizationFuncArgs, ...], ) -> None: - """Push a list of (next) states onto the - best-first priority queue. - """ - + """Push a list of (next) states onto the best-first priority queue.""" self.num_next_states += len(state_list) for state in state_list: @@ -400,27 +370,21 @@ def put( self.pqueue.put(state, depth, cost) self.num_enqueues += 1 - def updateMinimumReached( + def update_minimum_reached( self, min_cost: None | int | float | tuple[int | float, int | float] ) -> bool: - """Update the minimum_reached flag indicating - that a global optimum has been reached. - """ - + """Update the min_reached flag indicating that a global optimum has been reached.""" if min_cost is None or ( self.upperbound_cost is not None and self.upperbound_cost <= min_cost ): - self.minimum_reached = True + self.min_reached = True - return self.minimum_reached + return self.min_reached - def costBoundsExceeded( + def cost_bounds_exceeded( self, cost: None | int | float | tuple[int | float, int | float] ) -> bool: - """Return True if any cost bounds - have been exceeded. - """ - + """Return True if any cost bounds have been exceeded.""" return cost is not None and ( (self.mincost_bound is not None and cost > self.mincost_bound) or (self.upperbound_cost is not None and cost > self.upperbound_cost) diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index 0d3b475e5..eb0a09c00 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -28,12 +28,11 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: - """Convert a qiskit quantum circuit object into a circuit list that is - compatible with the :class:`SimpleGateList`. To conform with the uniformity - of the design, single and multiqubit (that is, gates acting on more than two - qubits) are assigned :math:`gamma=None`. In the converted list, a barrier - across the entire circuit is represented by the string "barrier." - Everything else is represented by an instance of :class:`CircuitElement`. + """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class:`SimpleGateList`. + + To conform with the uniformity of the design, single and multiqubit (that is, gates acting on more than two + qubits) are assigned :math:`gamma=None`. In the converted list, a barrier across the entire circuit is + represented by the string "barrier." Everything else is represented by an instance of :class:`CircuitElement`. Args: circuit: an instance of :class:`qiskit.QuantumCircuit` . @@ -75,11 +74,11 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: Returns: qc_cut: The SimpleGateList converted into a :class:`qiskit.QuantumCircuit` instance. - TODO: This function only works for instances of LO gate cutting. - Expand to cover the wire cutting case when needed. + TODO: This is a function that is not used for now and it only works for instances of LO gate cutting. + Expand to cover the wire cutting case if or when needed. """ - cut_circuit_list = interface.exportCutCircuit(name_mapping=None) - num_qubits = interface.getNumWires() + cut_circuit_list = interface.export_cut_circuit(name_mapping=None) + num_qubits = interface.get_num_wires() cut_types = interface.cut_type qc_cut = QuantumCircuit(num_qubits) for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): @@ -93,16 +92,17 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: return qc_cut -def selectSearchEngine( +def select_search_engine( stage_of_optimization: str, optimization_settings: OptimizationSettings, search_space_funcs: SearchFunctions, stop_at_first_min: bool = False, ) -> BestFirstSearch: - """Select the search algorithm to use. At present, only Dijkstra's algorithm - for best first search is supported. + """Select the search algorithm to use. + + In this release, only Dijkstra's algorithm for best first search is supported. """ - engine = optimization_settings.getEngineSelection(stage_of_optimization) + engine = optimization_settings.get_engine_selection(stage_of_optimization) if engine == "BestFirst": return BestFirstSearch( @@ -115,18 +115,16 @@ def selectSearchEngine( raise ValueError(f"Search engine {engine} is not supported.") -def greedyBestFirstSearch( +def greedy_best_first_search( state: DisjointSubcircuitsState, search_space_funcs: SearchFunctions, *args: CutOptimizationFuncArgs, ) -> None | DisjointSubcircuitsState: - """Perform greedy best-first search using the input starting state and - the input search-space functions. The resulting goal state is returned, - or None if a deadend is reached (no backtracking is performed). Any - additional input arguments are passed as additional arguments to the - search-space functions. - """ + """Perform greedy best-first search using the input starting state and the input search-space functions. + The resulting goal state is returned, or None if a deadend is reached (no backtracking is performed). Any + additional input arguments are passed as additional arguments to the search-space functions. + """ search_space_funcs.goal_state_func = cast( Callable, search_space_funcs.goal_state_func ) @@ -149,7 +147,7 @@ def greedyBestFirstSearch( ) if best[-1] is not None: - return greedyBestFirstSearch(best[-1], search_space_funcs, *args) + return greedy_best_first_search(best[-1], search_space_funcs, *args) else: return None diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 06fc1db6a..a435674af 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -30,24 +30,15 @@ class CircuitElement(NamedTuple): class CircuitInterface(ABC): - - """Base class for accessing and manipulating external circuit - representations, and for converting external circuit representations - to the internal representation used by the circuit cutting optimization code. - - Derived classes must override the default implementations of the abstract - methods defined in this base class. - """ + """Access and manipulate external circuit representations, and convert to the internal representation used by the circuit cutting optimization code.""" @abstractmethod - def getNumQubits(self): - """Derived classes must override this function and return the number - of qubits in the input circuit.""" + def get_num_qubits(self): + """Return the number of qubits in the input circuit.""" @abstractmethod - def getMultiQubitGates(self): - """Derived classes must override this function and return a list that - specifies the multiqubit gates in the input circuit. + def get_multiqubit_gates(self): + """Return a list that specifies the multiqubit gates in the input circuit. The returned list is of the form: [ ... [ ] ...] @@ -85,17 +76,14 @@ def getMultiQubitGates(self): """ @abstractmethod - def insertGateCut(self, gate_ID, cut_type): - """Derived classes must override this function and mark the specified - gate as being cut. The cut types can only be "LO" in this release. - """ + def insert_gate_cut(self, gate_ID, cut_type): + """Mark the specified gate as being cut. The cut types can only be "LO" in this release.""" @abstractmethod - def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): - """Derived classes must override this function and insert a wire cut - into the output circuit just prior to the specified gate on the wire - connected to the specified input of that gate. Gate inputs are - numbered starting from 1. The wire/qubit ID of the wire to be cut + def insert_wire_cut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): + """Insert insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. + + Gate inputs are numbered starting from 1. The wire/qubit ID of the wire to be cut is also provided as input to allow the wire choice to be verified. The ID of the new wire/qubit is also provided, which can then be used internally in derived classes to create new wires/qubits as needed. @@ -103,17 +91,15 @@ def insertWireCut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): """ @abstractmethod - def defineSubcircuits(self, list_of_list_of_wires): - """Derived classes must override this function. The input is a - list of subcircuits where each subcircuit is specified as a - list of wire IDs. + def define_subcircuits(self, list_of_list_of_wires): + """Define subcircuits using as input a list of subcircuits. + + Each subcircuit is specified as a list of wire IDs. """ class SimpleGateList(CircuitInterface): - - """Derived class that converts a simple list of gates into - the form needed by the circuit-cutting optimizer code. + """Convert a simple list of gates into the form needed by the circuit-cutting optimizer code. Elements of the input list must be instances of :class:`CircuitElement`. The only exception to this is a barrier when one is placed across @@ -127,7 +113,6 @@ class SimpleGateList(CircuitInterface): preferred ordering in the assignment of numeric qubit IDs to each name. Member Variables: - qubit_names (NametoIDMap): an instance of :class:`NametoIDMap` that maps qubit names to numerical qubit IDs. @@ -178,6 +163,7 @@ def __init__( input_circuit: Sequence[CircuitElement | str], init_qubit_names: list[Hashable] = [], ): + """Assign member variables.""" self.qubit_names = NameToIDMap(init_qubit_names) self.circuit = list() @@ -193,33 +179,30 @@ def __init__( gate_spec = CircuitElement( name=gate.name, params=gate.params, - qubits=[self.qubit_names.getID(x) for x in gate.qubits], + qubits=[self.qubit_names.get_id(x) for x in gate.qubits], gamma=gate.gamma, ) self.circuit.append([copy.deepcopy(gate_spec), None]) self.new_circuit.append(copy.deepcopy(gate_spec)) - self.new_gate_ID_map = np.arange(len(self.circuit), dtype=int) - self.num_qubits = self.qubit_names.getArraySizeNeeded() + self.new_gate_id_map = np.arange(len(self.circuit), dtype=int) + self.num_qubits = self.qubit_names.get_array_size_needed() self.output_wires = np.arange(self.num_qubits, dtype=int) # Initialize the list of subcircuits assuming no cutting self.subcircuits: Sequence[list[int] | int] = list(list(range(self.num_qubits))) - def getNumQubits(self) -> int: + def get_num_qubits(self) -> int: """Return the number of qubits in the input circuit.""" - return self.num_qubits - def getNumWires(self) -> int: + def get_num_wires(self) -> int: """Return the number of wires/qubits in the cut circuit.""" + return self.qubit_names.get_num_items() - return self.qubit_names.getNumItems() - - def getMultiQubitGates( + def get_multiqubit_gates( self, ) -> Sequence[Sequence[int | CircuitElement | None | list]]: - """Extract the multiqubit gates from the circuit and prepend the - index of the gate in the circuits to the gate specification. + """Extract the multiqubit gates from the circuit and prepend the index of the gate in the circuits to the gate specification. The elements of the resulting list therefore have the form [ ] @@ -239,128 +222,120 @@ def getMultiQubitGates( return subcircuit - def insertGateCut(self, gate_ID: int, cut_type: str) -> None: - """Mark the specified gate as being cut. The cut type in this release - can only be "LO". - """ - - gate_pos = self.new_gate_ID_map[gate_ID] + def insert_gate_cut(self, gate_id: int, cut_type: str) -> None: + """Mark the specified gate as being cut. The cut type in this release can only be "LO".""" + gate_pos = self.new_gate_id_map[gate_id] self.cut_type[gate_pos] = cut_type - def insertWireCut( + def insert_wire_cut( self, - gate_ID: int, - input_ID: int, - src_wire_ID: int, - dest_wire_ID: int, + gate_id: int, + input_id: int, + src_wire_id: int, + dest_wire_id: int, cut_type: str, ) -> None: - """Insert a wire cut into the output circuit just prior to the - specified gate on the wire connected to the specified input of - that gate. Gate inputs are numbered starting from 1. The + """Insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. + + Gate inputs are numbered starting from 1. The wire/qubit ID of the source wire to be cut is also provided as input to allow the wire choice to be verified. The ID of the (new) destination wire/qubit must also be provided. The cut type in this release can only be "LO". """ - - gate_pos = self.new_gate_ID_map[gate_ID] + gate_pos = self.new_gate_id_map[gate_id] new_gate_spec = self.new_circuit[gate_pos] # Gate inputs are numbered starting from 1, so we must # decrement the index to match qubit numbering. - assert src_wire_ID == new_gate_spec.qubits[input_ID - 1], ( - f"Input wire ID {src_wire_ID} does not match " - + f"new_circuit wire ID {new_gate_spec.qubits[input_ID-1]}" + assert src_wire_id == new_gate_spec.qubits[input_id - 1], ( + f"Input wire ID {src_wire_id} does not match " + + f"new_circuit wire ID {new_gate_spec.qubits[input_id-1]}" ) # If the new wire does not yet exist, then define it - if self.qubit_names.getName(dest_wire_ID) is None: - wire_name = self.qubit_names.getName(src_wire_ID) - self.qubit_names.defineID(dest_wire_ID, ("cut", wire_name)) + if self.qubit_names.get_name(dest_wire_id) is None: + wire_name = self.qubit_names.get_name(src_wire_id) + self.qubit_names.define_id(dest_wire_id, ("cut", wire_name)) - # Replace src_wire_ID with dest_wire_ID in the part of new_circuit that + # Replace src_wire_id with dest_wire_id in the part of new_circuit that # follows the wire-cut insertion point - wire_map = list(range(self.qubit_names.getArraySizeNeeded())) - wire_map[src_wire_ID] = dest_wire_ID + wire_map = list(range(self.qubit_names.get_array_size_needed())) + wire_map[src_wire_id] = dest_wire_id - self.replaceWireIDs(self.new_circuit[gate_pos:], wire_map) + self.replace_wire_ids(self.new_circuit[gate_pos:], wire_map) # Insert a move operator self.new_circuit = cast(list, self.new_circuit) - self.new_circuit.insert(gate_pos, ["move", src_wire_ID, dest_wire_ID]) + self.new_circuit.insert(gate_pos, ["move", src_wire_id, dest_wire_id]) self.cut_type.insert(gate_pos, cut_type) - self.new_gate_ID_map[gate_ID:] += 1 + self.new_gate_id_map[gate_id:] += 1 # Update the output wires - op = cast(CircuitElement, self.circuit[gate_ID][0]) - qubit = op.qubits[input_ID - 1] - self.output_wires[qubit] = dest_wire_ID - - def defineSubcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: - """Assign subcircuits where each subcircuit is - specified as a list of wire IDs. - """ + op = cast(CircuitElement, self.circuit[gate_id][0]) + qubit = op.qubits[input_id - 1] + self.output_wires[qubit] = dest_wire_id + def define_subcircuits(self, list_of_list_of_wires: list[list[int]]) -> None: + """Assign subcircuits where each subcircuit is specified as a list of wire IDs.""" self.subcircuits = list_of_list_of_wires - def getWireNames(self) -> list[Hashable]: - """Return a list of the internal wire names used in the circuit, - which consists of the original qubit names together with additional + def get_wire_names(self) -> list[Hashable]: + """Return a list of the internal wire names used in the circuit. + + This consists of the original qubit names together with additional names of form ("cut", ) introduced to represent cut wires. """ + return list(self.qubit_names.get_items()) - return list(self.qubit_names.getItems()) - - def exportCutCircuit( + def export_cut_circuit( self, name_mapping: None | str = "default", ) -> Sequence[CircuitElement | Sequence]: - """Return a list of gates representing the cut circuit. If None - is provided as the name_mapping, then the original qubit names are + """Return a list of gates representing the cut circuit. + + If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then the defaultWireNameMapping() method defines the name mapping. + then the default_wire_name_mapping() method defines the name mapping. """ - - wire_map = self.makeWireMapping(name_mapping) + wire_map = self.make_wire_mapping(name_mapping) out = copy.deepcopy(self.new_circuit) wire_map = cast(list, wire_map) - self.replaceWireIDs(out, wire_map) + self.replace_wire_ids(out, wire_map) return out - def exportOutputWires( + def export_output_wires( self, name_mapping: None | str = "default", ) -> dict[Hashable, Hashable | tuple[str, Hashable]]: - """Return a dictionary that maps output qubits in the input circuit - to the corresponding output wires/qubits in the cut circuit. If None - is provided as the name_mapping, then the original qubit names are + """Return a dictionary that maps output qubits in the input circuit to the corresponding output wires/qubits in the cut circuit. + + If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then the defaultWireNameMapping() method defines the name mapping. + then the default_wire_name_mapping() method defines the name mapping. """ - - wire_map = self.makeWireMapping(name_mapping) + wire_map = self.make_wire_mapping(name_mapping) out = dict() for in_wire, out_wire in enumerate(self.output_wires): - out[self.qubit_names.getName(in_wire)] = wire_map[out_wire] + out[self.qubit_names.get_name(in_wire)] = wire_map[out_wire] return out - def exportSubcircuitsAsString( + def export_subcircuits_as_string( self, name_mapping: None | str = "default", ) -> str: - """Return a string that maps qubits/wires in the output circuit - to subcircuits per the Circuit Knitting Toolbox convention. This + """Return a string that maps qubits/wires in the output circuit to subcircuits. + + This mapping is done per the Circuit Knitting Toolbox convention. This method only works with mappings to numeric qubit/wire names. """ + wire_map = self.make_wire_mapping(name_mapping) - wire_map = self.makeWireMapping(name_mapping) - - out: Sequence[int | str] = list(range(self.getNumWires())) + out: Sequence[int | str] = list(range(self.get_num_wires())) out = cast(list, out) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): @@ -369,42 +344,37 @@ def exportSubcircuitsAsString( out[wire_map[wire]] = alphabet[k] # type: ignore return "".join(out) - def makeWireMapping( + def make_wire_mapping( self, name_mapping: None | str | dict ) -> Sequence[int | tuple[str, int]]: - """Return a wire-mapping list given an input specification of a - name mapping. If None is provided as the input name_mapping, then - the original qubit names are mapped to themselves. If "default" - is used as the name_mapping, then the defaultWireNameMapping() - method is used to define the name mapping. - """ + """Return a wire-mapping list given an input specification of a name mapping. + If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. + If "default" is used as the name_mapping, then the default_wire_name_mapping() method is used to define the name mapping. + """ if name_mapping is None: name_mapping = dict() - for name in self.getWireNames(): + for name in self.get_wire_names(): name_mapping[name] = name elif name_mapping == "default": - name_mapping = self.defaultWireNameMapping() # type: ignore + name_mapping = self.default_wire_name_mapping() # type: ignore wire_mapping: list[int | tuple[str, int]] = list() - for k in self.qubit_names.getIDs(): + for k in self.qubit_names.get_ids(): name_mapping = cast(dict, name_mapping) - wire_mapping.append(name_mapping[self.qubit_names.getName(k)]) + wire_mapping.append(name_mapping[self.qubit_names.get_name(k)]) return wire_mapping - def defaultWireNameMapping(self) -> dict[Hashable, int]: - """Return a dictionary that maps wire names in :func:`self.getWireNames()` to - default numeric output qubit names when exporting a cut circuit. Cut - wires are assigned numeric IDs that are adjacent to the numeric - ID of the wire prior to cutting so that Move operators are then - applied against adjacent qubits. This is ensured by the :func:`self.sortOrder()` - method. - """ + def default_wire_name_mapping(self) -> dict[Hashable, int]: + """Return a dictionary that maps wire names to default numeric output qubit names when exporting a cut circuit. - name_pairs = [(name, self.sortOrder(name)) for name in self.getWireNames()] + Cut wires are assigned numeric IDs that are adjacent to the numeric ID of the wire prior to cutting so that Move + operators are then applied against adjacent qubits. This is ensured by the :func:`sort_order` method. + """ + name_pairs = [(name, self.sort_order(name)) for name in self.get_wire_names()] name_pairs.sort(key=lambda x: x[1]) @@ -414,26 +384,23 @@ def defaultWireNameMapping(self) -> dict[Hashable, int]: return name_map - def sortOrder(self, name: Hashable) -> int | float: - """Order numeric IDs of wires to enable :func:`defaultWireNameMapping`.""" - + def sort_order(self, name: Hashable) -> int | float: + """Order numeric IDs of wires to enable :func:`default_wire_name_mapping`.""" if isinstance(name, tuple): if name[0] == "cut": - x = self.sortOrder(name[1]) + x = self.sort_order(name[1]) x_int = int(x) x_frac = x - x_int return x_int + 0.5 * x_frac + 0.5 - return self.qubit_names.getID(name) + return self.qubit_names.get_id(name) - def replaceWireIDs( + def replace_wire_ids( self, gate_list: Sequence[CircuitElement | Sequence[str | int]], wire_map: list[int], ) -> None: - """Iterate through a list of gates and replace wire IDs with the - values defined by the wire_map. - """ + """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map.""" for inst in gate_list: if isinstance(inst, CircuitElement): for k in range(len(inst.qubits)): @@ -444,83 +411,74 @@ def replaceWireIDs( class NameToIDMap: - - """Class used to construct maps between hashable items (e.g., qubit names) - and natural numbers (e.g., qubit IDs). - """ + """Class used to construct maps between hashable items (e.g., qubit names) and natural numbers (e.g., qubit IDs).""" def __init__(self, init_names: list[Hashable]): - """Allow the name dictionary to be initialized with the names - in init_names in the order the names appear in order to force a - preferred ordering in the assigment of item IDs to those names. - """ + """Allow the name dictionary to be initialized with the names in init_names in the order the names appear. - self.next_ID: int = 0 + This is done in order to force a preferred ordering in the assigment of item IDs to those names. + """ + self.next_id: int = 0 self.item_dict: dict[Hashable, int] = dict() - self.ID_dict: dict[int, Hashable] = dict() + self.id_dict: dict[int, Hashable] = dict() for name in init_names: - self.getID(name) + self.get_id(name) - def getID(self, item_name: Hashable) -> int: + def get_id(self, item_name: Hashable) -> int: """Return the numeric ID associated with the specified hashable item. + If the hashable item does not yet appear in the item dictionary, a new item ID is assigned. """ if item_name not in self.item_dict: - while self.next_ID in self.ID_dict: - self.next_ID += 1 + while self.next_id in self.id_dict: + self.next_id += 1 - self.item_dict[item_name] = self.next_ID - self.ID_dict[self.next_ID] = item_name - self.next_ID += 1 + self.item_dict[item_name] = self.next_id + self.id_dict[self.next_id] = item_name + self.next_id += 1 return self.item_dict[item_name] - def defineID(self, item_ID: int, item_name: Hashable) -> None: + def define_id(self, item_id: int, item_name: Hashable) -> None: """Assign a specific ID number to an item name.""" - - assert item_ID not in self.ID_dict, f"item ID {item_ID} already assigned" + assert item_id not in self.id_dict, f"item ID {item_id} already assigned" assert ( item_name not in self.item_dict ), f"item name {item_name} already assigned" - self.item_dict[item_name] = item_ID - self.ID_dict[item_ID] = item_name + self.item_dict[item_name] = item_id + self.id_dict[item_id] = item_name - def getName(self, item_ID: int) -> Hashable | None: + def get_name(self, item_id: int) -> Hashable | None: """Return the name associated with the specified item ID. + None is returned if item_ID does not (yet) exist. """ - - if item_ID not in self.ID_dict: + if item_id not in self.id_dict: return None - return self.ID_dict[item_ID] + return self.id_dict[item_id] - def getNumItems(self) -> int: + def get_num_items(self) -> int: """Return the number of hashable items loaded thus far.""" - return len(self.item_dict) - def getArraySizeNeeded(self) -> int: - """Return one plus the maximum item ID assigned thus far, - or zero if no items have been assigned. The value returned - is thus the minimum size needed for a Python/Numpy - array that maps item IDs to other hashables. - """ + def get_array_size_needed(self) -> int: + """Return one plus the maximum item ID assigned thus far, or zero if no items have been assigned. - if self.getNumItems() == 0: # pragma: no cover + The value returned is thus the minimum size needed for a Python/Numpy array that maps item IDs to other hashables. + """ + if self.get_num_items() == 0: # pragma: no cover return 0 - return 1 + max(self.ID_dict.keys()) + return 1 + max(self.id_dict.keys()) - def getItems(self) -> Iterable[Hashable]: + def get_items(self) -> Iterable[Hashable]: """Return the keys of the dictionary of hashable items loaded thus far.""" - return self.item_dict.keys() - def getIDs(self) -> Iterable[int]: + def get_ids(self) -> Iterable[int]: """Return the keys of the dictionary of ID's assigned to hashable items loaded thus far.""" - - return self.ID_dict.keys() + return self.id_dict.keys() diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py index 7e5f28632..ed41d744c 100644 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ b/circuit_knitting/cutting/cut_finding/cut_finding.py @@ -57,7 +57,7 @@ def find_cuts( opt_settings = optimization # Hard-code the optimization type to best-first - opt_settings.setEngineSelection("CutOptimization", "BestFirst") + opt_settings.set_engine_selection("CutOptimization", "BestFirst") if isinstance(constraints, dict): constraint_settings = DeviceConstraints.from_dict(constraints) @@ -76,7 +76,7 @@ def find_cuts( opt_out = cast(DisjointSubcircuitsState, opt_out) opt_out.actions = cast(list, opt_out.actions) for action in opt_out.actions: - if action[0].getName() == "CutTwoQubitGate": + if action[0].get_name() == "CutTwoQubitGate": gate_ids.append(action[1][0]) else: wire_cut_actions.append(action) @@ -89,7 +89,7 @@ def find_cuts( # Insert all the wire cuts counter = 0 for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): - if action[0].getName() == "CutTwoQubitGate": + if action[0].get_name() == "CutTwoQubitGate": continue inst_id = action[1][0] qubit_id = action[2][0][0] - 1 diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index ccb2e3209..8d6c03804 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -18,10 +18,10 @@ from typing import cast from numpy.typing import NDArray from .search_space_generator import ActionNames -from .cco_utils import selectSearchEngine, greedyBestFirstSearch +from .cco_utils import select_search_engine, greedy_best_first_search from .cutting_actions import disjoint_subcircuit_actions from .search_space_generator import ( - getActionSubset, + get_action_subset, SearchFunctions, SearchSpaceGenerator, ) @@ -33,10 +33,7 @@ @dataclass class CutOptimizationFuncArgs: - - """Class for passing relevant arguments to the CutOptimization - search-space generating functions. - """ + """Collect arguments for passing to the :class:`CutOptimization` search-space generating methods.""" entangling_gates: Sequence[ Sequence[int | CircuitElement | None | list] @@ -46,47 +43,46 @@ class CutOptimizationFuncArgs: qpu_width: int | None = None -def CutOptimizationCostFunc( +def cut_optimization_cost_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> tuple[int | float, int]: - """Return the cost function. The particular cost function chosen here - aims to minimize the gamma while also (secondarily) giving preference to - circuit partitionings that balance the sizes of the resulting partitions, - by minimizing the maximum width across subcircuits. - """ + """Return the cost function. - return (state.lowerBoundGamma(), state.getMaxWidth()) + The particular cost function chosen here aims to minimize the gamma + while also (secondarily) giving preference to circuit partitionings + that balance the sizes of the resulting partitions, by minimizing the + maximum width across subcircuits. + """ + return (state.lower_bound_gamma(), state.get_max_width()) -def CutOptimizationUpperBoundCostFunc( +def cut_optimization_upper_bound_cost_func( goal_state, func_args: CutOptimizationFuncArgs ) -> tuple[int | float, int | float]: """Return the gamma upper bound.""" - return (goal_state.upperBoundGamma(), np.inf) + return (goal_state.upper_bound_gamma(), np.inf) -def CutOptimizationMinCostBoundFunc( +def cut_optimization_min_cost_bound_func( func_args: CutOptimizationFuncArgs, ) -> tuple[int | float, int | float] | None: """Return an a priori min-cost bound defined in the optimization settings.""" - if func_args.max_gamma is None: # pragma: no cover return None return (func_args.max_gamma, np.inf) -def CutOptimizationNextStateFunc( +def cut_optimization_next_state_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> list[DisjointSubcircuitsState]: """Generate a list of next states from the input state.""" - # Get the entangling gate spec that is to be processed next based # on the search level of the input state assert func_args.entangling_gates is not None assert func_args.search_actions is not None - gate_spec = func_args.entangling_gates[state.getSearchLevel()] + gate_spec = func_args.entangling_gates[state.get_search_level()] # Determine which search actions can be performed, taking into # account any user-specified constraints that might have been @@ -95,7 +91,7 @@ def CutOptimizationNextStateFunc( gate = gate_spec[1] gate = cast(CircuitElement, gate) if len(gate.qubits) == 2: - action_list = func_args.search_actions.getGroup("TwoQubitGates") + action_list = func_args.search_actions.get_group("TwoQubitGates") else: raise ValueError( "In the current version, only the cutting of two qubit gates is supported." @@ -103,63 +99,64 @@ def CutOptimizationNextStateFunc( gate_actions = gate_spec[2] gate_actions = cast(list, gate_actions) - action_list = getActionSubset(action_list, gate_actions) + action_list = get_action_subset(action_list, gate_actions) + # Apply the search actions to generate a list of next states next_state_list = [] assert action_list is not None for action in action_list: func_args.qpu_width = cast(int, func_args.qpu_width) - next_state_list.extend(action.nextState(state, gate_spec, func_args.qpu_width)) + next_state_list.extend(action.next_state(state, gate_spec, func_args.qpu_width)) return next_state_list -def CutOptimizationGoalStateFunc( +def cut_optimization_goal_state_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> bool: - """Return True if the input state is a goal state (i.e., the cutting decisions made satisfy - the device constraints and the optimization settings). - """ + """Return True if the input state is a goal state.""" func_args.entangling_gates = cast(list, func_args.entangling_gates) - return state.getSearchLevel() >= len(func_args.entangling_gates) + return state.get_search_level() >= len(func_args.entangling_gates) ### Global variable that holds the search-space functions for generating ### the cut optimization search space cut_optimization_search_funcs = SearchFunctions( - cost_func=CutOptimizationCostFunc, - upperbound_cost_func=CutOptimizationUpperBoundCostFunc, - next_state_func=CutOptimizationNextStateFunc, - goal_state_func=CutOptimizationGoalStateFunc, - mincost_bound_func=CutOptimizationMinCostBoundFunc, + cost_func=cut_optimization_cost_func, + upperbound_cost_func=cut_optimization_upper_bound_cost_func, + next_state_func=cut_optimization_next_state_func, + goal_state_func=cut_optimization_goal_state_func, + mincost_bound_func=cut_optimization_min_cost_bound_func, ) -def greedyCutOptimization( +def greedy_cut_optimization( circuit_interface: SimpleGateList, optimization_settings: OptimizationSettings, device_constraints: DeviceConstraints, search_space_funcs: SearchFunctions = cut_optimization_search_funcs, search_actions: ActionNames = disjoint_subcircuit_actions, ) -> DisjointSubcircuitsState | None: + """Peform a first pass at cut optimization using greedy best first search.""" func_args = CutOptimizationFuncArgs() - func_args.entangling_gates = circuit_interface.getMultiQubitGates() + func_args.entangling_gates = circuit_interface.get_multiqubit_gates() func_args.search_actions = search_actions - func_args.max_gamma = optimization_settings.getMaxGamma() - func_args.qpu_width = device_constraints.getQPUWidth() + func_args.max_gamma = optimization_settings.get_max_gamma() + func_args.qpu_width = device_constraints.get_qpu_width() start_state = DisjointSubcircuitsState( - circuit_interface.getNumQubits(), maxWireCutsCircuit(circuit_interface) + circuit_interface.get_num_qubits(), max_wire_cuts_circuit(circuit_interface) ) - return greedyBestFirstSearch(start_state, search_space_funcs, func_args) + return greedy_best_first_search(start_state, search_space_funcs, func_args) ################################################################################ class CutOptimization: + """Implement cut optimization whereby qubits are not reused. - """Class that implements cut optimization whereby qubits are not reused - via circuit folding (i.e., when mid-circuit measurement and active + Because of the condition of no qubit reuse, it is assumed that + there is no circuit folding (i.e., when mid-circuit measurement and active reset are not available). CutOptimization focuses on using circuit cutting to create disjoint subcircuits. @@ -168,28 +165,26 @@ class CutOptimization: choices of quasiprobability decompositions. Member Variables: - - circuit (:class:`CircuitInterface`) is the interface object for the circuit + circuit (:class:`CircuitInterface`) is the interface for the circuit to be cut. - settings (:class:`OptimizationSettings`) is an object that contains the settings - that control the optimization process. + settings (:class:`OptimizationSettings`)contains the settings that + control the optimization process. - constraints (:class:`DeviceConstraints`) is an object that contains the device - constraints that solutions must obey. + constraints (:class:`DeviceConstraints`) contains the device constraints + that solutions must obey. - search_funcs (:class:`SearchFunctions`) is an object that holds the functions - needed to generate and explore the cut optimization search space. + search_funcs (:class:`SearchFunctions`) holds the functions needed to generate + and explore the cut optimization search space. - func_args (:class:`CutOptimizationFuncArgs`) is an object that contains the - necessary device constraints and optimization settings parameters that - aree needed by the cut optimization search-space function. + func_args (:class:`CutOptimizationFuncArgs`) contains the necessary device constraints + and optimization settings parameters that are needed by the cut optimization + search-space function. - search_actions (:class:`ActionNames`) is an object that contains the allowed - actions that are used to generate the search space. + search_actions (:class:`ActionNames`) contains the allowed actions that are used to + generate the search space. - search_engine (:class`BestFirstSearch`) is an object that implements the - search algorithm. + search_engine (:class`BestFirstSearch`) implements the search algorithm. """ def __init__( @@ -204,19 +199,20 @@ def __init__( ) }, ): - """A CutOptimization object must be initialized with + """Assign member variables. + + A CutOptimization object must be initialized with a specification of all of the parameters of the optimization to be performed: i.e., the circuit to be cut, the optimization settings, the target-device constraints, the functions for generating the search space, and the allowed search actions. """ - generator = search_engine_config["CutOptimization"] search_space_funcs = generator.functions search_space_actions = generator.actions # Extract the subset of allowed actions as defined in the settings object - cut_groups = optimization_settings.getCutSearchGroups() + cut_groups = optimization_settings.get_cut_search_groups() cut_actions = search_space_actions.copy(cut_groups) self.circuit = circuit_interface @@ -226,14 +222,14 @@ def __init__( self.search_actions = cut_actions self.func_args = CutOptimizationFuncArgs() - self.func_args.entangling_gates = self.circuit.getMultiQubitGates() + self.func_args.entangling_gates = self.circuit.get_multiqubit_gates() self.func_args.search_actions = self.search_actions - self.func_args.max_gamma = self.settings.getMaxGamma() - self.func_args.qpu_width = self.constraints.getQPUWidth() + self.func_args.max_gamma = self.settings.get_max_gamma() + self.func_args.qpu_width = self.constraints.get_qpu_width() # Perform an initial greedy best-first search to determine an upper # bound for the optimal gamma - self.greedy_goal_state = greedyCutOptimization( + self.greedy_goal_state = greedy_cut_optimization( self.circuit, self.settings, self.constraints, @@ -245,22 +241,22 @@ def __init__( # Use the upper bound for the optimal gamma to determine the maximum # number of wire cuts that can be performed when allocating the # data structures in the actual state. - max_wire_cuts = maxWireCutsCircuit(self.circuit) + max_wire_cuts = max_wire_cuts_circuit(self.circuit) if self.greedy_goal_state is not None: - mwc = maxWireCutsGamma(self.greedy_goal_state.upperBoundGamma()) + mwc = max_wire_cuts_gamma(self.greedy_goal_state.upper_bound_gamma()) max_wire_cuts = min(max_wire_cuts, mwc) elif self.func_args.max_gamma is not None: - mwc = maxWireCutsGamma(self.func_args.max_gamma) + mwc = max_wire_cuts_gamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) # Push the start state onto the search_engine start_state = DisjointSubcircuitsState( - self.circuit.getNumQubits(), max_wire_cuts + self.circuit.get_num_qubits(), max_wire_cuts ) - sq = selectSearchEngine( + sq = select_search_engine( "CutOptimization", self.settings, self.search_funcs, @@ -268,20 +264,22 @@ def __init__( ) sq.initialize([start_state], self.func_args) - # Use the upper bound for the optimal gamma to constrain the search + # Use the upper bound from the initial greedy search to constrain the + # subsequent search. if self.greedy_goal_state is not None: - sq.updateUpperBoundGoalState(self.greedy_goal_state, self.func_args) + sq.update_upperbound_goal_state(self.greedy_goal_state, self.func_args) self.search_engine = sq self.goal_state_returned = False - def optimizationPass(self) -> tuple[DisjointSubcircuitsState, int | float]: - """Produce, at each call, a goal state representing a distinct - set of cutting decisions. None is returned once no additional choices + def optimization_pass(self) -> tuple[DisjointSubcircuitsState, int | float]: + """Produce, at each call, a goal state representing a distinct set of cutting decisions. + + None is returned once no additional choices of cuts can be made without exceeding the minimum upper bound across all cutting decisions previously returned, given the optimization settings. """ - state, cost = self.search_engine.optimizationPass(self.func_args) + state, cost = self.search_engine.optimization_pass(self.func_args) if state is None and not self.goal_state_returned: state = self.greedy_goal_state cost = self.search_funcs.cost_func(state, self.func_args) @@ -290,45 +288,37 @@ def optimizationPass(self) -> tuple[DisjointSubcircuitsState, int | float]: return state, cost - def minimumReached(self) -> bool: + def minimum_reached(self) -> bool: """Return True if the optimization reached a global minimum.""" + return self.search_engine.minimum_reached() - return self.search_engine.minimumReached() - - def getStats(self, penultimate: bool = False) -> NDArray[np.int_]: + def get_stats(self, penultimate: bool = False) -> NDArray[np.int_]: """Return the search-engine statistics.""" + return self.search_engine.get_stats(penultimate=penultimate) - return self.search_engine.getStats(penultimate=penultimate) - - def getUpperBoundCost(self) -> tuple[int | float, int | float]: + def get_upperbound_cost(self) -> tuple[int | float, int | float]: """Return the current upperbound cost.""" + return self.search_engine.get_upperbound_cost() - return self.search_engine.getUpperBoundCost() - - def updateUpperBoundCost(self, cost_bound: tuple[int | float, int | float]) -> None: + def update_upperbound_cost( + self, cost_bound: tuple[int | float, int | float] + ) -> None: """Update the cost upper bound based on an input cost bound.""" + self.search_engine.update_upperbound_cost(cost_bound) - self.search_engine.updateUpperBoundCost(cost_bound) - -def maxWireCutsCircuit(circuit_interface: SimpleGateList) -> int: - """Calculate an upper bound on the maximum number of wire cuts - that can be made given the total number of inputs to multiqubit - gates in the circuit. +def max_wire_cuts_circuit(circuit_interface: SimpleGateList) -> int: + """Calculate an upper bound on the maximum possible number of wire cuts, given the total number of inputs to multiqubit gates in the circuit. NOTE: There is no advantage gained by cutting wires that only have single qubit gates acting on them, so without loss of generality we can assume that wire cutting is performed only on the inputs to multiqubit gates. """ - - multiqubit_wires = [len(x[1].qubits) for x in circuit_interface.getMultiQubitGates()] # type: ignore + multiqubit_wires = [len(x[1].qubits) for x in circuit_interface.get_multiqubit_gates()] # type: ignore return sum(multiqubit_wires) -def maxWireCutsGamma(max_gamma: float | int) -> int: - """Calculate an upper bound on the maximum number of wire cuts - that can be made given the maximum allowed gamma. - """ - +def max_wire_cuts_gamma(max_gamma: float | int) -> int: + """Calculate an upper bound on the maximum number of wire cuts that can be made given the maximum allowed gamma.""" return int(np.ceil(np.log2(max_gamma + 1) - 1)) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 4ca54044c..672639e13 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -26,80 +26,65 @@ class DisjointSearchAction(ABC): - """Base class for search actions for constructing disjoint subcircuits.""" @abstractmethod - def getName(self): - """Derived classes must return the look-up name of the action.""" + def get_name(self): + """Return the look-up name of the associated instance of :class:`DisjointSearchAction`.""" @abstractmethod - def getGroupNames(self): - """Derived classes must return a list of group names.""" + def get_group_names(self): + """Return the group name of the associated instance of :class:`DisjointSearchAction`.""" @abstractmethod - def nextStatePrimitive(self, state, gate_spec, max_width): - """Derived classes must return a list of search states that - result from applying all variations of the action to gate_spec - in the specified DisjointSubcircuitsState state, subject to the - constraint that the number of resulting qubits (wires) in each - subcircuit cannot exceed max_width. - """ + def next_state_primitive(self, state, gate_spec, max_width): + """Return the new state that results from applying the associated instance of :class:`DisjointSearchAction`.""" - def nextState( + def next_state( self, state: DisjointSubcircuitsState, gate_spec: Sequence[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return a list of search states that result from applying the - action to gate_spec in the specified DisjointSubcircuitsState - state, subject to the constraint that the number of resulting - qubits (wires) in each subcircuit cannot exceed max_width. - """ + """Return a list of search states that result from applying the action to gate_spec in the specified :class:`DisjointSubcircuitsState` state. - next_list = self.nextStatePrimitive(state, gate_spec, max_width) + This is subject to the constraint that the number of resulting qubits (wires) in each subcircuit cannot exceed max_width. + """ + next_list = self.next_state_primitive(state, gate_spec, max_width) for next_state in next_list: - next_state.setNextLevel(state) + next_state.set_next_level(state) return next_list class ActionApplyGate(DisjointSearchAction): + """Implement the action of applying a two-qubit gate without decomposition.""" - """Action class that implements the action of - applying a two-qubit gate without decomposition""" - - def getName(self) -> None: - """Return the look-up name of ActionApplyGate.""" - + def get_name(self) -> None: + """Return the look-up name of :class:`ActionApplyGate`.""" return None - def getGroupNames(self) -> list[None | str]: - """Return the group name of ActionApplyGate.""" - + def get_group_names(self) -> list[None | str]: + """Return the group name of :class:`ActionApplyGate`.""" return [None, "TwoQubitGates"] - def nextStatePrimitive( + def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: list[int | CircuitElement | None | list], max_width: int | float, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying - ActionApplyGate to state given the two-qubit gate - specification: gate_spec. - """ + """Return the new state that results from applying :class:`ActionApplyGate` to state given the two-qubit gate specification: gate_spec.""" gate = gate_spec[1] # extract the gate from gate specification. gate = cast(CircuitElement, gate) # extract the root wire for the first qubit # acted on by the given 2-qubit gate. - r1 = state.findQubitRoot(gate.qubits[0]) + r1 = state.find_qubit_root(gate.qubits[0]) # extract the root wire for the second qubit # acted on by the given 2-qubit gate. - r2 = state.findQubitRoot(gate.qubits[1]) + r2 = state.find_qubit_root(gate.qubits[1]) # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate assert state.width is not None @@ -108,72 +93,67 @@ def nextStatePrimitive( # If the gate cannot be applied because it would violate the # merge constraints, then do not apply the gate - if state.checkDoNotMergeRoots(r1, r2): + if state.check_donot_merge_roots(r1, r2): return list() new_state = state.copy() if r1 != r2: - new_state.mergeRoots(r1, r2) + new_state.merge_roots(r1, r2) - new_state.addAction(self, gate_spec) + new_state.add_action(self, gate_spec) return [new_state] ### Adds ActionApplyGate to the global variable disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionApplyGate()) +disjoint_subcircuit_actions.define_action(ActionApplyGate()) class ActionCutTwoQubitGate(DisjointSearchAction): - """Action of cutting a two-qubit gate.""" - - def getName(self) -> str: - """Return the look-up name of ActionCutTwoQubitGate.""" + """Cut a two-qubit gate.""" + def get_name(self) -> str: + """Return the look-up name of :class:`ActionCutTwoQubitGate`.""" return "CutTwoQubitGate" - def getGroupNames(self) -> list[str]: - """Return the group name of ActionCutTwoQubitGate.""" - + def get_group_names(self) -> list[str]: + """Return the group name of :class:`ActionCutTwoQubitGate`.""" return ["GateCut", "TwoQubitGates"] - def nextStatePrimitive( + def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: list[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying - ActionCutTwoQubitGate to state given the gate_spec. - """ - + """Return the new state that results from applying :class:`ActionCutTwoQubitGate` to state given the gate_spec.""" gate = gate_spec[1] gate = cast(CircuitElement, gate) - # Cutting of multi-qubit gates is not supported in this version. + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "At present, only the cutting of two qubit gates is supported." + "In this release, only the cutting of two qubit gates is supported." ) - gamma_LB, num_bell_pairs, gamma_UB = self.getCostParams(gate_spec) + gamma_LB, num_bell_pairs, gamma_UB = self.get_cost_params(gate_spec) if gamma_LB is None: return list() q1 = gate.qubits[0] q2 = gate.qubits[1] - w1 = state.getWire(q1) - w2 = state.getWire(q2) - r1 = state.findQubitRoot(q1) - r2 = state.findQubitRoot(q2) + w1 = state.get_wire(q1) + w2 = state.get_wire(q2) + r1 = state.find_qubit_root(q1) + r2 = state.find_qubit_root(q2) if r1 == r2: return list() new_state = state.copy() - new_state.assertDoNotMergeRoots(r1, r2) + new_state.assert_donot_merge_roots(r1, r2) gamma_LB = cast(int, gamma_LB) new_state.gamma_LB = cast(int, new_state.gamma_LB) @@ -187,16 +167,16 @@ def nextStatePrimitive( new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= gamma_UB - new_state.addAction(self, gate_spec, (1, w1), (2, w2)) + new_state.add_action(self, gate_spec, (1, w1), (2, w2)) return [new_state] @staticmethod - def getCostParams( + def get_cost_params( gate_spec: list[int | CircuitElement | None | list], ) -> tuple[int | float | None, int, int | float | None]: """ - Get the cost parameters. + Get the cost parameters for gate cuts. This method returns a tuple of the form: (gamma_lower_bound, num_bell_pairs, gamma_upper_bound) @@ -209,239 +189,209 @@ def getCostParams( gamma = gate.gamma return (gamma, 0, gamma) - def exportCuts( + def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], gate_spec: list[int | CircuitElement | None | list], args, ) -> None: - """Insert an LO gate cut into the input circuit for the specified gate - and cut arguments. - """ - + """Insert an LO gate cut into the input circuit for the specified gate and cut arguments.""" assert isinstance(gate_spec[0], int) - circuit_interface.insertGateCut(gate_spec[0], "LO") + circuit_interface.insert_gate_cut(gate_spec[0], "LO") ### Adds ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionCutTwoQubitGate()) +disjoint_subcircuit_actions.define_action(ActionCutTwoQubitGate()) class ActionCutLeftWire(DisjointSearchAction): + """Cut the left (first input) wire of a two-qubit gate.""" - """Action class that implements the action of - cutting the left (first) wire of a two-qubit gate""" - - def getName(self) -> str: - """Return the look-up name of ActionCutLeftWire.""" - + def get_name(self) -> str: + """Return the look-up name of :class:`ActionCutLeftWire`.""" return "CutLeftWire" - def getGroupNames(self) -> list[str]: - """Return the group name of ActionCutLeftWire.""" - + def get_group_names(self) -> list[str]: + """Return the group name of :class:`ActionCutLeftWire`.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive( + def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: list[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying - ActionCutLeftWire to state given the gate_spec. - """ + """Return the new state that results from applying :class:`ActionCutLeftWire` to state given the gate_spec.""" gate = gate_spec[1] gate = cast(CircuitElement, gate) - # Cutting of multi-qubit gates is not supported in this version. + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "At present, only the cutting of two qubit gates is supported." + "In this release, only the cutting of two qubit gates is supported." ) # If the wire-cut limit would be exceeded, return the empty list - if not state.canAddWires(1): + if not state.can_add_wires(1): return list() q1 = gate.qubits[0] q2 = gate.qubits[1] - w1 = state.getWire(q1) - r1 = state.findQubitRoot(q1) - r2 = state.findQubitRoot(q2) + w1 = state.get_wire(q1) + r1 = state.find_qubit_root(q1) + r2 = state.find_qubit_root(q2) if r1 == r2: return list() - if not state.canExpandSubcircuit(r2, 1, max_width): + if not state.can_expand_subcircuit(r2, 1, max_width): return list() new_state = state.copy() - rnew = new_state.newWire(q1) - new_state.mergeRoots(rnew, r2) - new_state.assertDoNotMergeRoots(r1, r2) # Because r2 < rnew + rnew = new_state.new_wire(q1) + new_state.merge_roots(rnew, r2) + new_state.assert_donot_merge_roots(r1, r2) # Because r2 < rnew new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= 4 - new_state.addAction(self, gate_spec, (1, w1, rnew)) + new_state.add_action(self, gate_spec, (1, w1, rnew)) return [new_state] - def exportCuts( + def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: - """Insert an LO wire cut into the input circuit for the specified - gate and cut arguments. - """ - - insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + """Insert an LO wire cut into the input circuit for the specified gate and cut arguments.""" + insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) ### Adds ActionCutLeftWire to the global variable disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionCutLeftWire()) +disjoint_subcircuit_actions.define_action(ActionCutLeftWire()) -def insertAllLOWireCuts( +def insert_all_lo_wire_cuts( circuit_interface: SimpleGateList, wire_map: list[Hashable], gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: - """Insert LO wire cuts into the input circuit for the specified - gate and all cut arguments. - """ + """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments.""" gate_ID = gate_spec[0] gate_ID = cast(int, gate_ID) for input_ID, wire_ID, new_wire_ID in cut_args: - circuit_interface.insertWireCut( + circuit_interface.insert_wire_cut( gate_ID, input_ID, wire_map[wire_ID], wire_map[new_wire_ID], "LO" ) class ActionCutRightWire(DisjointSearchAction): + """Cut the right (second input) wire of a two-qubit gate.""" - """Action class that implements the action of - cutting the right (second) wire of a two-qubit gate""" - - def getName(self) -> str: - """Return the look-up name of ActionCutRightWire.""" - + def get_name(self) -> str: + """Return the look-up name of :class:`ActionCutRightWire`.""" return "CutRightWire" - def getGroupNames(self) -> list[str]: - """Return the group name of ActionCutRightWire.""" - + def get_group_names(self) -> list[str]: + """Return the group name of :class:`ActionCutRightWire`.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive( + def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: list[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying - ActionCutRightWire to state given the gate_spec. - """ - + """Return the new state that results from applying :class:`ActionCutRightWire` to state given the gate_spec.""" gate = gate_spec[1] gate = cast(CircuitElement, gate) - # Cutting of multi-qubit gates is not supported in this version. + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "At present, only the cutting of two qubit gates is supported." + "In this release, only the cutting of two qubit gates is supported." ) # If the wire-cut limit would be exceeded, return the empty list - if not state.canAddWires(1): + if not state.can_add_wires(1): return list() q1 = gate.qubits[0] q2 = gate.qubits[1] - w2 = state.getWire(q2) - r1 = state.findQubitRoot(q1) - r2 = state.findQubitRoot(q2) + w2 = state.get_wire(q2) + r1 = state.find_qubit_root(q1) + r2 = state.find_qubit_root(q2) if r1 == r2: return list() - if not state.canExpandSubcircuit(r1, 1, max_width): + if not state.can_expand_subcircuit(r1, 1, max_width): return list() new_state = state.copy() - rnew = new_state.newWire(q2) - new_state.mergeRoots(r1, rnew) - new_state.assertDoNotMergeRoots(r1, r2) # Because r1 < rnew + rnew = new_state.new_wire(q2) + new_state.merge_roots(r1, rnew) + new_state.assert_donot_merge_roots(r1, r2) # Because r1 < rnew new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB *= 4 - new_state.addAction(self, gate_spec, (2, w2, rnew)) + new_state.add_action(self, gate_spec, (2, w2, rnew)) return [new_state] - def exportCuts( + def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: # pragma: no cover - """Insert an LO wire cut into the input circuit for the specified - gate and cut arguments. - """ - - insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + """Insert an LO wire cut into the input circuit for the specified gate and cut arguments.""" + insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) ### Adds ActionCutRightWire to the global variable disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionCutRightWire()) +disjoint_subcircuit_actions.define_action(ActionCutRightWire()) class ActionCutBothWires(DisjointSearchAction): + """Cut both input wires of a two-qubit gate.""" - """Action class that implements the action of - cutting both wires of a two-qubit gate""" - - def getName(self) -> str: - """Return the look-up name of ActionCutBothWires.""" - + def get_name(self) -> str: + """Return the look-up name of :class:`ActionCutBothWires`.""" return "CutBothWires" - def getGroupNames(self) -> list[str]: - """Return the group name of ActionCutBothWires.""" - + def get_group_names(self) -> list[str]: + """Return the group name of :class:`ActionCutBothWires`.""" return ["WireCut", "TwoQubitGates"] - def nextStatePrimitive( + def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: list[int | CircuitElement | None | list], max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying - ActionCutBothWires to state given the gate_spec. - """ + """Return the new state that results from applying :class:`ActionCutBothWires` to state given the gate_spec.""" gate = gate_spec[1] gate = cast(CircuitElement, gate) - # Cutting of multi-qubit gates is not supported in this version. + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "At present, only the cutting of two qubit gates is supported." + "In this release, only the cutting of two qubit gates is supported." ) # If the wire-cut limit would be exceeded, return the empty list - if not state.canAddWires(2): + if not state.can_add_wires(2): return list() # If the maximum width is less than two, return the empty list @@ -450,18 +400,18 @@ def nextStatePrimitive( q1 = gate.qubits[0] q2 = gate.qubits[1] - w1 = state.getWire(q1) - w2 = state.getWire(q2) - r1 = state.findQubitRoot(q1) - r2 = state.findQubitRoot(q2) + w1 = state.get_wire(q1) + w2 = state.get_wire(q2) + r1 = state.find_qubit_root(q1) + r2 = state.find_qubit_root(q2) new_state = state.copy() - rnew_1 = new_state.newWire(q1) - rnew_2 = new_state.newWire(q2) - new_state.mergeRoots(rnew_1, rnew_2) - new_state.assertDoNotMergeRoots(r1, rnew_1) # Because r1 < rnew_1 - new_state.assertDoNotMergeRoots(r2, rnew_2) # Because r2 < rnew_2 + rnew_1 = new_state.new_wire(q1) + rnew_2 = new_state.new_wire(q2) + new_state.merge_roots(rnew_1, rnew_2) + new_state.assert_donot_merge_roots(r1, rnew_1) # Because r1 < rnew_1 + new_state.assert_donot_merge_roots(r2, rnew_2) # Because r2 < rnew_2 new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.gamma_UB = cast(float, new_state.gamma_UB) @@ -469,23 +419,20 @@ def nextStatePrimitive( new_state.bell_pairs.append((r2, rnew_2)) new_state.gamma_UB *= 16 - new_state.addAction(self, gate_spec, (1, w1, rnew_1), (2, w2, rnew_2)) + new_state.add_action(self, gate_spec, (1, w1, rnew_1), (2, w2, rnew_2)) return [new_state] - def exportCuts( + def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], gate_spec: list[int | CircuitElement | None | list], cut_args, ) -> None: # pragma: no cover - """Insert LO wire cuts into the input circuit for the specified - gate and cut arguments. - """ - - insertAllLOWireCuts(circuit_interface, wire_map, gate_spec, cut_args) + """Insert LO wire cuts into the input circuit for the specified gate and cut arguments.""" + insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) ### Adds ActionCutBothWires to the global variable disjoint_subcircuit_actions -disjoint_subcircuit_actions.defineAction(ActionCutBothWires()) +disjoint_subcircuit_actions.define_action(ActionCutBothWires()) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 0f0299df5..184f1f5bd 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -25,11 +25,7 @@ class DisjointSubcircuitsState: - - """Class for representing search-space states when cutting - circuits to construct disjoint subcircuits. Only minimally - sufficient information is stored in order to minimize the - memory footprint. + """Represent search-space states when cutting circuits to construct disjoint subcircuits. Each wire cut introduces a new wire. A mapping from qubit IDs in QASM-like statements to wire IDs is therefore created @@ -40,7 +36,6 @@ class DisjointSubcircuitsState: target quantum devices. Member Variables: - wiremap: an int Numpy array that provides the mapping from qubit IDs to wire IDs. @@ -92,10 +87,7 @@ class DisjointSubcircuitsState: """ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = None): - """An instance of :class:`DisjointSubcircuitsState` must be initialized with - a specification of the number of qubits in the circuit and the - maximum number of wire cuts that can be performed.""" - + """Initialize an instance of :class:`DisjointSubcircuitsState` with the specified configuration variables.""" if not ( num_qubits is None or (isinstance(num_qubits, int) and num_qubits >= 0) ): @@ -145,6 +137,7 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No @no_type_check def __copy__(self) -> DisjointSubcircuitsState: + """Make shallow copy.""" new_state = DisjointSubcircuitsState() new_state.wiremap = self.wiremap.copy() @@ -166,14 +159,13 @@ def __copy__(self) -> DisjointSubcircuitsState: def copy(self) -> DisjointSubcircuitsState: """Make shallow copy.""" - return copy.copy(self) def cut_actions_sublist(self) -> list[list | dict]: - """Create a formatted list containing the actions carried out on an instance - of :class:`DisjointSubcircuitState` along with the locations of these actions - which are specified in terms of the associated gates and wires.""" + """Create a formatted list containing the actions carried out on an instance of :class:`DisjointSubcircuitState`. + Also include the locations of these actions which are specified in terms of the associated gates and wires. + """ self.actions = cast(list, self.actions) cut_actions = print_actions_list(self.actions) @@ -206,8 +198,7 @@ def cut_actions_sublist(self) -> list[list | dict]: return self.cut_actions_list def print(self, simple: bool = False) -> None: # pragma: no cover - """Print the various properties of a DisjointSubcircuitState.""" - + """Print the various properties of a :class:`DisjointSubcircuitState`.""" cut_actions_list = self.cut_actions_sublist() self.actions = cast(list, self.actions) if simple: @@ -219,85 +210,65 @@ def print(self, simple: bool = False) -> None: # pragma: no cover print("width", self.width) print("bell_pairs", self.bell_pairs) print("gamma_LB", self.gamma_LB) - print("lowerBound", self.lowerBoundGamma()) + print("lowerBound", self.lower_bound_gamma()) print("gamma_UB", self.gamma_UB) print("no_merge", self.no_merge) print("actions", print_actions_list(self.actions)) print("level", self.level) - def getNumQubits(self) -> int: + def get_num_qubits(self) -> int: """Return the number of qubits in the circuit.""" self.wiremap = cast(NDArray[np.int_], self.wiremap) return self.wiremap.shape[0] - def getMaxWidth(self) -> int: + def get_max_width(self) -> int: """Return the maximum width across subcircuits.""" self.width = cast(NDArray[np.int_], self.width) return int(np.amax(self.width)) - def getSubCircuitIndices(self) -> list[int]: - """Return a list of root indices for the subcircuits in - the current cut circuit. - """ + def get_sub_circuit_indices(self) -> list[int]: + """Return a list of root indices for the subcircuits in the current cut circuit.""" self.uptree = cast(NDArray[np.int_], self.uptree) self.num_wires = cast(int, self.num_wires) return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] - def getWireRootMapping(self) -> list[int]: - """Return a list of root wires for each wire in - the current cut circuit. - """ + def get_wire_root_mapping(self) -> list[int]: + """Return a list of root wires for each wire in the current cut circuit.""" self.num_wires = cast(int, self.num_wires) - return [self.findWireRoot(i) for i in range(self.num_wires)] + return [self.find_wire_root(i) for i in range(self.num_wires)] - def findRootBellPair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: - """Find the root wires for a Bell pair (represented as a pair - of wires) and return a sorted tuple representing the Bell pair. - """ - - r0 = self.findWireRoot(bell_pair[0]) - r1 = self.findWireRoot(bell_pair[1]) + def find_root_bell_pair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: + """Find the root wires for a Bell pair (represented as a pair of wires) and return a sorted tuple representing the Bell pair.""" + r0 = self.find_wire_root(bell_pair[0]) + r1 = self.find_wire_root(bell_pair[1]) return (r0, r1) if (r0 < r1) else (r1, r0) - def lowerBoundGamma(self) -> float: - """Calculate a lower bound for gamma using the current - counts for the different types of circuit cuts. - """ - + def lower_bound_gamma(self) -> float: + """Calculate a lower bound for gamma using the current counts for the different types of circuit cuts.""" self.bell_pairs = cast(list, self.bell_pairs) - root_bell_pairs = map(lambda x: self.findRootBellPair(x), self.bell_pairs) + root_bell_pairs = map(lambda x: self.find_root_bell_pair(x), self.bell_pairs) self.gamma_LB = cast(float, self.gamma_LB) - return self.gamma_LB * calcRootBellPairsGamma(root_bell_pairs) - - def upperBoundGamma(self) -> float: - """Calculate an upper bound for gamma using the current - counts for the different types of circuit cuts. - """ + return self.gamma_LB * calc_root_bell_pairs_gamma(root_bell_pairs) + def upper_bound_gamma(self) -> float: + """Calculate an upper bound for gamma using the current counts for the different types of circuit cuts.""" self.gamma_UB = cast(float, self.gamma_UB) return self.gamma_UB - def canAddWires(self, num_wires: int) -> bool: - """Return True if an additional num_wires can be cut - without exceeding the maximum allowed number of wire cuts. - """ - + def can_add_wires(self, num_wires: int) -> bool: + """Return True if an additional num_wires can be cut without exceeding the maximum allowed number of wire cuts.""" self.num_wires = cast(int, self.num_wires) self.uptree = cast(NDArray[np.int_], self.uptree) return self.num_wires + num_wires <= self.uptree.shape[0] - def canExpandSubcircuit(self, root: int, num_wires: int, max_width: int) -> bool: - """Return True if num_wires can be added to subcircuit root - without exceeding the maximum allowed number of qubits. - """ + def can_expand_subcircuit(self, root: int, num_wires: int, max_width: int) -> bool: + """Return True if num_wires can be added to subcircuit root without exceeding the maximum allowed number of qubits.""" self.width = cast(NDArray[np.int_], self.width) return self.width[root] + num_wires <= max_width - def newWire(self, qubit: Hashable) -> int: - """Cut the wire associated with qubit and return - the ID of the new wire now associated with qubit. - """ + def new_wire(self, qubit: Hashable) -> int: + """Cut the wire associated with qubit and return the ID of the new wire now associated with qubit.""" self.num_wires = cast(int, self.num_wires) self.uptree = cast(NDArray[np.int_], self.uptree) assert self.num_wires < self.uptree.shape[0], ( @@ -311,18 +282,14 @@ def newWire(self, qubit: Hashable) -> int: qubit = cast(int, qubit) return self.wiremap[qubit] - def getWire(self, qubit: Hashable) -> int: + def get_wire(self, qubit: Hashable) -> int: """Return the ID of the wire currently associated with qubit.""" - self.wiremap = cast(NDArray[np.int_], self.wiremap) qubit = cast(int, qubit) return self.wiremap[qubit] - def findWireRoot(self, wire: int) -> int: - """Return the ID of the root wire in the subcircuit - that contains wire and collapse the path to the root. - """ - + def find_wire_root(self, wire: int) -> int: + """Return the ID of the root wire in the subcircuit that contains wire and collapse the path to the root.""" # Find the root wire in the subcircuit root = wire self.uptree = cast(NDArray[np.int_], self.uptree) @@ -337,18 +304,14 @@ def findWireRoot(self, wire: int) -> int: return root - def findQubitRoot(self, qubit: Hashable) -> int: - """Return the ID of the root wire in the subcircuit currently - associated with qubit and collapse the path to the root. - """ + def find_qubit_root(self, qubit: Hashable) -> int: + """Return the ID of the root wire in the subcircuit currently associated with qubit and collapse the path to the root.""" self.wiremap = cast(NDArray[np.int_], self.wiremap) qubit = cast(int, qubit) - return self.findWireRoot(self.wiremap[qubit]) + return self.find_wire_root(self.wiremap[qubit]) - def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: - """Return True if the subcircuits represented by - root wire IDs root_1 and root_2 should not be merged. - """ + def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: + """Return True if the subcircuits represented by root wire IDs root_1 and root_2 should not be merged.""" self.uptree = cast(NDArray[np.int_], self.uptree) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( "Arguments must be roots: " @@ -358,8 +321,8 @@ def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: - r1 = self.findWireRoot(clause[0]) - r2 = self.findWireRoot(clause[1]) + r1 = self.find_wire_root(clause[0]) + r2 = self.find_wire_root(clause[1]) assert r1 != r2, "Do-Not-Merge clauses must not be identical" @@ -368,36 +331,28 @@ def checkDoNotMergeRoots(self, root_1: int, root_2: int) -> bool: return False - def verifyMergeConstraints(self) -> bool: + def verify_merge_constraints(self) -> bool: """Return True if all merge constraints are satisfied.""" - self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: - r1 = self.findWireRoot(clause[0]) - r2 = self.findWireRoot(clause[1]) + r1 = self.find_wire_root(clause[0]) + r2 = self.find_wire_root(clause[1]) if r1 == r2: return False return True - def assertDoNotMergeRoots(self, wire_1: int, wire_2: int) -> None: - """Add a constraint that the subcircuits associated - with wires IDs wire_1 and wire_2 should not be merged. - """ - - assert self.findWireRoot(wire_1) != self.findWireRoot( + def assert_donot_merge_roots(self, wire_1: int, wire_2: int) -> None: + """Add a constraint that the subcircuits associated with wires IDs wire_1 and wire_2 should not be merged.""" + assert self.find_wire_root(wire_1) != self.find_wire_root( wire_2 ), f"{wire_1} cannot be the same subcircuit as {wire_2}" assert isinstance(self.no_merge, list) self.no_merge.append((wire_1, wire_2)) - def mergeRoots(self, root_1: int, root_2: int) -> None: - """Merge the subcircuits associated with root wire IDs root_1 - and root_2, and update the statistics (i.e., width) - associated with the newly merged subcircuit. - """ - + def merge_roots(self, root_1: int, root_2: int) -> None: + """Merge the subcircuits associated with root wire IDs root_1 and root_2 update the statistics (i.e., width) associated with the newly merged subcircuit.""" self.uptree = cast(NDArray[np.int_], self.uptree) self.width = cast(NDArray[np.int_], self.width) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( @@ -413,39 +368,30 @@ def mergeRoots(self, root_1: int, root_2: int) -> None: self.uptree[other_root] = merged_root self.width[merged_root] += self.width[other_root] - def addAction( + def add_action( self, action_obj: DisjointSearchAction, gate_spec: list[int | CircuitElement | None | list], *args, ) -> None: - """Append the specified action to the list of search-space - actions that have been performed. - """ - - if action_obj.getName() is not None: + """Append the specified action to the list of search-space actions that have been performed.""" + if action_obj.get_name() is not None: self.actions = cast(list, self.actions) self.actions.append([action_obj, gate_spec, args]) - def getSearchLevel(self) -> int: + def get_search_level(self) -> int: """Return the search level.""" self.level = cast(int, self.level) return self.level - def setNextLevel(self, state: DisjointSubcircuitsState) -> None: - """Set the search level of self to one plus the search - level of the input state. - """ - + def set_next_level(self, state: DisjointSubcircuitsState) -> None: + """Set the search level of self to one plus the search level of the input state.""" self.level = cast(int, self.level) state.level = cast(int, state.level) self.level = state.level + 1 - def exportCuts(self, circuit_interface: SimpleGateList): - """Export LO cuts into the input circuit_interface for each of - the cutting decisions made. - """ - + def export_cuts(self, circuit_interface: SimpleGateList): + """Export LO cuts into the input circuit_interface for each of the cutting decisions made.""" # This wire map assumes no reuse of measured qubits that # result from wire cuts assert self.num_wires is not None @@ -453,29 +399,28 @@ def exportCuts(self, circuit_interface: SimpleGateList): assert self.actions is not None for action, gate_spec, cut_args in self.actions: - action.exportCuts(circuit_interface, wire_map, gate_spec, cut_args) + action.export_cuts(circuit_interface, wire_map, gate_spec, cut_args) - root_list = self.getSubCircuitIndices() - wires_to_roots = self.getWireRootMapping() + root_list = self.get_sub_circuit_indices() + wires_to_roots = self.get_wire_root_mapping() subcircuits = [ list({wire_map[w] for w, r in enumerate(wires_to_roots) if r == root}) for root in root_list ] - circuit_interface.defineSubcircuits(subcircuits) + circuit_interface.define_subcircuits(subcircuits) + +def calc_root_bell_pairs_gamma(root_bell_pairs: Iterable[Hashable]) -> float: + """Calculate the minimum-achievable LOCC gamma for circuit cuts that utilize virtual Bell pairs. -def calcRootBellPairsGamma(root_bell_pairs: Iterable[Hashable]) -> float: - """Calculate the minimum-achievable LOCC gamma for circuit - cuts that utilize virtual Bell pairs. The input can be an iterable - over hashable identifiers that represent Bell pairs across disconnected - subcircuits in a cut circuit. There must be a one-to-one mapping between + The input can be an iterable over hashable identifiers that represent Bell pairs across + disconnected subcircuits in a cut circuit. There must be a one-to-one mapping between identifiers and pairs of subcircuits. Repeated identifiers are interpreted as mutiple Bell pairs across the same pair of subcircuits, and the counts of such repeats are used to calculate gamma. """ - gamma = 1.0 for n in Counter(root_bell_pairs).values(): gamma *= 2 ** (n + 1) - 1 @@ -486,7 +431,5 @@ def calcRootBellPairsGamma(root_bell_pairs: Iterable[Hashable]) -> float: def print_actions_list( action_list: list[list], ) -> list[list[str | list | tuple]]: - """Return a list specifying objects that represent cutting actions assoicated with an - instance of :class:`DisjointSubcircuitsState`. - """ - return [[x[0].getName()] + x[1:] for x in action_list] + """Return a list specifying objects that represent cutting actions assoicated with an instance of :class:`DisjointSubcircuitsState`.""" + return [[x[0].get_name()] + x[1:] for x in action_list] diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index d8b267aae..4b754ea36 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -14,10 +14,10 @@ from .cut_optimization import CutOptimization from .cut_optimization import disjoint_subcircuit_actions -from .cut_optimization import CutOptimizationNextStateFunc -from .cut_optimization import CutOptimizationGoalStateFunc -from .cut_optimization import CutOptimizationMinCostBoundFunc -from .cut_optimization import CutOptimizationUpperBoundCostFunc +from .cut_optimization import cut_optimization_next_state_func +from .cut_optimization import cut_optimization_goal_state_func +from .cut_optimization import cut_optimization_min_cost_bound_func +from .cut_optimization import cut_optimization_upper_bound_cost_func from .search_space_generator import SearchFunctions, SearchSpaceGenerator import numpy as np @@ -30,26 +30,24 @@ ### Functions for generating the cut optimization search space cut_optimization_search_funcs = SearchFunctions( - cost_func=CutOptimizationUpperBoundCostFunc, # Valid choice only for LO cuts. - upperbound_cost_func=CutOptimizationUpperBoundCostFunc, - next_state_func=CutOptimizationNextStateFunc, - goal_state_func=CutOptimizationGoalStateFunc, - mincost_bound_func=CutOptimizationMinCostBoundFunc, + cost_func=cut_optimization_upper_bound_cost_func, # Valid choice only for LO cuts. + upperbound_cost_func=cut_optimization_upper_bound_cost_func, + next_state_func=cut_optimization_next_state_func, + goal_state_func=cut_optimization_goal_state_func, + mincost_bound_func=cut_optimization_min_cost_bound_func, ) class LOCutsOptimizer: - - """Wrapper class for optimizing circuit cuts for the case in which - only LO quasiprobability decompositions are employed. + """Optimize circuit cuts for the case in which only LO quasiprobability decompositions are employed. The search_engine_config dictionary that configures the optimization algorithms must be specified in the constructor. For flexibility, the circuit_interface, optimization_settings, and device_constraints can - be specified either in the constructor or in the optimize() method. In + be specified either in the constructor or in the :func:`optimize` method. In the latter case, the values provided overwrite the previous values. - The circuit_interface object that is passed to the optimize() + The circuit_interface object that is passed to the :func:`optimize` method is updated to reflect the optimized circuit cuts that were identified. @@ -86,11 +84,11 @@ def __init__( ) }, ): + """Initialize :class:`LOCutsOptimizer with the specified configuration variables.""" self.circuit_interface = circuit_interface self.optimization_settings = optimization_settings self.device_constraints = device_constraints self.search_engine_config = search_engine_config - self.cut_optimization = None self.best_result = None @@ -100,10 +98,9 @@ def optimize( optimization_settings: OptimizationSettings | None = None, device_constraints: DeviceConstraints | None = None, ) -> DisjointSubcircuitsState | None: - """Method to optimize the cutting of a circuit. + """Optimize the cutting of a circuit. Input Arguments: - circuit_interface: defines the circuit to be cut. This object is then updated with the optimized cuts that were identified. @@ -115,13 +112,11 @@ def optimize( the target quantum hardware. Returns: - The lowest-cost instance of :class:`DisjointSubcircuitsState` identified in the search, or None if no solution could be found. In the case of the former, the circuit_interface object is also updated as a side effect to incorporate the cuts found. """ - if circuit_interface is not None: self.circuit_interface = circuit_interface @@ -149,7 +144,7 @@ def optimize( out_1 = list() while True: - state, cost = self.cut_optimization.optimizationPass() + state, cost = self.cut_optimization.optimization_pass() if state is None: break out_1.append((cost, state)) @@ -158,35 +153,31 @@ def optimize( if min_cost is not None: self.best_result = min_cost[-1] - self.best_result.exportCuts(self.circuit_interface) + self.best_result.export_cuts(self.circuit_interface) else: self.best_result = None return self.best_result - def getResults(self) -> DisjointSubcircuitsState | None: + def get_results(self) -> DisjointSubcircuitsState | None: """Return the optimization results.""" - return self.best_result - def getStats(self, penultimate=False) -> dict[str, NDArray[np.int_]]: + def get_stats(self, penultimate=False) -> dict[str, NDArray[np.int_]]: """Return a dictionary containing optimization results.""" - return { - "CutOptimization": self.cut_optimization.getStats(penultimate=penultimate) + "CutOptimization": self.cut_optimization.get_stats(penultimate=penultimate) } - def minimumReached(self) -> bool: - """Return a Boolean flag indicating whether the global - minimum was reached. - """ - - return self.cut_optimization.minimumReached() + def minimum_reached(self) -> bool: + """Return a Boolean flag indicating whether the global minimum was reached.""" + return self.cut_optimization.minimum_reached() -def printStateList( +def print_state_list( state_list: list[DisjointSubcircuitsState], ) -> None: # pragma: no cover + """Call the :func:`print` method defined for a :class:`DisjointSubcircuitsState` instance.""" for x in state_list: print() x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index f5345f78e..0fb694488 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -19,10 +19,9 @@ @dataclass class OptimizationSettings: - """Class for specifying parameters that control the optimization. + """Specify the parameters that control the optimization. Member Variables: - max_gamma: a constraint on the maximum value of gamma that a solution to the optimization is allowed to have to be considered feasible. @@ -57,7 +56,6 @@ class OptimizationSettings: flags have been incorporated with an eye towards future releases. Raises: - ValueError: max_gamma must be a positive definite integer. ValueError: max_backjumps must be a positive semi-definite integer. """ @@ -71,6 +69,7 @@ class OptimizationSettings: engine_selections: dict[str, str] | None = None def __post_init__(self): + """Post-init method for the data class.""" if self.max_gamma < 1: raise ValueError("max_gamma must be a positive definite integer.") if self.max_backjumps < 0: @@ -86,48 +85,51 @@ def __post_init__(self): if self.engine_selections is None: self.engine_selections = {"CutOptimization": "BestFirst"} - def getMaxGamma(self) -> int: + def get_max_gamma(self) -> int: """Return the max gamma.""" return self.max_gamma - def getMaxBackJumps(self) -> int: + def get_max_backjumps(self) -> int: """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def getRandSeed(self) -> int | None: - """Return the random seed.""" + def get_rand_seed(self) -> int | None: + """Return the seed used to generate the pseudorandom numbers used in the optimizaton.""" return self.rand_seed - def getEngineSelection(self, stage_of_optimization: str) -> str: + def get_engine_selection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" self.engine_selections = cast(dict, self.engine_selections) return self.engine_selections[stage_of_optimization] - def setEngineSelection(self, stage_of_optimization: str, engine_name: str) -> None: + def set_engine_selection( + self, stage_of_optimization: str, engine_name: str + ) -> None: """Set the name of the search engine to employ.""" self.engine_selections = cast(dict, self.engine_selections) self.engine_selections[stage_of_optimization] = engine_name - def setGateCutTypes(self) -> None: + def set_gate_cut_types(self) -> None: """Select which gate-cut types to include in the optimization. - The default is to only include LO gate cuts. + + The default is to only include LO gate cuts, which are the + only cut types supported in this release. """ self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas - def setWireCutTypes(self) -> None: + def set_wire_cut_types(self) -> None: """Select which wire-cut types to include in the optimization. - The default is to only include LO wire cuts. - """ + The default is to only include LO wire cuts, which are the + only cut types supported in this release. + """ self.wire_cut_LO = self.LO self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas - def getCutSearchGroups(self) -> list[None | str]: - """Return a list of search-action groups to include in the - optimization for cutting circuits into disjoint subcircuits. - """ + def get_cut_search_groups(self) -> list[None | str]: + """Return a list of search-action groups to include in the optimization.""" out: list out = [None] @@ -147,4 +149,5 @@ def getCutSearchGroups(self) -> list[None | str]: def from_dict( cls, options: dict # dict[str, None | int | bool | dict[str, str]] ) -> OptimizationSettings: + """Return an instance of :class:`OptimizationSettings` initialized with the parameters passed in options.""" return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 93274d938..58abd61da 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -18,19 +18,15 @@ @dataclass class DeviceConstraints: - """Class for specifying the characteristics of the target quantum - processor that the optimizer must respect in order for the resulting - subcircuits to be executable on the target processor. + """Specify the characteristics of the target quantum processor that the optimizer must respect. Member Variables: - qubits_per_QPU: The number of qubits that are available on the individual QPUs that make up the quantum processor. num_QPUs: The number of QPUs in the target quantum processor. Raises: - ValueError: qubits_per_QPU must be a positive integer. ValueError: num_QPUs must be a positive integer. """ @@ -39,15 +35,17 @@ class DeviceConstraints: num_QPUs: int def __post_init__(self): + """Post-init method for data class.""" if self.qubits_per_QPU < 1 or self.num_QPUs < 1: raise ValueError( "qubits_per_QPU and num_QPUs must be positive definite integers." ) - def getQPUWidth(self) -> int: + def get_qpu_width(self) -> int: """Return the number of qubits supported on each individual QPU.""" return self.qubits_per_QPU @classmethod def from_dict(cls, options: dict[str, int]) -> DeviceConstraints: + """Return an instance of :class:`DeviceConstraints` initialized with the parameters passed in options.""" return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index cdc34ed87..9b51ea10c 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -24,10 +24,7 @@ class ActionNames: - - """Class that maps action names to individual action objects - and group names and to lists of action objects, where the - action objects are used to generate a search space. + """Map action names to individual action objects and group names to lists of action objects that are used to generate a search space. Member Variables: @@ -40,39 +37,34 @@ class ActionNames: group_dict: dict[str, list[DisjointSearchAction]] def __init__(self): + """Initialize :class:`ActionNames` with the specified configuration variables.""" self.action_dict = dict() self.group_dict = dict() def copy( self, list_of_groups: list[DisjointSearchAction | None] | None = None ) -> ActionNames: - """Return a copy of :class:`ActionNames` that contains only those actions - whose group affiliations intersect with list_of_groups. + """Return a copy of :class:`ActionNames` containing only those actions whose group affiliations intersect with list_of_groups. + The default is to return a copy containing all actions. """ - - action_list = getActionSubset(list(self.action_dict.values()), list_of_groups) - + action_list = get_action_subset(list(self.action_dict.values()), list_of_groups) new_container = ActionNames() assert action_list is not None for action in action_list: - new_container.defineAction(action) + new_container.define_action(action) return new_container - def defineAction(self, action_object: DisjointSearchAction) -> None: - """Insert the specified action object into the look-up - dictionaries using the name of the action and its group - names. - """ - + def define_action(self, action_object: DisjointSearchAction) -> None: + """Insert the specified action object into the look-up dictionaries using the name of the action and its group names.""" assert ( - action_object.getName() not in self.action_dict - ), f"Action {action_object.getName()} is already defined" + action_object.get_name() not in self.action_dict + ), f"Action {action_object.get_name()} is already defined" - self.action_dict[action_object.getName()] = action_object + self.action_dict[action_object.get_name()] = action_object - group_name = action_object.getGroupNames() + group_name = action_object.get_group_names() if isinstance(group_name, list) or isinstance(group_name, tuple): for name in group_name: @@ -84,33 +76,30 @@ def defineAction(self, action_object: DisjointSearchAction) -> None: self.group_dict[group_name] = list() self.group_dict[group_name].append(action_object) - def getAction(self, action_name: str) -> DisjointSearchAction | None: + def get_action(self, action_name: str) -> DisjointSearchAction | None: """Return the action object associated with the specified name. + None is returned if there is no associated action object. """ - if action_name in self.action_dict: return self.action_dict[action_name] return None - def getGroup(self, group_name: str) -> list | None: + def get_group(self, group_name: str) -> list | None: """Return the list of action objects associated with the group_name. + None is returned if there are no associated action objects. """ - if group_name in self.group_dict: return self.group_dict[group_name] return None -def getActionSubset( +def get_action_subset( action_list: list[DisjointSearchAction] | None, action_groups: list[DisjointSearchAction | None] | None, ) -> list[DisjointSearchAction] | None: - """Return the subset of actions in action_list whose group affiliations - intersect with action_groups. - """ - + """Return the subset of actions in action_list whose group affiliations intersect with action_groups.""" if action_groups is None: return action_list @@ -121,15 +110,15 @@ def getActionSubset( assert action_list is not None return [ - a for a in action_list if len(groups.intersection(set(a.getGroupNames()))) > 0 + a for a in action_list if len(groups.intersection(set(a.get_group_names()))) > 0 ] @dataclass class SearchFunctions: + """Contain functions needed to generate and explore a search space. - """Data class for holding functions needed to generate and explore - a search space. In addition to the required input arguments, the function + In addition to the required input arguments, the function signatures are assumed to also allow additional input arguments that are needed to perform the corresponding computations. @@ -151,7 +140,7 @@ class SearchFunctions: upperbound_cost_func (lambda goal_state, *args) can either be None or a function that returns an upper bound to the optimal cost given a goal_state as input. The upper bound is used to prune next-states from the search in - subsequent calls to the optimizationPass() method of the search algorithm. + subsequent calls to the :func:`optimization_pass` method of the search algorithm. If upperbound_cost_func is None, the cost of the goal_state as determined by cost_func is used as an upper bound to the optimal cost. If the upperbound_cost_func returns None, the effect is equivalent to returning @@ -193,9 +182,7 @@ class SearchFunctions: @dataclass class SearchSpaceGenerator: - - """Data class for holding both the functions and the - associated actions needed to generate and explore a search space. + """Contain both the functions and the associated actions needed to generate and explore a search space. Member Variables: diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index a23577c82..d388e4730 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -103,7 +103,7 @@ "source": [ "settings = OptimizationSettings(rand_seed=12345)\n", "\n", - "settings.setEngineSelection(\"CutOptimization\", \"BestFirst\")\n", + "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", "\n", "qubits_per_QPU = 4\n", @@ -124,9 +124,9 @@ "\n", " print(\n", " \" Gamma =\",\n", - " None if (out is None) else out.upperBoundGamma(),\n", + " None if (out is None) else out.upper_bound_gamma(),\n", " \", Min_gamma_reached =\",\n", - " op.minimumReached(),\n", + " op.minimum_reached(),\n", " )\n", " if out is not None:\n", " out.print(simple=True)\n", @@ -135,7 +135,7 @@ "\n", " print(\n", " \"Subcircuits:\",\n", - " interface.exportSubcircuitsAsString(name_mapping=\"default\"),\n", + " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", " \"\\n\",\n", " )" ] @@ -255,7 +255,7 @@ "\n", "settings = OptimizationSettings(rand_seed=12345)\n", "\n", - "settings.setEngineSelection(\"CutOptimization\", \"BestFirst\")\n", + "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", "qubits_per_QPU = 7\n", "num_QPUs = 2\n", @@ -275,9 +275,9 @@ "\n", " print(\n", " \" Gamma =\",\n", - " None if (out is None) else out.upperBoundGamma(),\n", + " None if (out is None) else out.upper_bound_gamma(),\n", " \", Min_gamma_reached =\",\n", - " op.minimumReached(),\n", + " op.minimum_reached(),\n", " )\n", " if out is not None:\n", " out.print(simple=True)\n", @@ -286,7 +286,7 @@ "\n", " print(\n", " \"Subcircuits:\",\n", - " interface.exportSubcircuitsAsString(name_mapping=\"default\"),\n", + " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", " \"\\n\",\n", " )" ] diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 256627eca..686bf2423 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -19,7 +19,7 @@ @fixture -def testCircuit(): +def test_circuit(): circuit = [ CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), CircuitElement(name="cx", params=[], qubits=[0, 2], gamma=3), @@ -53,23 +53,23 @@ def testCircuit(): return interface -def test_BestFirstSearch(testCircuit: SimpleGateList): +def test_best_first_search(test_circuit: SimpleGateList): settings = OptimizationSettings(rand_seed=12345) - settings.setEngineSelection("CutOptimization", "BestFirst") + settings.set_engine_selection("CutOptimization", "BestFirst") constraint_obj = DeviceConstraints(qubits_per_QPU=4, num_QPUs=2) - op = CutOptimization(testCircuit, settings, constraint_obj) + op = CutOptimization(test_circuit, settings, constraint_obj) - out, _ = op.optimizationPass() + out, _ = op.optimization_pass() - assert op.search_engine.getStats(penultimate=True) is not None - assert op.search_engine.getStats() is not None - assert op.getUpperBoundCost() == (27, inf) - assert op.minimumReached() is False + assert op.search_engine.get_stats(penultimate=True) is not None + assert op.search_engine.get_stats() is not None + assert op.get_upperbound_cost() == (27, inf) + assert op.minimum_reached() is False assert out is not None - assert (out.lowerBoundGamma(), out.gamma_UB, out.getMaxWidth()) == ( + assert (out.lower_bound_gamma(), out.gamma_UB, out.get_max_width()) == ( 27, 27, 4, @@ -92,10 +92,10 @@ def test_BestFirstSearch(testCircuit: SimpleGateList): ], ] - out, _ = op.optimizationPass() + out, _ = op.optimization_pass() - assert op.search_engine.getStats(penultimate=True) is not None - assert op.search_engine.getStats() is not None - assert op.getUpperBoundCost() == (27, inf) - assert op.minimumReached() is True + assert op.search_engine.get_stats(penultimate=True) is not None + assert op.search_engine.get_stats() is not None + assert op.get_upperbound_cost() == (27, inf) + assert op.minimum_reached() is True assert out is None diff --git a/test/cutting/cut_finding/test_cco_utils.py b/test/cutting/cut_finding/test_cco_utils.py index 5e3e9c370..da00f06a4 100644 --- a/test/cutting/cut_finding/test_cco_utils.py +++ b/test/cutting/cut_finding/test_cco_utils.py @@ -29,7 +29,7 @@ # test circuit 3 @fixture -def InternalTestCircuit(): +def internal_test_circuit(): circuit = [ CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), @@ -40,8 +40,8 @@ def InternalTestCircuit(): CircuitElement(name="rx", params=[0.4], qubits=[0], gamma=None), ] interface = SimpleGateList(circuit) - interface.insertGateCut(2, "LO") - interface.defineSubcircuits([[0, 1], [2, 3]]) + interface.insert_gate_cut(2, "LO") + interface.define_subcircuits([[0, 1], [2, 3]]) return interface @@ -86,8 +86,8 @@ def test_qc_to_cco_circuit( assert test_circuit_internal == known_output -def test_cco_to_qc_circuit(InternalTestCircuit: SimpleGateList): - qc_cut = cco_to_qc_circuit(InternalTestCircuit) +def test_cco_to_qc_circuit(internal_test_circuit: SimpleGateList): + qc_cut = cco_to_qc_circuit(internal_test_circuit) assert qc_cut.data == [ CircuitInstruction( operation=Instruction(name="cx", num_qubits=2, num_clbits=0, params=[]), diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 842fd832a..8ddeafbf9 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -6,13 +6,13 @@ ) from circuit_knitting.cutting.cut_finding.cut_optimization import ( - maxWireCutsCircuit, - maxWireCutsGamma, + max_wire_cuts_circuit, + max_wire_cuts_gamma, ) class TestCircuitInterface: - def test_CircuitConversion(self): + def test_circuit_conversion(self): """Test conversion of circuits to the internal representation used by the circuit-cutting optimizer. """ @@ -31,10 +31,10 @@ def test_CircuitConversion(self): # appears in the first gate in the list that specifies the circuit # is assigned ID 0. - assert circuit_converted.getNumQubits() == 2 - assert circuit_converted.getNumWires() == 2 + assert circuit_converted.get_num_qubits() == 2 + assert circuit_converted.get_num_wires() == 2 assert circuit_converted.qubit_names.item_dict == {"q1": 0, "q0": 1} - assert circuit_converted.getMultiQubitGates() == [ + assert circuit_converted.get_multiqubit_gates() == [ [4, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None] ] @@ -46,8 +46,8 @@ def test_CircuitConversion(self): [CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], ] - assert maxWireCutsCircuit(circuit_converted) == 2 - assert maxWireCutsGamma(7) == 2 + assert max_wire_cuts_circuit(circuit_converted) == 2 + assert max_wire_cuts_gamma(7) == 2 # Assign by hand a different qubit mapping by specifiying init_qubit_names. circuit_converted = SimpleGateList(trial_circuit, ["q0", "q1"]) @@ -60,7 +60,7 @@ def test_CircuitConversion(self): [CircuitElement(name="cx", params=[], qubits=[1, 0], gamma=3), None], ] - def test_GateCutInterface(self): + def test_gate_cut_interface(self): """Test the internal representation of LO gate cuts.""" trial_circuit = [ @@ -71,16 +71,16 @@ def test_GateCutInterface(self): CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3), ] circuit_converted = SimpleGateList(trial_circuit) - circuit_converted.insertGateCut(2, "LO") - circuit_converted.defineSubcircuits([[0, 1], [2, 3]]) + circuit_converted.insert_gate_cut(2, "LO") + circuit_converted.define_subcircuits([[0, 1], [2, 3]]) - assert list(circuit_converted.new_gate_ID_map) == [0, 1, 2, 3, 4] + assert list(circuit_converted.new_gate_id_map) == [0, 1, 2, 3, 4] assert circuit_converted.cut_type == [None, None, "LO", None, None] assert ( - circuit_converted.exportSubcircuitsAsString(name_mapping="default") + circuit_converted.export_subcircuits_as_string(name_mapping="default") == "AABB" ) - assert circuit_converted.exportCutCircuit(name_mapping="default") == [ + assert circuit_converted.export_cut_circuit(name_mapping="default") == [ trial_circuit[0], trial_circuit[1], trial_circuit[2], @@ -90,12 +90,12 @@ def test_GateCutInterface(self): # the following two methods are the same in the absence of wire cuts. assert ( - circuit_converted.exportOutputWires(name_mapping="default") - == circuit_converted.exportOutputWires(name_mapping=None) + circuit_converted.export_output_wires(name_mapping="default") + == circuit_converted.export_output_wires(name_mapping=None) == {0: 0, 1: 1, 2: 2, 3: 3} ) - def test_WireCutInterface(self): + def test_wire_cut_interface(self): """Test the internal representation of LO wire cuts.""" trial_circuit = [ @@ -108,15 +108,15 @@ def test_WireCutInterface(self): circuit_converted = SimpleGateList(trial_circuit) # cut first input wire of trial_circuit[2] and map it to wire id 4. - circuit_converted.insertWireCut(2, 1, 1, 4, "LO") + circuit_converted.insert_wire_cut(2, 1, 1, 4, "LO") assert list(circuit_converted.output_wires) == [0, 4, 2, 3] assert circuit_converted.cut_type[2] == "LO" # the missing gate 2 corresponds to a move operation - assert list(circuit_converted.new_gate_ID_map) == [0, 1, 3, 4, 5] + assert list(circuit_converted.new_gate_id_map) == [0, 1, 3, 4, 5] - assert circuit_converted.exportCutCircuit(name_mapping=None) == [ + assert circuit_converted.export_cut_circuit(name_mapping=None) == [ trial_circuit[0], trial_circuit[1], ["move", 1, ("cut", 1)], @@ -126,7 +126,7 @@ def test_WireCutInterface(self): ] # relabel wires after wire cuts according to 'None' name_mapping. - assert circuit_converted.exportOutputWires(name_mapping=None) == { + assert circuit_converted.export_output_wires(name_mapping=None) == { 0: 0, 1: ("cut", 1), 2: 2, @@ -134,14 +134,14 @@ def test_WireCutInterface(self): } # relabel wires after wire cuts according to 'default' name_mapping. - assert circuit_converted.exportOutputWires(name_mapping="default") == { + assert circuit_converted.export_output_wires(name_mapping="default") == { 0: 0, 1: 2, 2: 3, 3: 4, } - assert circuit_converted.exportCutCircuit(name_mapping="default") == [ + assert circuit_converted.export_cut_circuit(name_mapping="default") == [ CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), ["move", 1, 2], diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index b481d8cd7..170290388 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -33,7 +33,7 @@ def gate_cut_test_setup(): circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) - settings.setEngineSelection("CutOptimization", "BestFirst") + settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -51,7 +51,7 @@ def wire_cut_test_setup(): circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) - settings.setEngineSelection("CutOptimization", "BestFirst") + settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -62,7 +62,7 @@ def multiqubit_test_setup(): circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) settings = OptimizationSettings(rand_seed=12345) - settings.setEngineSelection("CutOptimization", "BestFirst") + settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -83,10 +83,10 @@ def test_no_cuts( assert print_actions_list(output.actions) == [] # no cutting. - assert interface.exportSubcircuitsAsString(name_mapping="default") == "AAAA" + assert interface.export_subcircuits_as_string(name_mapping="default") == "AAAA" -def test_GateCuts( +def test_gate_cuts( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits requires cutting. @@ -120,22 +120,22 @@ def test_GateCuts( }, ] - best_result = optimization_pass.getResults() + best_result = optimization_pass.get_results() - assert output.upperBoundGamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. + assert output.upper_bound_gamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. - assert optimization_pass.minimumReached() is True # matches optimal solution. + assert optimization_pass.minimum_reached() is True # matches optimal solution. assert ( - interface.exportSubcircuitsAsString(name_mapping="default") == "AABB" + interface.export_subcircuits_as_string(name_mapping="default") == "AABB" ) # circuit separated into 2 subcircuits. assert ( - optimization_pass.getStats()["CutOptimization"] == array([15, 46, 15, 6]) + optimization_pass.get_stats()["CutOptimization"] == array([15, 46, 15, 6]) ).all() # matches known stats. -def test_WireCuts( +def test_wire_cuts( wire_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): qubits_per_QPU = 4 @@ -164,15 +164,15 @@ def test_WireCuts( } ] - best_result = optimization_pass.getResults() + best_result = optimization_pass.get_results() - assert output.upperBoundGamma() == best_result.gamma_UB == 4 # One LO wire cut. + assert output.upper_bound_gamma() == best_result.gamma_UB == 4 # One LO wire cut. - assert optimization_pass.minimumReached() is True # matches optimal solution + assert optimization_pass.minimum_reached() is True # matches optimal solution # check if unsupported search engine is flagged. -def test_SelectSearchEngine( +def test_select_search_engine( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): qubits_per_QPU = 4 @@ -180,9 +180,9 @@ def test_SelectSearchEngine( interface, settings = gate_cut_test_setup - settings.setEngineSelection("CutOptimization", "BeamSearch") + settings.set_engine_selection("CutOptimization", "BeamSearch") - search_engine = settings.getEngineSelection("CutOptimization") + search_engine = settings.get_engine_selection("CutOptimization") constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) @@ -194,7 +194,7 @@ def test_SelectSearchEngine( # The cutting of multiqubit gates is not supported at present. -def test_MultiqubitCuts( +def test_multiqubit_cuts( multiqubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits requires cutting. @@ -215,7 +215,7 @@ def test_MultiqubitCuts( ) -def test_UpdatedCostBounds( +def test_updated_cost_bounds( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): qubits_per_QPU = 3 @@ -227,12 +227,12 @@ def test_UpdatedCostBounds( # Perform cut finding with the default cost upper bound. cut_opt = CutOptimization(interface, settings, constraint_obj) - state, _ = cut_opt.optimizationPass() + state, _ = cut_opt.optimization_pass() assert state is not None # Update and lower cost upper bound. - cut_opt.updateUpperBoundCost((2, 4)) - state, _ = cut_opt.optimizationPass() + cut_opt.update_upperbound_cost((2, 4)) + state, _ = cut_opt.optimization_pass() # Since any cut has a cost of at least 3, the returned state must be None. assert state is None diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index a8a599c34..5538f3d85 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -20,7 +20,7 @@ @fixture -def testCircuit(): +def test_circuit(): circuit = [ CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), CircuitElement(name="s", params=[], qubits=["q0"], gamma=None), @@ -30,15 +30,15 @@ def testCircuit(): interface = SimpleGateList(circuit) # initialize DisjointSubcircuitsState object. - state = DisjointSubcircuitsState(interface.getNumQubits(), 2) + state = DisjointSubcircuitsState(interface.get_num_qubits(), 2) - two_qubit_gate = interface.getMultiQubitGates()[0] + two_qubit_gate = interface.get_multiqubit_gates()[0] return interface, state, two_qubit_gate -def test_ActionApplyGate( - testCircuit: Callable[ +def test_action_apply_gate( + test_circuit: Callable[ [], tuple[ SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] @@ -47,20 +47,20 @@ def test_ActionApplyGate( ): """Test the application of a gate without any cutting actions.""" - _, state, two_qubit_gate = testCircuit + _, state, two_qubit_gate = test_circuit apply_gate = ActionApplyGate() - assert apply_gate.getName() is None - assert apply_gate.getGroupNames() == [None, "TwoQubitGates"] + assert apply_gate.get_name() is None + assert apply_gate.get_group_names() == [None, "TwoQubitGates"] - updated_state = apply_gate.nextStatePrimitive(state, two_qubit_gate, 2) + updated_state = apply_gate.next_state_primitive(state, two_qubit_gate, 2) actions_list = [] for state in updated_state: actions_list.extend(state.actions) assert actions_list == [] # no actions when the gate is simply applied. -def test_CutTwoQubitGate( - testCircuit: Callable[ +def test_cut_two_qubit_gate( + test_circuit: Callable[ [], tuple[ SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] @@ -69,12 +69,12 @@ def test_CutTwoQubitGate( ): """Test the action of cutting a two qubit gate.""" - interface, state, two_qubit_gate = testCircuit + interface, state, two_qubit_gate = test_circuit cut_gate = ActionCutTwoQubitGate() - assert cut_gate.getName() == "CutTwoQubitGate" - assert cut_gate.getGroupNames() == ["GateCut", "TwoQubitGates"] + assert cut_gate.get_name() == "CutTwoQubitGate" + assert cut_gate.get_group_names() == ["GateCut", "TwoQubitGates"] - updated_state = cut_gate.nextStatePrimitive(state, two_qubit_gate, 2) + updated_state = cut_gate.next_state_primitive(state, two_qubit_gate, 2) actions_list = [] for state in updated_state: actions_list.extend(print_actions_list(state.actions)) @@ -86,20 +86,20 @@ def test_CutTwoQubitGate( ] ] - assert cut_gate.getCostParams(two_qubit_gate) == ( + assert cut_gate.get_cost_params(two_qubit_gate) == ( 3, 0, 3, ) # reproduces the parameters for a CNOT when only LO is enabled. - cut_gate.exportCuts( + cut_gate.export_cuts( interface, None, two_qubit_gate, None ) # insert cut in circuit interface. assert interface.cut_type[2] == "LO" -def test_CutLeftWire( - testCircuit: Callable[ +def test_cut_left_wire( + test_circuit: Callable[ [], tuple[ SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] @@ -107,16 +107,16 @@ def test_CutLeftWire( ] ): """Test the action of cutting the first (left) input wire to a two qubit gate.""" - _, state, two_qubit_gate = testCircuit + _, state, two_qubit_gate = test_circuit cut_left_wire = ActionCutLeftWire() - assert cut_left_wire.getName() == "CutLeftWire" - assert cut_left_wire.getGroupNames() == ["WireCut", "TwoQubitGates"] + assert cut_left_wire.get_name() == "CutLeftWire" + assert cut_left_wire.get_group_names() == ["WireCut", "TwoQubitGates"] - updated_state = cut_left_wire.nextStatePrimitive(state, two_qubit_gate, 3) + updated_state = cut_left_wire.next_state_primitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: actions_list.extend(print_actions_list(state.actions)) - # TO-DO: Consider replacing actions_list to a NamedTuple. + # TO-DO: Consider replacing actions_list with a NamedTuple. assert actions_list[0][0] == "CutLeftWire" assert actions_list[0][1][1] == CircuitElement( name="cx", params=[], qubits=[0, 1], gamma=3 @@ -124,8 +124,8 @@ def test_CutLeftWire( assert actions_list[0][2][0][0] == 1 # the first input ('left') wire is cut. -def test_CutRightWire( - testCircuit: Callable[ +def test_cut_right_wire( + test_circuit: Callable[ [], tuple[ SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] @@ -133,12 +133,12 @@ def test_CutRightWire( ] ): """Test the action of cutting the second (right) input wire to a two qubit gate.""" - _, state, two_qubit_gate = testCircuit + _, state, two_qubit_gate = test_circuit cut_right_wire = ActionCutRightWire() - assert cut_right_wire.getName() == "CutRightWire" - assert cut_right_wire.getGroupNames() == ["WireCut", "TwoQubitGates"] + assert cut_right_wire.get_name() == "CutRightWire" + assert cut_right_wire.get_group_names() == ["WireCut", "TwoQubitGates"] - updated_state = cut_right_wire.nextStatePrimitive(state, two_qubit_gate, 3) + updated_state = cut_right_wire.next_state_primitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: actions_list.extend(print_actions_list(state.actions)) @@ -149,10 +149,10 @@ def test_CutRightWire( assert actions_list[0][2][0][0] == 2 # the second input ('right') wire is cut -def test_DefinedActions(): +def test_defined_actions(): # Check that unsupported cutting actions return None # when the action or corresponding group is requested. - assert ActionNames().getAction("LOCCGateCut") is None + assert ActionNames().get_action("LOCCGateCut") is None - assert ActionNames().getGroup("LOCCCUTS") is None + assert ActionNames().get_group("LOCCCUTS") is None diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 6a90379d2..79291251f 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -23,7 +23,7 @@ def test_StateInitialization(num_qubits, max_wire_cuts): @fixture -def testCircuit(): +def test_circuit(): circuit = [ CircuitElement(name="h", params=[], qubits=["q1"], gamma=None), CircuitElement(name="barrier", params=[], qubits=["q1"], gamma=None), @@ -35,25 +35,25 @@ def testCircuit(): interface = SimpleGateList(circuit) # initialize DisjointSubcircuitsState object. - state = DisjointSubcircuitsState(interface.getNumQubits(), 2) + state = DisjointSubcircuitsState(interface.get_num_qubits(), 2) - two_qubit_gate = interface.getMultiQubitGates()[0] + two_qubit_gate = interface.get_multiqubit_gates()[0] return state, two_qubit_gate -def test_StateUncut( - testCircuit: Callable[ +def test_state_uncut( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, _ = testCircuit + state, _ = test_circuit assert list(state.wiremap) == [0, 1] assert state.num_wires == 2 - assert state.getNumQubits() == 2 + assert state.get_num_qubits() == 2 assert list(state.uptree) == [0, 1, 2, 3] @@ -61,17 +61,17 @@ def test_StateUncut( assert list(state.no_merge) == [] - assert state.getSearchLevel() == 0 + assert state.get_search_level() == 0 -def test_ApplyGate( - testCircuit: Callable[ +def test_apply_gate( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, two_qubit_gate = testCircuit + state, two_qubit_gate = test_circuit - next_state = disjoint_subcircuit_actions.getAction(None).nextState( + next_state = disjoint_subcircuit_actions.get_action(None).next_state( state, two_qubit_gate, 10 )[0] @@ -79,9 +79,9 @@ def test_ApplyGate( assert next_state.num_wires == 2 - assert next_state.findQubitRoot(1) == 0 + assert next_state.find_qubit_root(1) == 0 - assert next_state.getWireRootMapping() == [0, 0] + assert next_state.get_wire_root_mapping() == [0, 0] assert list(next_state.uptree) == [0, 0, 2, 3] @@ -89,29 +89,29 @@ def test_ApplyGate( assert list(next_state.no_merge) == [] - assert next_state.getSearchLevel() == 1 + assert next_state.get_search_level() == 1 -def test_CutGate( - testCircuit: Callable[ +def test_cut_gate( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, two_qubit_gate = testCircuit + state, two_qubit_gate = test_circuit - next_state = disjoint_subcircuit_actions.getAction("CutTwoQubitGate").nextState( + next_state = disjoint_subcircuit_actions.get_action("CutTwoQubitGate").next_state( state, two_qubit_gate, 10 )[0] assert list(next_state.wiremap) == [0, 1] - assert next_state.checkDoNotMergeRoots(0, 1) is True + assert next_state.check_donot_merge_roots(0, 1) is True assert next_state.num_wires == 2 - assert state.getNumQubits() == 2 + assert state.get_num_qubits() == 2 - assert next_state.getWireRootMapping() == [0, 1] + assert next_state.get_wire_root_mapping() == [0, 1] assert list(next_state.uptree) == [0, 1, 2, 3] @@ -119,23 +119,23 @@ def test_CutGate( assert list(next_state.no_merge) == [(0, 1)] - assert next_state.getSearchLevel() == 1 + assert next_state.get_search_level() == 1 - assert next_state.lowerBoundGamma() == 3 # one CNOT cut. + assert next_state.lower_bound_gamma() == 3 # one CNOT cut. assert ( - next_state.upperBoundGamma() == 3 - ) # equal to lowerBoundGamma for single gate cuts. + next_state.upper_bound_gamma() == 3 + ) # equal to lower_bound_gamma for single gate cuts. -def test_CutLeftWire( - testCircuit: Callable[ +def test_cut_left_wire( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, two_qubit_gate = testCircuit + state, two_qubit_gate = test_circuit - next_state = disjoint_subcircuit_actions.getAction("CutLeftWire").nextState( + next_state = disjoint_subcircuit_actions.get_action("CutLeftWire").next_state( state, two_qubit_gate, 10 )[0] @@ -146,17 +146,17 @@ def test_CutLeftWire( assert next_state.num_wires == 3 - assert state.getNumQubits() == 2 + assert state.get_num_qubits() == 2 - assert not next_state.canExpandSubcircuit(1, 1, 2) # False + assert not next_state.can_expand_subcircuit(1, 1, 2) # False - assert next_state.canExpandSubcircuit(1, 1, 3) # True + assert next_state.can_expand_subcircuit(1, 1, 3) # True - assert next_state.canAddWires(2) is False + assert next_state.can_add_wires(2) is False - assert next_state.getWireRootMapping() == [0, 1, 1] + assert next_state.get_wire_root_mapping() == [0, 1, 1] - assert next_state.checkDoNotMergeRoots(0, 1) is True + assert next_state.check_donot_merge_roots(0, 1) is True assert list(next_state.uptree) == [0, 1, 1, 3] @@ -164,25 +164,25 @@ def test_CutLeftWire( assert list(next_state.no_merge) == [(0, 1)] - assert next_state.getMaxWidth() == 2 + assert next_state.get_max_width() == 2 - assert next_state.findQubitRoot(0) == 1 + assert next_state.find_qubit_root(0) == 1 - assert next_state.getSearchLevel() == 1 + assert next_state.get_search_level() == 1 - assert next_state.lowerBoundGamma() == 3 + assert next_state.lower_bound_gamma() == 3 - assert next_state.upperBoundGamma() == 4 + assert next_state.upper_bound_gamma() == 4 -def test_CutRightWire( - testCircuit: Callable[ +def test_cut_right_wire( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, two_qubit_gate = testCircuit + state, two_qubit_gate = test_circuit - next_state = disjoint_subcircuit_actions.getAction("CutRightWire").nextState( + next_state = disjoint_subcircuit_actions.get_action("CutRightWire").next_state( state, two_qubit_gate, 10 )[0] @@ -193,13 +193,13 @@ def test_CutRightWire( assert next_state.num_wires == 3 - assert state.getNumQubits() == 2 + assert state.get_num_qubits() == 2 - assert next_state.canAddWires(1) is True + assert next_state.can_add_wires(1) is True - assert next_state.getWireRootMapping() == [0, 1, 0] + assert next_state.get_wire_root_mapping() == [0, 1, 0] - assert next_state.checkDoNotMergeRoots(0, 1) is True + assert next_state.check_donot_merge_roots(0, 1) is True assert list(next_state.uptree) == [0, 1, 0, 3] @@ -207,35 +207,35 @@ def test_CutRightWire( assert list(next_state.no_merge) == [(0, 1)] - assert next_state.findQubitRoot(1) == 0 + assert next_state.find_qubit_root(1) == 0 - assert next_state.getSearchLevel() == 1 + assert next_state.get_search_level() == 1 -def test_CutBothWires( - testCircuit: Callable[ +def test_cut_both_wires( + test_circuit: Callable[ [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] ] ): - state, two_qubit_gate = testCircuit + state, two_qubit_gate = test_circuit - next_state = disjoint_subcircuit_actions.getAction("CutBothWires").nextState( + next_state = disjoint_subcircuit_actions.get_action("CutBothWires").next_state( state, two_qubit_gate, 10 )[0] assert list(next_state.wiremap) == [2, 3] - assert next_state.canAddWires(1) is False + assert next_state.can_add_wires(1) is False assert next_state.num_wires == 4 - assert state.getNumQubits() == 2 + assert state.get_num_qubits() == 2 - assert next_state.getWireRootMapping() == [0, 1, 2, 2] + assert next_state.get_wire_root_mapping() == [0, 1, 2, 2] assert ( - next_state.checkDoNotMergeRoots(0, 2) - == next_state.checkDoNotMergeRoots(1, 2) + next_state.check_donot_merge_roots(0, 2) + == next_state.check_donot_merge_roots(1, 2) is True ) @@ -245,16 +245,18 @@ def test_CutBothWires( assert list(next_state.no_merge) == [(0, 2), (1, 3)] - assert next_state.findQubitRoot(0) == 2 # maps to third wire initialized after cut. + assert ( + next_state.find_qubit_root(0) == 2 + ) # maps to third wire initialized after cut. assert ( - next_state.findQubitRoot(1) == 2 + next_state.find_qubit_root(1) == 2 ) # maps to third wire because of the entangling gate. - assert next_state.getSearchLevel() == 1 + assert next_state.get_search_level() == 1 - assert next_state.lowerBoundGamma() == 9 # 3^n scaling. + assert next_state.lower_bound_gamma() == 9 # 3^n scaling. - assert next_state.upperBoundGamma() == 16 # The 4^n scaling that comes with LO. + assert next_state.upper_bound_gamma() == 16 # The 4^n scaling that comes with LO. - assert next_state.verifyMergeConstraints() is True + assert next_state.verify_merge_constraints() is True diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index af0b7537b..96d8f9abb 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -10,36 +10,36 @@ "max_gamma, max_backjumps ", [(0, 1), (-1, 0), (1, -1)], ) -def test_OptimizationParameters(max_gamma: int, max_backjumps: int): +def test_optimization_parameters(max_gamma: int, max_backjumps: int): """Test optimization parameters for being valid data types.""" with pytest.raises(ValueError): _ = OptimizationSettings(max_gamma=max_gamma, max_backjumps=max_backjumps) -def test_GateCutTypes( +def test_gate_cut_types( LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False ): """Test default gate cut types.""" op = OptimizationSettings() - op.setGateCutTypes() + op.set_gate_cut_types() assert op.gate_cut_LO is True assert op.gate_cut_LOCC_with_ancillas is False -def test_WireCutTypes( +def test_wire_cut_types( LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False ): """Test default wire cut types.""" op = OptimizationSettings() - op.setWireCutTypes() + op.set_wire_cut_types() assert op.wire_cut_LO assert op.wire_cut_LOCC_with_ancillas is False assert op.wire_cut_LOCC_no_ancillas is False -def test_AllCutSearchGroups(): - """Test for the existence of all Cut search groups.""" +def test_all_cut_search_groups(): + """Test for the existence of all cut search groups.""" assert OptimizationSettings( LO=True, LOCC_ancillas=True, LOCC_no_ancillas=True - ).getCutSearchGroups() == [None, "GateCut", "WireCut"] + ).get_cut_search_groups() == [None, "GateCut", "WireCut"] diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index c33024eb6..edad9dfed 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -7,7 +7,7 @@ @pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)]) -def test_DeviceConstraints(qubits_per_QPU: int, num_QPUs: int): +def test_device_constraints(qubits_per_QPU: int, num_QPUs: int): """Test device constraints for being valid data types.""" with pytest.raises(ValueError): @@ -15,7 +15,7 @@ def test_DeviceConstraints(qubits_per_QPU: int, num_QPUs: int): @pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(2, 4), (1, 3)]) -def test_getQPUWidth(qubits_per_QPU: int, num_QPUs: int): - """Test that getQPUWidth returns number of qubits per qpu.""" +def test_get_qpu_width(qubits_per_QPU: int, num_QPUs: int): + """Test that get_qpu_width returns number of qubits per qpu.""" - assert DeviceConstraints(qubits_per_QPU, num_QPUs).getQPUWidth() == qubits_per_QPU + assert DeviceConstraints(qubits_per_QPU, num_QPUs).get_qpu_width() == qubits_per_QPU From ea9ba938bd372f36834c6ab5c423b70101ca1212 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 1 Mar 2024 10:32:54 -0500 Subject: [PATCH 079/128] Fix remaining pylint errors. --- circuit_knitting/cutting/cut_finding/cut_optimization.py | 4 +++- circuit_knitting/cutting/cut_finding/cutting_actions.py | 1 + .../circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb | 2 -- test/cutting/cut_finding/test_optimization_settings.py | 8 +++----- 4 files changed, 7 insertions(+), 8 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 8d6c03804..7a2c443f1 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -33,7 +33,7 @@ @dataclass class CutOptimizationFuncArgs: - """Collect arguments for passing to the :class:`CutOptimization` search-space generating methods.""" + """Collect arguments for passing to the search-space generating methods in :class:`CutOptimization`.""" entangling_gates: Sequence[ Sequence[int | CircuitElement | None | list] @@ -53,6 +53,7 @@ def cut_optimization_cost_func( that balance the sizes of the resulting partitions, by minimizing the maximum width across subcircuits. """ + # pylint: disable=unused-argument return (state.lower_bound_gamma(), state.get_max_width()) @@ -60,6 +61,7 @@ def cut_optimization_upper_bound_cost_func( goal_state, func_args: CutOptimizationFuncArgs ) -> tuple[int | float, int | float]: """Return the gamma upper bound.""" + # pylint: disable=unused-argument return (goal_state.upper_bound_gamma(), np.inf) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 672639e13..2c25939c0 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -197,6 +197,7 @@ def export_cuts( args, ) -> None: """Insert an LO gate cut into the input circuit for the specified gate and cut arguments.""" + # pylint: disable=unused-argument assert isinstance(gate_spec[0], int) circuit_interface.insert_gate_cut(gate_spec[0], "LO") diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index d388e4730..aef111dd6 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -249,8 +249,6 @@ } ], "source": [ - "from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit\n", - "\n", "circuit_ckt_wirecut = qc_to_cco_circuit(qc_0)\n", "\n", "settings = OptimizationSettings(rand_seed=12345)\n", diff --git a/test/cutting/cut_finding/test_optimization_settings.py b/test/cutting/cut_finding/test_optimization_settings.py index 96d8f9abb..f76590910 100644 --- a/test/cutting/cut_finding/test_optimization_settings.py +++ b/test/cutting/cut_finding/test_optimization_settings.py @@ -17,11 +17,9 @@ def test_optimization_parameters(max_gamma: int, max_backjumps: int): _ = OptimizationSettings(max_gamma=max_gamma, max_backjumps=max_backjumps) -def test_gate_cut_types( - LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False -): +def test_gate_cut_types(LO: bool = True, LOCC_ancillas: bool = False): """Test default gate cut types.""" - op = OptimizationSettings() + op = OptimizationSettings(LO, LOCC_ancillas) op.set_gate_cut_types() assert op.gate_cut_LO is True assert op.gate_cut_LOCC_with_ancillas is False @@ -31,7 +29,7 @@ def test_wire_cut_types( LO: bool = True, LOCC_ancillas: bool = False, LOCC_no_ancillas: bool = False ): """Test default wire cut types.""" - op = OptimizationSettings() + op = OptimizationSettings(LO, LOCC_ancillas, LOCC_no_ancillas) op.set_wire_cut_types() assert op.wire_cut_LO assert op.wire_cut_LOCC_with_ancillas is False From d374c25d64ee826c8b89c117a5333a79fad5a6b6 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 1 Mar 2024 12:19:14 -0500 Subject: [PATCH 080/128] Generate black diff. --- circuit_knitting/cutting/cut_finding/search_space_generator.py | 1 - tox.ini | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 9b51ea10c..c97e901b7 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -185,7 +185,6 @@ class SearchSpaceGenerator: """Contain both the functions and the associated actions needed to generate and explore a search space. Member Variables: - functions: a data class that holds the functions needed to generate and explore a search space. diff --git a/tox.ini b/tox.ini index 60b69ac3f..dd90a96f1 100644 --- a/tox.ini +++ b/tox.ini @@ -27,6 +27,7 @@ commands = ruff check circuit_knitting/ docs/ test/ tools/ nbqa ruff docs/ autoflake --check --quiet --recursive circuit_knitting/ docs/ test/ tools/ + black --diff circuit_knitting/ docs/ test/ tools/ black --check circuit_knitting/ docs/ test/ tools/ pydocstyle circuit_knitting/ mypy circuit_knitting/ From b8ccbe43a4ef8a3b7b845f11f6f62faad9b67ea4 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Fri, 1 Mar 2024 14:50:44 -0500 Subject: [PATCH 081/128] Use python3.10 for lint workflow This will match the version specified by basepython in `tox.ini` --- .github/workflows/lint.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 8869143f8..37520b9dd 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -18,10 +18,10 @@ jobs: - uses: actions/checkout@v4 with: fetch-depth: 0 - - name: Set up Python 3.9 + - name: Set up Python 3.10 uses: actions/setup-python@v5 with: - python-version: '3.9' + python-version: '3.10' - name: Install tox run: | python -m pip install --upgrade pip From 4bbac31fac0d64e27056c6ef3a2f2079c3fc4f1b Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 1 Mar 2024 17:23:35 -0500 Subject: [PATCH 082/128] Run style with updated version of black --- .../cutting/cut_finding/cut_optimization.py | 6 +-- .../cut_finding/search_space_generator.py | 54 +++++++++++-------- 2 files changed, 35 insertions(+), 25 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 7a2c443f1..39283ccf0 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -35,9 +35,9 @@ class CutOptimizationFuncArgs: """Collect arguments for passing to the search-space generating methods in :class:`CutOptimization`.""" - entangling_gates: Sequence[ - Sequence[int | CircuitElement | None | list] - ] | None = None + entangling_gates: Sequence[Sequence[int | CircuitElement | None | list]] | None = ( + None + ) search_actions: ActionNames | None = None max_gamma: float | int | None = None qpu_width: int | None = None diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index c97e901b7..d556632ce 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -156,28 +156,38 @@ class SearchFunctions: is None is likewise equivalent to an infinite min-cost bound. """ - cost_func: Callable[ - [DisjointSubcircuitsState, CutOptimizationFuncArgs], - int | float | tuple[int | float, int | float], - ] | None = None - - next_state_func: Callable[ - [DisjointSubcircuitsState, CutOptimizationFuncArgs], - list[DisjointSubcircuitsState], - ] | None = None - - goal_state_func: Callable[ - [DisjointSubcircuitsState, CutOptimizationFuncArgs], bool - ] | None = None - - upperbound_cost_func: Callable[ - [DisjointSubcircuitsState, CutOptimizationFuncArgs], - tuple[int | float, int | float], - ] | None = None - - mincost_bound_func: Callable[ - [CutOptimizationFuncArgs], None | tuple[int | float, int | float] - ] | None = None + cost_func: ( + Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], + int | float | tuple[int | float, int | float], + ] + | None + ) = None + + next_state_func: ( + Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], + list[DisjointSubcircuitsState], + ] + | None + ) = None + + goal_state_func: ( + Callable[[DisjointSubcircuitsState, CutOptimizationFuncArgs], bool] | None + ) = None + + upperbound_cost_func: ( + Callable[ + [DisjointSubcircuitsState, CutOptimizationFuncArgs], + tuple[int | float, int | float], + ] + | None + ) = None + + mincost_bound_func: ( + Callable[[CutOptimizationFuncArgs], None | tuple[int | float, int | float]] + | None + ) = None @dataclass From 7d3872bdcbb17f9e471ba5bdcb2e51c0eb354fce Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 6 Mar 2024 13:22:59 -0500 Subject: [PATCH 083/128] Edit doc strings --- .../cutting/cut_finding/best_first_search.py | 38 +++++++----------- .../cutting/cut_finding/cut_optimization.py | 9 ++--- .../cutting/cut_finding/cutting_actions.py | 3 +- .../cutting/cut_finding/lo_cuts_optimizer.py | 38 ++++++------------ .../cut_finding/optimization_settings.py | 39 +++++-------------- .../cut_finding/quantum_device_constraints.py | 15 +------ .../tutorials/LO_circuit_cut_finder.ipynb | 27 ++++++++----- 7 files changed, 61 insertions(+), 108 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index 0fa11a3e8..ccbcf6044 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -55,15 +55,6 @@ class BestFirstPriorityQueue: Because of the design of the tuple entries that precede it, state objects never get evaluated in the heap-managment comparisons that are performed internally by the priority-queue implementation. - - Member Variables: - - rand_gen is a Numpy random number generator. - - unique is a Python sequence counter. - - pqueue is a Python priority queue (currently heapq, with plans to move to - queue.PriorityQueue if parallelization is ultimately required). """ def __init__(self, rand_seed: int | None): @@ -114,9 +105,9 @@ class BestFirstSearch: """Implement Dijkstra's best-first search algorithm. The search proceeds by choosing the deepest, lowest-cost state in the search - frontier and generating next states. Successive calls to the :func:`optimization_pass` - method will resume the search at the next deepest, lowest-cost state - in the search frontier. The costs of goal states that are returned + frontier and generating next states. Successive calls to + :meth:`BestFirstSearch.optimization_pass()` will resume the search at the next deepest, + lowest-cost state in the search frontier. The costs of goal states that are returned are used to constrain subsequent searches. None is returned if no (additional) feasible solutions can be found, or when no (additional) solutions can be found without exceeding the lowest upper-bound cost @@ -128,26 +119,26 @@ class BestFirstSearch: generators in the bounded best-first priority-queue objects. cost_func (lambda state, *args) is a function that computes cost values - from search states. Input arguments to the :func:`optimization_pass` method are + from search states. Input arguments to :meth:`BestFirstSearch.optimization_pass()`are also passed to the cost_func. The cost returned can be numeric or tuples of numerics. In the latter case, lexicographical comparisons are performed per Python semantics. next_state_func (lambda state, *args) is a function that returns a list - of next states generated from the input state. Input arguments to the - :func:`optimization_pass` method are also passed to the next_state_func. + of next states generated from the input state. Input arguments to + :meth:`BestFirstSearch.optimization_pass() are also passed to the next_state_func. goal_state_func (lambda state, *args) is a function that returns True if - the input state is a solution state of the search. Input arguments to the - :func:`optimization_pass` method are also passed to the goal_state_func. + the input state is a solution state of the search. Input arguments to + :meth:`BestFirstSearch.optimization_pass() are also passed to the goal_state_func. upperbound_cost_func (lambda goal_state, *args) can either be None or a function that returns an upper bound to the optimal cost given a goal_state as input. The upper bound is used to prune next-states from the search in - subsequent calls to the :func:`optimization_pass` method. If upperbound_cost_func + subsequent calls :meth:`BestFirstSearch.optimization_pass(). If upperbound_cost_func is None, the cost of the goal_state as determined by cost_func is used as - an upper bound to the optimal cost. Input arguments to the - :func:`optimization_pass` method are also passed to the upperbound_cost_func. + an upper bound to the optimal cost. Input arguments to :meth:`BestFirstSearch.optimization_pass() + are also passed to the upperbound_cost_func. mincost_bound_func (lambda *args) can either be None or a function that returns a cost bound that is compared to the minimum cost across all @@ -201,7 +192,7 @@ def __init__( and the functions used to perform the search, an optional Boolean flag can be provided to indicate whether to stop the search after the first minimum-cost goal state has been reached (True), - or whether subsequent calls to the :func:`optimization_pass` method should + or whether subsequent calls to :meth:`BestFirstSearch.optimization_pass() should return any additional minimum-cost goal states that might exist (False). """ @@ -252,7 +243,8 @@ def optimization_pass( ): """Perform best-first search until either a goal state is reached, or cost-bounds are reached or no further goal states can be found. - If no further goal states can be found, None is returned. The cost of the returned state is also returned. Any input arguments to + If no further goal states can be found, None is returned. + The cost of the returned state is also returned. Any input arguments to :func:`optimization_pass` are passed along to the search-space functions employed. """ if self.mincost_bound_func is not None: @@ -305,7 +297,7 @@ def minimum_reached(self) -> bool: def get_stats(self, penultimate: bool = False) -> NDArray[np.int_] | None: """Return statistics of the search that was performed. - This is Numpy array containing the number of states visited + This is a Numpy array containing the number of states visited (dequeued), the number of next-states generated, the number of next-states that are enqueued after cost pruning, and the number of backjumps performed. Return None if no search is performed. diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 39283ccf0..865ec7ea5 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -80,16 +80,15 @@ def cut_optimization_next_state_func( ) -> list[DisjointSubcircuitsState]: """Generate a list of next states from the input state.""" # Get the entangling gate spec that is to be processed next based - # on the search level of the input state + # on the search level of the input state. assert func_args.entangling_gates is not None assert func_args.search_actions is not None gate_spec = func_args.entangling_gates[state.get_search_level()] - # Determine which search actions can be performed, taking into + # Determine which cutting actions can be performed, taking into # account any user-specified constraints that might have been - # placed on how the current entangling gate is to be handled - # in the search + # placed on how the current entangling gate is to be handled. gate = gate_spec[1] gate = cast(CircuitElement, gate) if len(gate.qubits) == 2: @@ -103,7 +102,7 @@ def cut_optimization_next_state_func( gate_actions = cast(list, gate_actions) action_list = get_action_subset(action_list, gate_actions) - # Apply the search actions to generate a list of next states + # Apply the search actions to generate a list of next states. next_state_list = [] assert action_list is not None for action in action_list: diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 2c25939c0..e2d9df93c 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -48,7 +48,8 @@ def next_state( ) -> list[DisjointSubcircuitsState]: """Return a list of search states that result from applying the action to gate_spec in the specified :class:`DisjointSubcircuitsState` state. - This is subject to the constraint that the number of resulting qubits (wires) in each subcircuit cannot exceed max_width. + This is subject to the constraint that the number of resulting qubits (wires) + in each subcircuit cannot exceed max_width. """ next_list = self.next_state_primitive(state, gate_spec, max_width) diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 4b754ea36..6555086f1 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -39,37 +39,21 @@ class LOCutsOptimizer: - """Optimize circuit cuts for the case in which only LO quasiprobability decompositions are employed. + """Optimize circuit cuts for the case in which only LO decompositions are employed. The search_engine_config dictionary that configures the optimization algorithms must be specified in the constructor. For flexibility, the circuit_interface, optimization_settings, and device_constraints can - be specified either in the constructor or in the :func:`optimize` method. In - the latter case, the values provided overwrite the previous values. + be specified either in the constructor or in :meth:LOCutsOptimizer.optimize(). + In the latter case, the values provided overwrite the previous values. - The circuit_interface object that is passed to the :func:`optimize` - method is updated to reflect the optimized circuit cuts that were + circuit_interface, an instance of :class:`CircuitInterface`, defines the circuit to be cut. + The circuit_interface object that is passed to the :meth:`LOCutsOptimizer.optimize()` + is updated to reflect the optimized circuit cuts that were identified. - Member Variables: - - circuit_interface (:class:`CircuitInterface`) defines the circuit to be cut. - - optimization_settings (:class:`OptimizationSettings`) defines the settings - to be used for the optimization. - - device_constraints (:class:`DeviceConstraints`) defines the capabilties of - the target quantum hardware. - - search_engine_config (dict) maps names of stages of optimization to - the corresponding SearchSpaceGenerator functions and actions that - are used to perform the search for each stage. - - cut_optimization (:class:`CutOptimization`) is the object created to - perform the circuit cutting optimization. - - best_result (:class:`DisjointSubcircuitsState`) is the lowest-cost - DisjointSubcircuitsState object identified in the search. + :meth:`LOCutsOptimizer.optimize()` returns :data:`best_result`, an instance of :class:`DisjointSubcircuitsState`, + which is the lowest-cost DisjointSubcircuitsState object identified in the search. """ def __init__( @@ -100,7 +84,7 @@ def optimize( ) -> DisjointSubcircuitsState | None: """Optimize the cutting of a circuit. - Input Arguments: + Args: circuit_interface: defines the circuit to be cut. This object is then updated with the optimized cuts that were identified. @@ -113,7 +97,7 @@ def optimize( Returns: The lowest-cost instance of :class:`DisjointSubcircuitsState` identified in - the search, or None if no solution could be found. In the + the search, or None if no solution could be found. In the case of the former, the circuit_interface object is also updated as a side effect to incorporate the cuts found. """ @@ -170,7 +154,7 @@ def get_stats(self, penultimate=False) -> dict[str, NDArray[np.int_]]: } def minimum_reached(self) -> bool: - """Return a Boolean flag indicating whether the global minimum was reached.""" + """Return a Boolean flag indicating whether the global minimum was reached.""" return self.cut_optimization.minimum_reached() diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 0fb694488..c3745660a 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -21,43 +21,23 @@ class OptimizationSettings: """Specify the parameters that control the optimization. - Member Variables: - max_gamma: a constraint on the maximum value of gamma that a + max_gamma specifies a constraint on the maximum value of gamma that a solution to the optimization is allowed to have to be considered feasible. - engine_selections: a dictionary that defines the selections - of search engines for the various stages of optimization. In this release + engine_selections is a dictionary that defines the selection + of search engines for the optimization. In this release only "BestFirst" or Dijkstra's best-first search is supported. - max_backjumps: a constraint on the maximum number of backjump + max_backjumps specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - rand_seed: a seed used to provide a repeatable initialization + rand_seed is a seed used to provide a repeatable initialization of the pesudorandom number generators used by the optimization. If None is used as the random seed, then a seed is obtained using an operating-system call to achieve an unrepeatable randomized initialization. - gate_cut_LO: a flag that indicates that LO gate cuts should be - included in the optimization. - - gate_cut_LOCC_with_ancillas: a flag that indicates that - LOCC gate cuts with ancillas should be included in the optimization. - - wire_cut_LO: a flag that indicates that LO wire cuts should be - included in the optimization. - - wire_cut_LOCC_with_ancillas: a flag that indicates that - LOCC wire cuts with ancillas should be included in the optimization. - - wire_cut_LOCC_no_ancillas: a flag that indicates that - LOCC wire cuts with no ancillas should be included in the optimization. - NOTE: The current release only supports LO gate and wire cuts. LOCC flags have been incorporated with an eye towards future releases. - - Raises: - ValueError: max_gamma must be a positive definite integer. - ValueError: max_backjumps must be a positive semi-definite integer. """ max_gamma: int = 1024 @@ -77,7 +57,6 @@ def __post_init__(self): self.gate_cut_LO = self.LO self.gate_cut_LOCC_with_ancillas = self.LOCC_ancillas - self.gate_cut_LOCC_no_ancillas = self.LOCC_no_ancillas self.wire_cut_LO = self.LO self.wire_cut_LOCC_with_ancillas = self.LOCC_ancillas @@ -86,7 +65,7 @@ def __post_init__(self): self.engine_selections = {"CutOptimization": "BestFirst"} def get_max_gamma(self) -> int: - """Return the max gamma.""" + """Return the constraint on the maxiumum allowed value of gamma.""" return self.max_gamma def get_max_backjumps(self) -> int: @@ -129,7 +108,7 @@ def set_wire_cut_types(self) -> None: self.wire_cut_LOCC_no_ancillas = self.LOCC_no_ancillas def get_cut_search_groups(self) -> list[None | str]: - """Return a list of search-action groups to include in the optimization.""" + """Return a list of action groups to include in the optimization.""" out: list out = [None] @@ -147,7 +126,7 @@ def get_cut_search_groups(self) -> list[None | str]: @classmethod def from_dict( - cls, options: dict # dict[str, None | int | bool | dict[str, str]] + cls, options: dict ) -> OptimizationSettings: - """Return an instance of :class:`OptimizationSettings` initialized with the parameters passed in options.""" + """Return an instance of :class:`OptimizationSettings` initialized with the parameters passed in.""" return cls(**options) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 58abd61da..b2c4a77fb 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -18,18 +18,7 @@ @dataclass class DeviceConstraints: - """Specify the characteristics of the target quantum processor that the optimizer must respect. - - Member Variables: - qubits_per_QPU: The number of qubits that are available on the - individual QPUs that make up the quantum processor. - - num_QPUs: The number of QPUs in the target quantum processor. - - Raises: - ValueError: qubits_per_QPU must be a positive integer. - ValueError: num_QPUs must be a positive integer. - """ + """Specify the characteristics (qubits per QPU and number of QPUs) of the target quantum device that must be respected.""" qubits_per_QPU: int num_QPUs: int @@ -47,5 +36,5 @@ def get_qpu_width(self) -> int: @classmethod def from_dict(cls, options: dict[str, int]) -> DeviceConstraints: - """Return an instance of :class:`DeviceConstraints` initialized with the parameters passed in options.""" + """Return an instance of :class:`DeviceConstraints` initialized with the parameters passed in.""" return cls(**options) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index aef111dd6..17fed18f8 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -33,17 +33,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 2, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -79,6 +79,7 @@ "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAA \n", @@ -86,6 +87,7 @@ "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", "Subcircuits: AAAB \n", @@ -93,6 +95,7 @@ "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", "Subcircuits: AABB \n", @@ -156,17 +159,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 4, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -196,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -206,6 +209,7 @@ "\n", "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAAAAA \n", @@ -213,6 +217,7 @@ "\n", "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 3.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", "Subcircuits: AAAAAAB \n", @@ -220,6 +225,7 @@ "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AAAABABB \n", @@ -227,6 +233,7 @@ "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [10, CircuitElement(name='cx', params=[], qubits=[3, 4], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AAAABBBB \n", @@ -234,6 +241,7 @@ "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 16.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", "Subcircuits: AABABCBCC \n", @@ -241,6 +249,7 @@ "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", + "1\n", " Gamma = 243.0 , Min_gamma_reached = True\n", "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, CircuitElement(name='cx', params=[], qubits=[1, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", "Subcircuits: ABCDDEF \n", From d07c13a1b3055e5845273b73a017d1cf9cb426e4 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Thu, 7 Mar 2024 11:23:20 -0600 Subject: [PATCH 084/128] Find cuts updates (#498) * Return metadata from find_cuts * Move cut finding into cutting package * black * Fix coverage * notebook update * Docstring * Fix small bugs in find_cuts * black * Update test/cutting/test_cutting_decomposition.py * Handle CutBothWires action * Clean up todo * Assert the qubit id's are relative to a two qubit gate * elif * minor comment update * Clean up docstring/comments * Clean up docstring * Don't use funky logic * Docstring cleanup --- circuit_knitting/cutting/__init__.py | 3 +- .../cutting/cut_finding/__init__.py | 3 - .../cutting/cut_finding/cut_finding.py | 102 -------------- .../cutting/cutting_decomposition.py | 124 +++++++++++++++++- .../tutorials/04_automatic_cut_finding.ipynb | 51 ++++--- test/cutting/test_cutting_decomposition.py | 15 +++ 6 files changed, 173 insertions(+), 125 deletions(-) delete mode 100644 circuit_knitting/cutting/cut_finding/cut_finding.py diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index a6f11f100..f739a145c 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -77,12 +77,12 @@ cutqc.reconstruct_full_distribution """ -from .cut_finding import find_cuts from .cutting_decomposition import ( partition_circuit_qubits, partition_problem, cut_gates, PartitionedCuttingProblem, + find_cuts, ) from .cutting_experiments import generate_cutting_experiments from .cutting_reconstruction import reconstruct_expectation_values @@ -98,4 +98,5 @@ "PartitionedCuttingProblem", "cut_wires", "expand_observables", + "find_cuts", ] diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index d78feabbe..3589d3bff 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -8,6 +8,3 @@ # that they have been altered from the originals. """Main automated cut finding functionality.""" -from .cut_finding import find_cuts - -__all__ = ["find_cuts"] diff --git a/circuit_knitting/cutting/cut_finding/cut_finding.py b/circuit_knitting/cutting/cut_finding/cut_finding.py deleted file mode 100644 index ed41d744c..000000000 --- a/circuit_knitting/cutting/cut_finding/cut_finding.py +++ /dev/null @@ -1,102 +0,0 @@ -# This code is a Qiskit project. - -# (C) Copyright IBM 2024. - -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -"""Automatically find cut locations in a quantum circuit.""" - -from __future__ import annotations - -from qiskit import QuantumCircuit -from qiskit.circuit import CircuitInstruction -from typing import cast - -from .optimization_settings import OptimizationSettings -from .quantum_device_constraints import DeviceConstraints -from .disjoint_subcircuits_state import DisjointSubcircuitsState -from .circuit_interface import SimpleGateList -from .lo_cuts_optimizer import LOCutsOptimizer -from .cco_utils import qc_to_cco_circuit -from ..instructions import CutWire -from ..cutting_decomposition import cut_gates - - -def find_cuts( - circuit: QuantumCircuit, - optimization: OptimizationSettings | dict[str, str | int], - constraints: DeviceConstraints | dict[str, int], -) -> QuantumCircuit: - """ - Find cut locations in a circuit, given optimization settings and QPU constraints. - - Args: - circuit: The circuit to cut - optimization: Settings for controlling optimizer behavior. Currently, - only a best-first optimizer is supported. For a list of supported - optimization settings, see :class:`.OptimizationSettings`. - constraints: QPU constraints used to generate the cut location search space. - For information on how to specify QPU constraints, see :class:`.DeviceConstraints`. - - Returns: - A circuit containing :class:`.BaseQPDGate` instances. The subcircuits - resulting from cutting these gates will be runnable on the devices - specified in ``constraints``. - """ - circuit_cco = qc_to_cco_circuit(circuit) - interface = SimpleGateList(circuit_cco) - - if isinstance(optimization, dict): - opt_settings = OptimizationSettings.from_dict(optimization) - else: - opt_settings = optimization - - # Hard-code the optimization type to best-first - opt_settings.set_engine_selection("CutOptimization", "BestFirst") - - if isinstance(constraints, dict): - constraint_settings = DeviceConstraints.from_dict(constraints) - else: - constraint_settings = constraints - - # Hard-code the optimizer to an LO-only optimizer - optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) - - # Find cut locations - opt_out = optimizer.optimize() - - wire_cut_actions = [] - gate_ids = [] - - opt_out = cast(DisjointSubcircuitsState, opt_out) - opt_out.actions = cast(list, opt_out.actions) - for action in opt_out.actions: - if action[0].get_name() == "CutTwoQubitGate": - gate_ids.append(action[1][0]) - else: - wire_cut_actions.append(action) - - # First, replace all gates to cut with BaseQPDGate instances. - # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. - # This may not hold in the future as we stop treating gate cuts individually. - circ_out = cut_gates(circuit, gate_ids)[0] - - # Insert all the wire cuts - counter = 0 - for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): - if action[0].get_name() == "CutTwoQubitGate": - continue - inst_id = action[1][0] - qubit_id = action[2][0][0] - 1 - circ_out.data.insert( - inst_id + counter, - CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), - ) - counter += 1 - - return circ_out diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 8c6de775b..ac86c0c4f 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -15,7 +15,7 @@ from collections import defaultdict from collections.abc import Sequence, Hashable -from typing import NamedTuple +from typing import NamedTuple, cast, Any from qiskit.circuit import ( QuantumCircuit, @@ -28,6 +28,13 @@ from ..utils.transforms import separate_circuit, _partition_labels_from_circuit from .qpd.qpd_basis import QPDBasis from .qpd.instructions import TwoQubitQPDGate +from .instructions import CutWire +from .cut_finding.optimization_settings import OptimizationSettings +from .cut_finding.quantum_device_constraints import DeviceConstraints +from .cut_finding.disjoint_subcircuits_state import DisjointSubcircuitsState +from .cut_finding.circuit_interface import SimpleGateList +from .cut_finding.lo_cuts_optimizer import LOCutsOptimizer +from .cut_finding.cco_utils import qc_to_cco_circuit class PartitionedCuttingProblem(NamedTuple): @@ -260,3 +267,118 @@ def decompose_observables( } return subobservables_by_subsystem + + +def find_cuts( + circuit: QuantumCircuit, + optimization: dict[str, str | int], + constraints: dict[str, int], +) -> tuple[QuantumCircuit, dict[str, Any]]: + """ + Find cut locations in a circuit, given optimization settings and QPU constraints. + + Args: + circuit: The circuit to cut + optimization: Settings dictionary for controlling optimizer behavior. Currently, + only a best-first optimizer is supported. + - max_gamma: Specifies a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered + feasible. Not that the sampling overhead is ``gamma ** 2``. + - max_backjumps: Specifies a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. + - rand_seed: Used to provide a repeatable initialization of the pseudorandom + number generators used by the optimization. If ``None`` is used as the + seed, then a seed is obtained using an operating system call to achieve + an unrepeatable random initialization. + constraints: Dictionary for specifying the constraints on the quantum device(s). + - qubits_per_QPU: The maximum number of qubits each subcircuit can contain + after cutting. + - num_QPUs: The maximum number of subcircuits produced after cutting + + Returns: + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + + A metadata dictionary: + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. + """ + circuit_cco = qc_to_cco_circuit(circuit) + interface = SimpleGateList(circuit_cco) + + opt_settings = OptimizationSettings.from_dict(optimization) + + # Hard-code the optimization type to best-first + opt_settings.set_engine_selection("CutOptimization", "BestFirst") + + constraint_settings = DeviceConstraints.from_dict(constraints) + + # Hard-code the optimizer to an LO-only optimizer + optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) + + # Find cut locations + opt_out = optimizer.optimize() + + wire_cut_actions = [] + gate_ids = [] + + opt_out = cast(DisjointSubcircuitsState, opt_out) + opt_out.actions = cast(list, opt_out.actions) + for action in opt_out.actions: + if action[0].get_name() == "CutTwoQubitGate": + gate_ids.append(action[1][0]) + else: + # The cut-finding optimizer currently only supports 4 cutting + # actions: {CutTwoQubitGate + these 3 wire cut types} + assert action[0].get_name() in ( + "CutLeftWire", + "CutRightWire", + "CutBothWires", + ) + wire_cut_actions.append(action) + + # First, replace all gates to cut with BaseQPDGate instances. + # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. + # This may not hold in the future as we stop treating gate cuts individually. + circ_out = cut_gates(circuit, gate_ids)[0] + + # Insert all the wire cuts + counter = 0 + for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): + inst_id = action[1][0] + # action[2][0][0] will be either 1 (control) or 2 (target) + qubit_id = action[2][0][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction( + CutWire(), [circuit.data[inst_id + counter].qubits[qubit_id]], [] + ), + ) + counter += 1 + if action[0].get_name() == "CutBothWires": + # There should be two wires specified in the action in this case + assert len(action[2]) == 2 + qubit_id2 = action[2][1][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction( + CutWire(), [circuit.data[inst_id + counter].qubits[qubit_id2]], [] + ), + ) + counter += 1 + + # Return metadata describing the cut scheme + metadata: dict[str, Any] = {"cuts": []} + for i, inst in enumerate(circ_out.data): + if inst.operation.name == "qpd_2q": + metadata["cuts"].append(("Gate Cut", i)) + elif inst.operation.name == "cut_wire": + metadata["cuts"].append(("Wire Cut", i)) + metadata["sampling_overhead"] = opt_out.upper_bound_gamma() ** 2 + + return circ_out, metadata diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 3e480df02..65406cda5 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,7 +21,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -53,9 +53,18 @@ "execution_count": 2, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found solution using 2 cuts with a sampling overhead of 127.06026169907257.\n", + "Wire Cut at index 19\n", + "Gate Cut at index 28\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -74,7 +83,13 @@ "# Specify the size and number of the QPUs available\n", "device_constraints = {\"qubits_per_QPU\": 4, \"num_QPUs\": 2}\n", "\n", - "cut_circuit = find_cuts(circuit, optimization_settings, device_constraints)\n", + "cut_circuit, metadata = find_cuts(circuit, optimization_settings, device_constraints)\n", + "print(\n", + " f'Found solution using {len(metadata[\"cuts\"])} cuts with a sampling '\n", + " f'overhead of {metadata[\"sampling_overhead\"]}.'\n", + ")\n", + "for cut in metadata[\"cuts\"]:\n", + " print(f\"{cut[0]} at index {cut[1]}\")\n", "cut_circuit.draw(\"mpl\", scale=0.8, fold=-1)" ] }, @@ -87,17 +102,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -119,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -145,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -155,7 +170,7 @@ " 1: PauliList(['ZIII', 'IIII', 'IIII'])}" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -166,17 +181,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -187,17 +202,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -215,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -254,7 +269,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.8.16" } }, "nbformat": 4, diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index ee68ed806..18ab41c1e 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -19,12 +19,14 @@ from qiskit.circuit import CircuitInstruction, Barrier, Clbit from qiskit.circuit.library import EfficientSU2, RXXGate from qiskit.circuit.library.standard_gates import CXGate +from qiskit.circuit.random import random_circuit from qiskit.quantum_info import PauliList from circuit_knitting.cutting import ( partition_circuit_qubits, partition_problem, cut_gates, + find_cuts, ) from circuit_knitting.cutting.instructions import Move from circuit_knitting.cutting.qpd import ( @@ -257,6 +259,19 @@ def test_partition_problem(self): assert subcircuit[0].num_qubits == 3 assert subcircuit[1].num_qubits == 1 + def test_find_cuts(self): + with self.subTest("simple circuit"): + circuit = random_circuit(7, 6, max_operands=2, seed=1242) + + cut_circ, metadata = find_cuts( + circuit, {"rand_seed": 111}, {"qubits_per_QPU": 4, "num_QPUs": 2} + ) + cut_types = {cut[0] for cut in metadata["cuts"]} + + assert len(metadata["cuts"]) == 2 + assert {"Wire Cut", "Gate Cut"} == cut_types + assert np.isclose(127.06026169, metadata["sampling_overhead"], atol=1e-8) + def test_cut_gates(self): with self.subTest("simple circuit"): compare_qc = QuantumCircuit(2) From 94d96ae28b9faef8d9f03e51d015419722a497c3 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 8 Mar 2024 14:54:35 -0500 Subject: [PATCH 085/128] Change to namedtuples, redo tests and typing. --- .../cutting/cut_finding/best_first_search.py | 2 +- .../cutting/cut_finding/cco_utils.py | 2 +- .../cutting/cut_finding/circuit_interface.py | 39 ++++-- .../cutting/cut_finding/cut_optimization.py | 15 +- .../cutting/cut_finding/cutting_actions.py | 64 ++++----- .../cut_finding/disjoint_subcircuits_state.py | 132 ++++++++++++------ .../cutting/cut_finding/lo_cuts_optimizer.py | 8 +- .../cut_finding/optimization_settings.py | 4 +- .../tutorials/LO_circuit_cut_finder.ipynb | 113 ++++++++++++--- .../cut_finding/test_best_first_search.py | 48 ++++--- .../cut_finding/test_circuit_interfaces.py | 7 +- .../cut_finding/test_cut_finder_roundtrip.py | 47 +++---- .../cut_finding/test_cutting_actions.py | 53 ++++--- 13 files changed, 334 insertions(+), 200 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index ccbcf6044..f8b73cbd1 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -105,7 +105,7 @@ class BestFirstSearch: """Implement Dijkstra's best-first search algorithm. The search proceeds by choosing the deepest, lowest-cost state in the search - frontier and generating next states. Successive calls to + frontier and generating next states. Successive calls to :meth:`BestFirstSearch.optimization_pass()` will resume the search at the next deepest, lowest-cost state in the search frontier. The costs of goal states that are returned are used to constrain subsequent searches. None is returned if no diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index eb0a09c00..ebf1df059 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -28,7 +28,7 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: - """Convert a qiskit quantum circuit object into a circuit list that is compatible with the :class:`SimpleGateList`. + """Convert a :class:`qiskit.QuantumCircuit` instance into a circuit list that is compatible with the :class:`SimpleGateList`. To conform with the uniformity of the design, single and multiqubit (that is, gates acting on more than two qubits) are assigned :math:`gamma=None`. In the converted list, a barrier across the entire circuit is diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index a435674af..07ef11d3c 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -25,10 +25,18 @@ class CircuitElement(NamedTuple): name: str params: list[float | int] - qubits: Sequence[int | tuple[str, int]] + qubits: list[int | tuple[str, int]] gamma: int | float | None +class GateSpec(NamedTuple): + """Named tuple for gate specification.""" + + instruction_id: int + gate: CircuitElement + cut_constraints: list | None + + class CircuitInterface(ABC): """Access and manipulate external circuit representations, and convert to the internal representation used by the circuit cutting optimization code.""" @@ -48,7 +56,7 @@ def get_multiqubit_gates(self): member functions implemented by the derived class to replace the gate with the decomposition determined by the optimizer. - The must be of the form of CircuitElement. + The must be of the form of :class`CircuitElement`. The must be a hashable identifier that can be used to look up cutting rules for the specified gate. Gate names are typically @@ -132,7 +140,7 @@ class SimpleGateList(CircuitInterface): specifications. new_circuit (list): a list of gate specifications that define - the cut circuit. As with circuit, qubit IDs are used to identify + the cut circuit. As with ``circuit``, qubit IDs are used to identify wires/qubits. cut_type (list): a list that assigns cut-type annotations to gates @@ -149,9 +157,8 @@ class SimpleGateList(CircuitInterface): wire IDs defines a subcircuit. """ - circuit: list[list[str | None] | list[CircuitElement | None]] - # new_circuit: Sequence[CircuitElement | str | list[str | int]] - new_circuit: Sequence[CircuitElement | str | Sequence] + circuit: list + new_circuit: list cut_type: list[str | None] qubit_names: NameToIDMap num_qubits: int @@ -161,7 +168,7 @@ class SimpleGateList(CircuitInterface): def __init__( self, input_circuit: Sequence[CircuitElement | str], - init_qubit_names: list[Hashable] = [], + init_qubit_names: list[Hashable] = list(), ): """Assign member variables.""" self.qubit_names = NameToIDMap(init_qubit_names) @@ -201,11 +208,11 @@ def get_num_wires(self) -> int: def get_multiqubit_gates( self, - ) -> Sequence[Sequence[int | CircuitElement | None | list]]: + ) -> list[GateSpec]: """Extract the multiqubit gates from the circuit and prepend the index of the gate in the circuits to the gate specification. The elements of the resulting list therefore have the form - [ ] + [ ] The and have the forms described above. @@ -213,12 +220,14 @@ def get_multiqubit_gates( The is the list index of the corresponding element in self.circuit. """ - subcircuit: Sequence[Sequence[int | CircuitElement | None | list]] = list() - for k, gate in enumerate(self.circuit): - if gate[0] != "barrier": - if len(gate[0].qubits) > 1 and gate[0].name != "barrier": # type: ignore - subcircuit = cast(list, subcircuit) - subcircuit.append([k] + gate) + subcircuit: list[GateSpec] = list() + for k, circ_element in enumerate(self.circuit): + gate = circ_element[0] + cut_constraints = circ_element[1] + if gate != "barrier": + if len(gate.qubits) > 1 and gate.name != "barrier": # type: ignore + # subcircuit = cast(list, subcircuit) + subcircuit.append(GateSpec(k, gate, cut_constraints)) return subcircuit diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 865ec7ea5..2e6cba4d7 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -26,7 +26,7 @@ SearchSpaceGenerator, ) from .disjoint_subcircuits_state import DisjointSubcircuitsState -from .circuit_interface import SimpleGateList, CircuitElement, Sequence +from .circuit_interface import SimpleGateList, CircuitElement, GateSpec from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints @@ -35,9 +35,7 @@ class CutOptimizationFuncArgs: """Collect arguments for passing to the search-space generating methods in :class:`CutOptimization`.""" - entangling_gates: Sequence[Sequence[int | CircuitElement | None | list]] | None = ( - None - ) + entangling_gates: list[GateSpec] | None = None search_actions: ActionNames | None = None max_gamma: float | int | None = None qpu_width: int | None = None @@ -89,8 +87,9 @@ def cut_optimization_next_state_func( # Determine which cutting actions can be performed, taking into # account any user-specified constraints that might have been # placed on how the current entangling gate is to be handled. - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + + gate = gate_spec.gate + gate = cast(CircuitElement, gate_spec.gate) if len(gate.qubits) == 2: action_list = func_args.search_actions.get_group("TwoQubitGates") else: @@ -98,7 +97,7 @@ def cut_optimization_next_state_func( "In the current version, only the cutting of two qubit gates is supported." ) - gate_actions = gate_spec[2] + gate_actions = gate_spec.cut_constraints gate_actions = cast(list, gate_actions) action_list = get_action_subset(action_list, gate_actions) @@ -316,7 +315,7 @@ def max_wire_cuts_circuit(circuit_interface: SimpleGateList) -> int: loss of generality we can assume that wire cutting is performed only on the inputs to multiqubit gates. """ - multiqubit_wires = [len(x[1].qubits) for x in circuit_interface.get_multiqubit_gates()] # type: ignore + multiqubit_wires = [len(x.gate.qubits) for x in circuit_interface.get_multiqubit_gates()] # type: ignore return sum(multiqubit_wires) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index e2d9df93c..4bf14a4d2 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -15,11 +15,11 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Hashable, cast, Sequence -from .search_space_generator import ActionNames from .circuit_interface import SimpleGateList +from .search_space_generator import ActionNames +from typing import Hashable, cast from .disjoint_subcircuits_state import DisjointSubcircuitsState -from .circuit_interface import CircuitElement +from .circuit_interface import GateSpec # Object that holds action names for constructing disjoint subcircuits disjoint_subcircuit_actions = ActionNames() @@ -43,7 +43,7 @@ def next_state_primitive(self, state, gate_spec, max_width): def next_state( self, state: DisjointSubcircuitsState, - gate_spec: Sequence[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: """Return a list of search states that result from applying the action to gate_spec in the specified :class:`DisjointSubcircuitsState` state. @@ -73,19 +73,20 @@ def get_group_names(self) -> list[None | str]: def next_state_primitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int | float, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionApplyGate` to state given the two-qubit gate specification: gate_spec.""" - gate = gate_spec[1] # extract the gate from gate specification. - gate = cast(CircuitElement, gate) + gate = gate_spec.gate # extract the root wire for the first qubit # acted on by the given 2-qubit gate. r1 = state.find_qubit_root(gate.qubits[0]) + # extract the root wire for the second qubit # acted on by the given 2-qubit gate. r2 = state.find_qubit_root(gate.qubits[1]) + # If applying the gate would cause the number of qubits to exceed # the qubit limit, then do not apply the gate assert state.width is not None @@ -106,7 +107,7 @@ def next_state_primitive( return [new_state] -### Adds ActionApplyGate to the global variable disjoint_subcircuit_actions +### Add ActionApplyGate to the global variable ``disjoint_subcircuit_actions`` disjoint_subcircuit_actions.define_action(ActionApplyGate()) @@ -124,12 +125,11 @@ def get_group_names(self) -> list[str]: def next_state_primitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionCutTwoQubitGate` to state given the gate_spec.""" - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover @@ -168,13 +168,13 @@ def next_state_primitive( new_state.gamma_UB = cast(int, new_state.gamma_UB) new_state.gamma_UB *= gamma_UB - new_state.add_action(self, gate_spec, (1, w1), (2, w2)) + new_state.add_action(self, gate_spec, ((1, w1), (2, w2))) return [new_state] @staticmethod def get_cost_params( - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, ) -> tuple[int | float | None, int, int | float | None]: """ Get the cost parameters for gate cuts. @@ -185,8 +185,7 @@ def get_cost_params( Since CKT does not support LOCC at the moment, these tuples will be of the form (gamma, 0, gamma). """ - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + gate = gate_spec.gate gamma = gate.gamma return (gamma, 0, gamma) @@ -194,13 +193,13 @@ def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, args, ) -> None: """Insert an LO gate cut into the input circuit for the specified gate and cut arguments.""" # pylint: disable=unused-argument - assert isinstance(gate_spec[0], int) - circuit_interface.insert_gate_cut(gate_spec[0], "LO") + assert isinstance(gate_spec.instruction_id, int) + circuit_interface.insert_gate_cut(gate_spec.instruction_id, "LO") ### Adds ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions @@ -221,12 +220,12 @@ def get_group_names(self) -> list[str]: def next_state_primitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionCutLeftWire` to state given the gate_spec.""" - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + gate = gate_spec.gate + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( @@ -268,7 +267,7 @@ def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, cut_args, ) -> None: """Insert an LO wire cut into the input circuit for the specified gate and cut arguments.""" @@ -282,11 +281,11 @@ def export_cuts( def insert_all_lo_wire_cuts( circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, cut_args, ) -> None: """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments.""" - gate_ID = gate_spec[0] + gate_ID = gate_spec.instruction_id gate_ID = cast(int, gate_ID) for input_ID, wire_ID, new_wire_ID in cut_args: circuit_interface.insert_wire_cut( @@ -308,12 +307,11 @@ def get_group_names(self) -> list[str]: def next_state_primitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionCutRightWire` to state given the gate_spec.""" - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( @@ -355,7 +353,7 @@ def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, cut_args, ) -> None: # pragma: no cover """Insert an LO wire cut into the input circuit for the specified gate and cut arguments.""" @@ -380,12 +378,12 @@ def get_group_names(self) -> list[str]: def next_state_primitive( self, state: DisjointSubcircuitsState, - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionCutBothWires` to state given the gate_spec.""" - gate = gate_spec[1] - gate = cast(CircuitElement, gate) + gate = gate_spec.gate + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( @@ -421,7 +419,7 @@ def next_state_primitive( new_state.bell_pairs.append((r2, rnew_2)) new_state.gamma_UB *= 16 - new_state.add_action(self, gate_spec, (1, w1, rnew_1), (2, w2, rnew_2)) + new_state.add_action(self, gate_spec, ((1, w1, rnew_1), (2, w2, rnew_2))) return [new_state] @@ -429,7 +427,7 @@ def export_cuts( self, circuit_interface: SimpleGateList, wire_map: list[Hashable], - gate_spec: list[int | CircuitElement | None | list], + gate_spec: GateSpec, cut_args, ) -> None: # pragma: no cover """Insert LO wire cuts into the input circuit for the specified gate and cut arguments.""" diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 184f1f5bd..0faf6b222 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -17,13 +17,54 @@ import numpy as np from numpy.typing import NDArray from collections import Counter -from typing import Hashable, Iterable, TYPE_CHECKING, no_type_check, cast -from .circuit_interface import CircuitElement, SimpleGateList +from .circuit_interface import SimpleGateList, GateSpec +from typing import Hashable, Iterable, TYPE_CHECKING, no_type_check, cast, NamedTuple if TYPE_CHECKING: # pragma: no cover from .cutting_actions import DisjointSearchAction +class Action(NamedTuple): + """Named tuple for specification of cutting action.""" + + action: DisjointSearchAction + gate_spec: GateSpec + args: list + + +class GateCutLocation(NamedTuple): + """Named tuple for specification of gate cut location.""" + + instruction_id: int + gate_name: str + + +class WireCutLocation(NamedTuple): + """Named tuple for specification of wire cut location. + + Wire cuts are identified through the gates whose input wires are cut. + """ + + instruction_id: int + gate_name: str + input: int + + +class CutIdentifier(NamedTuple): + """Named tuple for specification of location of :class:`CutTwoQubitGate` or :class:`CutBothWires` instances.""" + + cut_action: DisjointSearchAction + gate_cut_location: GateCutLocation + + +# Used for dentifying CutLeftWire and CutRightWire actions. +class OneWireCutIdentifier(NamedTuple): + """Named tuple for specification of location of :class:`CutLeftWire` or :class:`CutRightWire` instances.""" + + cut_action: DisjointSearchAction + wire_cut_location: WireCutLocation + + class DisjointSubcircuitsState: """Represent search-space states when cutting circuits to construct disjoint subcircuits. @@ -56,8 +97,7 @@ class DisjointSubcircuitsState: order to implement optimal LOCC wire and gate cuts using ancillas. gamma_LB: a float that is the cumulative lower-bound gamma for circuit cuts - that cannot be constructed using Bell pairs, such as LO gate cuts - for small-angled rotations. + that cannot be constructed using Bell pairs. gamma_UB: a float that is the cumulative upper-bound gamma for all circuit cuts assuming all cuts are LO. @@ -70,17 +110,7 @@ class DisjointSubcircuitsState: wire IDs, the constraint is that at least one pair of corresponding subcircuits cannot be merged. - actions: a list that contains a list of circuit-cutting actions that have - been performed on the circuit. Elements of the list have the form - - [, , (, ..., )] - - The is the object that was used to generate the - circuit cut. The is the specification of the - cut gate using the format defined in the :class:`CircuitInterface` class - description. The trailing entries are the arguments needed by the - that can be used to explore the space of QPD assignments - to the circuit-cutting action. + actions: a list of instances of :class:`Action`. level: an int which specifies the level in the search tree at which this search state resides, with 0 being the root of the search tree. @@ -113,7 +143,7 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No self.gamma_UB: float | None = None self.no_merge: list[tuple] | None = None - self.actions: list[list] | None = None + self.actions: list[Action] | None = None self.cut_actions_list: list | None = None self.level: int | None = None @@ -161,36 +191,41 @@ def copy(self) -> DisjointSubcircuitsState: """Make shallow copy.""" return copy.copy(self) - def cut_actions_sublist(self) -> list[list | dict]: + def cut_actions_sublist(self) -> list[NamedTuple]: """Create a formatted list containing the actions carried out on an instance of :class:`DisjointSubcircuitState`. Also include the locations of these actions which are specified in terms of the associated gates and wires. """ self.actions = cast(list, self.actions) - cut_actions = print_actions_list(self.actions) + cut_actions = get_actions_list(self.actions) - # Output formatting for LO gate and wire cuts. - # TODO: Change to NamedTuples. + # Output formatting for LO gate and wire cuts self.cut_actions_list = cast(list, self.cut_actions_list) for i in range(len(cut_actions)): - if (cut_actions[i][0] == "CutLeftWire") or ( - cut_actions[i][0] == "CutRightWire" - ): + if cut_actions[i].action.get_name() in ("CutLeftWire", "CutRightWire"): self.cut_actions_list.append( - { - "Cut action": cut_actions[i][0], - "Cut location:": { - "Gate": [cut_actions[i][1][0], cut_actions[i][1][1]] - }, - "Input wire": cut_actions[i][2][0][0], - } + OneWireCutIdentifier( + cut_actions[i].action.get_name(), + WireCutLocation( + cut_actions[i].gate_spec.instruction_id, + cut_actions[i].gate_spec.gate.name, + cut_actions[i].args[0][0], + ), + ) ) - elif cut_actions[i][0] == "CutTwoQubitGate": + elif cut_actions[i].action.get_name() in ( + "CutTwoQubitGate", + "CutBothWires", + ): + # For CutBothWires both inputs are cut and so the inputs need not be specified. self.cut_actions_list.append( - { - "Cut action": cut_actions[i][0], - "Cut Gate": [cut_actions[i][1][0], cut_actions[i][1][1]], - } + CutIdentifier( + cut_actions[i].action.get_name(), + GateCutLocation( + cut_actions[i].gate_spec.instruction_id, + cut_actions[i].gate_spec.gate.name, + ), + ) ) if not self.cut_actions_list: self.cut_actions_list = cut_actions @@ -213,7 +248,7 @@ def print(self, simple: bool = False) -> None: # pragma: no cover print("lowerBound", self.lower_bound_gamma()) print("gamma_UB", self.gamma_UB) print("no_merge", self.no_merge) - print("actions", print_actions_list(self.actions)) + print("actions", get_actions_list(self.actions)) print("level", self.level) def get_num_qubits(self) -> int: @@ -233,7 +268,7 @@ def get_sub_circuit_indices(self) -> list[int]: return [i for i, j in enumerate(self.uptree[: self.num_wires]) if i == j] def get_wire_root_mapping(self) -> list[int]: - """Return a list of root wires for each wire in the current cut circuit.""" + """Return a list of root wires for each wire in the current state of the circuit.""" self.num_wires = cast(int, self.num_wires) return [self.find_wire_root(i) for i in range(self.num_wires)] @@ -371,13 +406,13 @@ def merge_roots(self, root_1: int, root_2: int) -> None: def add_action( self, action_obj: DisjointSearchAction, - gate_spec: list[int | CircuitElement | None | list], - *args, + gate_spec: GateSpec, + args: tuple | None = None, ) -> None: """Append the specified action to the list of search-space actions that have been performed.""" if action_obj.get_name() is not None: self.actions = cast(list, self.actions) - self.actions.append([action_obj, gate_spec, args]) + self.actions.append(Action(action_obj, gate_spec, [args])) def get_search_level(self) -> int: """Return the search level.""" @@ -398,8 +433,13 @@ def export_cuts(self, circuit_interface: SimpleGateList): wire_map = np.arange(self.num_wires) assert self.actions is not None - for action, gate_spec, cut_args in self.actions: - action.export_cuts(circuit_interface, wire_map, gate_spec, cut_args) + for action in self.actions: + action.action.export_cuts( # type: ignore + circuit_interface, + wire_map, + action.gate_spec, + action.args, + ) root_list = self.get_sub_circuit_indices() wires_to_roots = self.get_wire_root_mapping() @@ -428,8 +468,8 @@ def calc_root_bell_pairs_gamma(root_bell_pairs: Iterable[Hashable]) -> float: return gamma -def print_actions_list( - action_list: list[list], -) -> list[list[str | list | tuple]]: +def get_actions_list( + action_list: list[Action], +) -> list[Action]: """Return a list specifying objects that represent cutting actions assoicated with an instance of :class:`DisjointSubcircuitsState`.""" - return [[x[0].get_name()] + x[1:] for x in action_list] + return action_list diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 6555086f1..534dbab3e 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -52,8 +52,8 @@ class LOCutsOptimizer: is updated to reflect the optimized circuit cuts that were identified. - :meth:`LOCutsOptimizer.optimize()` returns :data:`best_result`, an instance of :class:`DisjointSubcircuitsState`, - which is the lowest-cost DisjointSubcircuitsState object identified in the search. + :meth:`LOCutsOptimizer.optimize()` returns ``best_result``, an instance of :class:`DisjointSubcircuitsState`, + which is the lowest-cost :class:`DisjointSubcircuitsState` instance identified in the search. """ def __init__( @@ -82,7 +82,7 @@ def optimize( optimization_settings: OptimizationSettings | None = None, device_constraints: DeviceConstraints | None = None, ) -> DisjointSubcircuitsState | None: - """Optimize the cutting of a circuit. + """Optimize the cutting of a circuit by calling :meth:`CutOptimization.optimization_pass()`. Args: circuit_interface: defines the circuit to be @@ -161,7 +161,7 @@ def minimum_reached(self) -> bool: def print_state_list( state_list: list[DisjointSubcircuitsState], ) -> None: # pragma: no cover - """Call the :func:`print` method defined for a :class:`DisjointSubcircuitsState` instance.""" + """Call the :meth:`print()` method defined for a :class:`DisjointSubcircuitsState` instance.""" for x in state_list: print() x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index c3745660a..2021c485b 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -125,8 +125,6 @@ def get_cut_search_groups(self) -> list[None | str]: return out @classmethod - def from_dict( - cls, options: dict - ) -> OptimizationSettings: + def from_dict(cls, options: dict) -> OptimizationSettings: """Return an instance of :class:`OptimizationSettings` initialized with the parameters passed in.""" return cls(**options) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 17fed18f8..cbaef11a2 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 22, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -43,7 +43,7 @@ "
" ] }, - "execution_count": 23, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -79,7 +79,6 @@ "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAA \n", @@ -87,17 +86,15 @@ "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [17, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [25, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx'))]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [20, CircuitElement(name='cx', params=[], qubits=[1, 2], gamma=3.0)]}]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx'))]\n", "Subcircuits: AABB \n", "\n" ] @@ -159,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -169,7 +166,7 @@ "
" ] }, - "execution_count": 25, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -199,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -209,7 +206,6 @@ "\n", "\n", "---------- 7 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAAAAA \n", @@ -217,41 +213,36 @@ "\n", "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 3.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx'))]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', input=1))]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [10, CircuitElement(name='cx', params=[], qubits=[3, 4], gamma=3.0)]}, 'Input wire': 1}]\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', input=1))]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 16.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutRightWire', 'Cut location:': {'Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, 'Input wire': 2}, {'Cut action': 'CutLeftWire', 'Cut location:': {'Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, 'Input wire': 1}]\n", + "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', input=1))]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - "1\n", " Gamma = 243.0 , Min_gamma_reached = True\n", - "[{'Cut action': 'CutTwoQubitGate', 'Cut Gate': [7, CircuitElement(name='cx', params=[], qubits=[0, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [8, CircuitElement(name='cx', params=[], qubits=[1, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [9, CircuitElement(name='cx', params=[], qubits=[2, 3], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [11, CircuitElement(name='cx', params=[], qubits=[3, 5], gamma=3.0)]}, {'Cut action': 'CutTwoQubitGate', 'Cut Gate': [12, CircuitElement(name='cx', params=[], qubits=[3, 6], gamma=3.0)]}]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx'))]\n", "Subcircuits: ABCDDEF \n", "\n" ] @@ -297,6 +288,82 @@ " \"\\n\",\n", " )" ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement\n", + "\n", + "\n", + "def test_circuit():\n", + " circuit = [\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 1], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 2], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[1, 2], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[1, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[2, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 5], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 6], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[5, 6], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 7], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[5, 7], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[6, 7], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[3, 4], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[3, 5], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[3, 6], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 1], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 2], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[1, 2], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[0, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[1, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[2, 3], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 5], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 6], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[5, 6], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[4, 7], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[5, 7], gamma=3),\n", + " CircuitElement(name=\"cx\", params=[], qubits=[6, 7], gamma=3),\n", + " ]\n", + " interface = SimpleGateList(circuit)\n", + " return interface" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'function' object has no attribute 'get_multiqubit_gates'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 8\u001b[0m\n\u001b[1;32m 4\u001b[0m settings\u001b[38;5;241m.\u001b[39mset_engine_selection(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCutOptimization\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBestFirst\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 6\u001b[0m constraint_obj \u001b[38;5;241m=\u001b[39m DeviceConstraints(qubits_per_QPU\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4\u001b[39m, num_QPUs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m op \u001b[38;5;241m=\u001b[39m \u001b[43mCutOptimization\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtest_circuit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconstraint_obj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m out, _ \u001b[38;5;241m=\u001b[39m op\u001b[38;5;241m.\u001b[39moptimization_pass()\n", + "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cut_optimization.py:225\u001b[0m, in \u001b[0;36mCutOptimization.__init__\u001b[0;34m(self, circuit_interface, optimization_settings, device_constraints, search_engine_config)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msearch_actions \u001b[38;5;241m=\u001b[39m cut_actions\n\u001b[1;32m 224\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args \u001b[38;5;241m=\u001b[39m CutOptimizationFuncArgs()\n\u001b[0;32m--> 225\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39mentangling_gates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcircuit\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_multiqubit_gates\u001b[49m()\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39msearch_actions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msearch_actions\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39mmax_gamma \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msettings\u001b[38;5;241m.\u001b[39mget_max_gamma()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'function' object has no attribute 'get_multiqubit_gates'" + ] + } + ], + "source": [ + "from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization\n", + "\n", + "test_circuit = test_circuit()\n", + "settings = OptimizationSettings(rand_seed=12345)\n", + "\n", + "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", + "\n", + "constraint_obj = DeviceConstraints(qubits_per_QPU=4, num_QPUs=2)\n", + "\n", + "op = CutOptimization(test_circuit, settings, constraint_obj)\n", + "\n", + "out, _ = op.optimization_pass()" + ] } ], "metadata": { diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 686bf2423..73e54ed3f 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -5,6 +5,7 @@ from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, CircuitElement, + GateSpec, ) from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization from circuit_knitting.cutting.cut_finding.optimization_settings import ( @@ -14,7 +15,7 @@ DeviceConstraints, ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - print_actions_list, + get_actions_list, ) @@ -74,22 +75,35 @@ def test_best_first_search(test_circuit: SimpleGateList): 27, 4, ) # lower and upper bounds are the same in the absence of LOCC. - assert print_actions_list(out.actions) == [ - [ - "CutTwoQubitGate", - [12, CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), None], - ((1, 3), (2, 4)), - ], - [ - "CutTwoQubitGate", - [13, CircuitElement(name="cx", params=[], qubits=[3, 5], gamma=3), None], - ((1, 3), (2, 5)), - ], - [ - "CutTwoQubitGate", - [14, CircuitElement(name="cx", params=[], qubits=[3, 6], gamma=3), None], - ((1, 3), (2, 6)), - ], + actions_sublist = [] + for i, action in enumerate(get_actions_list(out.actions)): + assert action.action.get_name() == "CutTwoQubitGate" + actions_sublist.append(get_actions_list(out.actions)[i][1:]) + assert actions_sublist == [ + ( + GateSpec( + instruction_id=12, + gate=CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), + cut_constraints=None, + ), + [((1, 3), (2, 4))], + ), + ( + GateSpec( + instruction_id=13, + gate=CircuitElement(name="cx", params=[], qubits=[3, 5], gamma=3), + cut_constraints=None, + ), + [((1, 3), (2, 5))], + ), + ( + GateSpec( + instruction_id=14, + gate=CircuitElement(name="cx", params=[], qubits=[3, 6], gamma=3), + cut_constraints=None, + ), + [((1, 3), (2, 6))], + ), ] out, _ = op.optimization_pass() diff --git a/test/cutting/cut_finding/test_circuit_interfaces.py b/test/cutting/cut_finding/test_circuit_interfaces.py index 8ddeafbf9..4ed27c321 100644 --- a/test/cutting/cut_finding/test_circuit_interfaces.py +++ b/test/cutting/cut_finding/test_circuit_interfaces.py @@ -3,6 +3,7 @@ from circuit_knitting.cutting.cut_finding.circuit_interface import ( CircuitElement, SimpleGateList, + GateSpec, ) from circuit_knitting.cutting.cut_finding.cut_optimization import ( @@ -35,7 +36,11 @@ def test_circuit_conversion(self): assert circuit_converted.get_num_wires() == 2 assert circuit_converted.qubit_names.item_dict == {"q1": 0, "q0": 1} assert circuit_converted.get_multiqubit_gates() == [ - [4, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None] + GateSpec( + instruction_id=4, + gate=CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), + cut_constraints=None, + ) ] assert circuit_converted.circuit == [ diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 170290388..3537567f9 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -9,7 +9,6 @@ from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, - CircuitElement, ) from circuit_knitting.cutting.cut_finding.optimization_settings import ( OptimizationSettings, @@ -18,7 +17,11 @@ DeviceConstraints, ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - print_actions_list, + get_actions_list, + OneWireCutIdentifier, + WireCutLocation, + CutIdentifier, + GateCutLocation, ) from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import ( LOCutsOptimizer, @@ -81,7 +84,7 @@ def test_no_cuts( output = optimization_pass.optimize(interface, settings, constraint_obj) - assert print_actions_list(output.actions) == [] # no cutting. + assert get_actions_list(output.actions) == [] # no cutting. assert interface.export_subcircuits_as_string(name_mapping="default") == "AAAA" @@ -104,20 +107,14 @@ def test_gate_cuts( cut_actions_list = output.cut_actions_sublist() assert cut_actions_list == [ - { - "Cut action": "CutTwoQubitGate", - "Cut Gate": [ - 9, - CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3), - ], - }, - { - "Cut action": "CutTwoQubitGate", - "Cut Gate": [ - 20, - CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3.0), - ], - }, + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation(instruction_id=9, gate_name="cx"), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation(instruction_id=20, gate_name="cx"), + ), ] best_result = optimization_pass.get_results() @@ -152,16 +149,12 @@ def test_wire_cuts( cut_actions_list = output.cut_actions_sublist() assert cut_actions_list == [ - { - "Cut action": "CutLeftWire", - "Cut location:": { - "Gate": [ - 10, - CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3), - ] - }, - "Input wire": 1, - } + OneWireCutIdentifier( + cut_action="CutLeftWire", + wire_cut_location=WireCutLocation( + instruction_id=10, gate_name="cx", input=1 + ), + ) ] best_result = optimization_pass.get_results() diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 5538f3d85..1de26e7c8 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -14,7 +14,9 @@ ) from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( DisjointSubcircuitsState, - print_actions_list, + get_actions_list, + CutIdentifier, + GateCutLocation, ) from circuit_knitting.cutting.cut_finding.search_space_generator import ActionNames @@ -29,7 +31,7 @@ def test_circuit(): interface = SimpleGateList(circuit) - # initialize DisjointSubcircuitsState object. + # initialize instance of :class:`DisjointSubcircuitsState`. state = DisjointSubcircuitsState(interface.get_num_qubits(), 2) two_qubit_gate = interface.get_multiqubit_gates()[0] @@ -77,15 +79,22 @@ def test_cut_two_qubit_gate( updated_state = cut_gate.next_state_primitive(state, two_qubit_gate, 2) actions_list = [] for state in updated_state: - actions_list.extend(print_actions_list(state.actions)) + actions_list.extend(state.cut_actions_sublist()) assert actions_list == [ - [ - "CutTwoQubitGate", - [2, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], - ((1, 0), (2, 1)), - ] + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation(instruction_id=2, gate_name="cx"), + ) ] + # assert actions_list == [ + # [ + # "CutTwoQubitGate", + # [2, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], + # ((1, 0), (2, 1)), + # ] + # ] + assert cut_gate.get_cost_params(two_qubit_gate) == ( 3, 0, @@ -115,13 +124,13 @@ def test_cut_left_wire( updated_state = cut_left_wire.next_state_primitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: - actions_list.extend(print_actions_list(state.actions)) - # TO-DO: Consider replacing actions_list with a NamedTuple. - assert actions_list[0][0] == "CutLeftWire" - assert actions_list[0][1][1] == CircuitElement( - name="cx", params=[], qubits=[0, 1], gamma=3 - ) - assert actions_list[0][2][0][0] == 1 # the first input ('left') wire is cut. + actions_list.extend(get_actions_list(state.actions)) + for action in actions_list: + assert action.action.get_name() == "CutLeftWire" + assert action.gate_spec.gate == CircuitElement( + name="cx", params=[], qubits=[0, 1], gamma=3 + ) + assert action.args[0][0] == 1 # the first input ('left') wire is cut. def test_cut_right_wire( @@ -141,12 +150,14 @@ def test_cut_right_wire( updated_state = cut_right_wire.next_state_primitive(state, two_qubit_gate, 3) actions_list = [] for state in updated_state: - actions_list.extend(print_actions_list(state.actions)) - assert actions_list[0][0] == "CutRightWire" - assert actions_list[0][1][1] == CircuitElement( - name="cx", params=[], qubits=[0, 1], gamma=3 - ) - assert actions_list[0][2][0][0] == 2 # the second input ('right') wire is cut + actions_list.extend(get_actions_list(state.actions)) + + for action in actions_list: + assert action.action.get_name() == "CutRightWire" + assert action.gate_spec.gate == CircuitElement( + name="cx", params=[], qubits=[0, 1], gamma=3 + ) + assert action.args[0][0] == 2 # the second input ('right') wire is cut def test_defined_actions(): From 95a4885604451c2a6bc564370605f5d9a4fa7d4f Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 8 Mar 2024 16:28:30 -0500 Subject: [PATCH 086/128] Fix sphinx errors, change actions to named tuples. --- .../cutting/cut_finding/circuit_interface.py | 91 ++++++++----------- .../cutting/cut_finding/cut_optimization.py | 9 +- .../cutting/cut_finding/cutting_actions.py | 4 +- .../cutting/cutting_decomposition.py | 74 +++++++-------- .../tutorials/04_automatic_cut_finding.ipynb | 12 +-- 5 files changed, 89 insertions(+), 101 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 07ef11d3c..7cfb5e1d6 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -30,7 +30,21 @@ class CircuitElement(NamedTuple): class GateSpec(NamedTuple): - """Named tuple for gate specification.""" + """Named tuple for gate specification. + + ``cut_constraints`` can be of the form + None,[],[None], or [, ..., ] + + A cut constraint of None indicates that no constraints are placed + on how or whether cuts can be performed. An empty list [] or the + list [None] indicates that no cuts are to be performed and the gate + is to be applied without cutting. A list of cut types of the form + [ ... ] indicates precisely which types of + cuts can be considered. In this case, the cut type None must be + explicitly included to indicate the possibilty of not cutting, if + not cutting is to be considered. In the current version of the code, + the allowed cut types are 'None', 'GateCut' and 'WireCut'. + """ instruction_id: int gate: CircuitElement @@ -38,7 +52,7 @@ class GateSpec(NamedTuple): class CircuitInterface(ABC): - """Access and manipulate external circuit representations, and convert to the internal representation used by the circuit cutting optimization code.""" + """Access attributes of input circuit and perform operations on the internal circuit representations.""" @abstractmethod def get_num_qubits(self): @@ -48,48 +62,19 @@ def get_num_qubits(self): def get_multiqubit_gates(self): """Return a list that specifies the multiqubit gates in the input circuit. - The returned list is of the form: - [ ... [ ] ...] - - The can be any object that uniquely identifies the gate - in the circuit. The can be used as an argument in other - member functions implemented by the derived class to replace the gate - with the decomposition determined by the optimizer. - - The must be of the form of :class`CircuitElement`. - - The must be a hashable identifier that can be used to - look up cutting rules for the specified gate. Gate names are typically - the Qiskit names of the gates. - - The must be a non-negative integer with qubits numbered - starting with zero. Derived classes are responsible for constructing the - mappings from external qubit identifiers to the corresponding qubit IDs. - - The can be of the form - None - [] - [None] - [, ..., ] - - A cut constraint of None indicates that no constraints are placed - on how or whether cuts can be performed. An empty list [] or the - list [None] indicates that no cuts are to be performed and the gate - is to be applied without cutting. A list of cut types of the form - [ ... ] indicates precisely which types of - cuts can be considered. In this case, the cut type None must be - explicitly included to indicate the possibilty of not cutting, if - not cutting is to be considered. In the current version of the code, - the allowed cut types are 'None', 'GateCut' and 'WireCut'. + The returned list is a list of instances of :class:`GateSpec`. """ @abstractmethod def insert_gate_cut(self, gate_ID, cut_type): - """Mark the specified gate as being cut. The cut types can only be "LO" in this release.""" + """Mark the specified gate as being cut. The cut types can only be "LO" in this release.""" @abstractmethod def insert_wire_cut(self, gate_ID, input_ID, src_wire_ID, dest_wire_ID, cut_type): - """Insert insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. + """Insert insert a wire cut into the output circuit. + + Wire cuts are inserted just prior to the specified + gate on the wire connected to the specified input of that gate. Gate inputs are numbered starting from 1. The wire/qubit ID of the wire to be cut is also provided as input to allow the wire choice to be verified. @@ -136,22 +121,25 @@ class SimpleGateList(CircuitInterface): [ ... [, None] ...] - where the qubit names have been replaced with qubit IDs in the gate - specifications. + where can be a string to denote a "barrier" across + the entire circuit, or an instance of :class:`CircuitElement`. + Moreover the qubit names have been replaced with qubit IDs + in the gate specification. - new_circuit (list): a list of gate specifications that define - the cut circuit. As with ``circuit``, qubit IDs are used to identify + new_circuit (list): a list of the form [......] that defines + the cut circuit. The form of is as mentioned above. + As with ``circuit``, qubit IDs are used to identify wires/qubits. cut_type (list): a list that assigns cut-type annotations to gates - in new_circuit. + in ``new_circuit``. new_gate_ID_map (list): a list that maps the positions of gates - in circuit to their new positions in new_circuit. + in circuit to their new positions in ``new_circuit``. output_wires (list): a list that maps qubit IDs in circuit to the corresponding output wires of new_circuit so that observables defined for circuit - can be remapped to new_circuit. + can be remapped to ``new_circuit``. subcircuits (list): a list of list of wire IDs, where each list of wire IDs defines a subcircuit. @@ -211,14 +199,7 @@ def get_multiqubit_gates( ) -> list[GateSpec]: """Extract the multiqubit gates from the circuit and prepend the index of the gate in the circuits to the gate specification. - The elements of the resulting list therefore have the form - [ ] - - The and have the forms - described above. - - The is the list index of the corresponding element in - self.circuit. + The elements of the resulting list are instances of :class:`GateSpec`. """ subcircuit: list[GateSpec] = list() for k, circ_element in enumerate(self.circuit): @@ -226,7 +207,6 @@ def get_multiqubit_gates( cut_constraints = circ_element[1] if gate != "barrier": if len(gate.qubits) > 1 and gate.name != "barrier": # type: ignore - # subcircuit = cast(list, subcircuit) subcircuit.append(GateSpec(k, gate, cut_constraints)) return subcircuit @@ -244,7 +224,10 @@ def insert_wire_cut( dest_wire_id: int, cut_type: str, ) -> None: - """Insert a wire cut into the output circuit just prior to the specified gate on the wire connected to the specified input of that gate. + """Insert a wire cut into the output circuit, + + Wire cuts are inserted just prior to the specified + gate on the wire connected to the specified input of that gate. Gate inputs are numbered starting from 1. The wire/qubit ID of the source wire to be cut is also provided as diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 2e6cba4d7..a61bbc118 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -168,7 +168,7 @@ class CutOptimization: circuit (:class:`CircuitInterface`) is the interface for the circuit to be cut. - settings (:class:`OptimizationSettings`)contains the settings that + settings (:class:`OptimizationSettings`) contains the settings that control the optimization process. constraints (:class:`DeviceConstraints`) contains the device constraints @@ -201,7 +201,7 @@ def __init__( ): """Assign member variables. - A CutOptimization object must be initialized with + An instance of :class:`CutOptimization` must be initialized with a specification of all of the parameters of the optimization to be performed: i.e., the circuit to be cut, the optimization settings, the target-device constraints, the functions for generating the @@ -308,7 +308,10 @@ def update_upperbound_cost( def max_wire_cuts_circuit(circuit_interface: SimpleGateList) -> int: - """Calculate an upper bound on the maximum possible number of wire cuts, given the total number of inputs to multiqubit gates in the circuit. + """Calculate an upper bound on the maximum possible number of wire cuts. + + This is constrained by the total number of inputs to multiqubit gates in + the circuit. NOTE: There is no advantage gained by cutting wires that only have single qubit gates acting on them, so without diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 4bf14a4d2..00b5d3488 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -76,7 +76,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int | float, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionApplyGate` to state given the two-qubit gate specification: gate_spec.""" + """Return the new state that results from applying :class:`ActionApplyGate` to state given ``gate_spec``.""" gate = gate_spec.gate # extract the root wire for the first qubit @@ -128,7 +128,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionCutTwoQubitGate` to state given the gate_spec.""" + """Return the new state that results from applying :class:`ActionCutTwoQubitGate` to state given ``gate_spec``.""" gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index ac86c0c4f..4c82883dd 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -278,35 +278,37 @@ def find_cuts( Find cut locations in a circuit, given optimization settings and QPU constraints. Args: - circuit: The circuit to cut - optimization: Settings dictionary for controlling optimizer behavior. Currently, - only a best-first optimizer is supported. - - max_gamma: Specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered - feasible. Not that the sampling overhead is ``gamma ** 2``. - - max_backjumps: Specifies a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. - - rand_seed: Used to provide a repeatable initialization of the pseudorandom - number generators used by the optimization. If ``None`` is used as the - seed, then a seed is obtained using an operating system call to achieve - an unrepeatable random initialization. - constraints: Dictionary for specifying the constraints on the quantum device(s). - - qubits_per_QPU: The maximum number of qubits each subcircuit can contain - after cutting. - - num_QPUs: The maximum number of subcircuits produced after cutting + circuit: The circuit to cut + + optimization: Settings dictionary for controlling optimizer behavior. Currently, + only a best-first optimizer is supported. + - max_gamma: Specifies a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered + feasible. Not that the sampling overhead is ``gamma ** 2``. + - max_backjumps: Specifies a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. + - rand_seed: Used to provide a repeatable initialization of the pseudorandom + number generators used by the optimization. If ``None`` is used as the + seed, then a seed is obtained using an operating system call to achieve + an unrepeatable random initialization. + + constraints: Dictionary for specifying the constraints on the quantum device(s). + - qubits_per_QPU: The maximum number of qubits each subcircuit can contain + after cutting. + - num_QPUs: The maximum number of subcircuits produced after cutting Returns: - A circuit containing :class:`.BaseQPDGate` instances. The subcircuits - resulting from cutting these gates will be runnable on the devices - specified in ``constraints``. - - A metadata dictionary: - - cuts: A list of length-2 tuples describing each cut in the output circuit. - The tuples are formatted as ``(cut_type: str, cut_id: int)``. The - cut ID is the index of the cut gate or wire in the output circuit's - ``data`` field. - - sampling_overhead: The sampling overhead incurred from cutting the specified - gates and wires. + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + + A metadata dictionary: + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. """ circuit_cco = qc_to_cco_circuit(circuit) interface = SimpleGateList(circuit_cco) @@ -330,12 +332,12 @@ def find_cuts( opt_out = cast(DisjointSubcircuitsState, opt_out) opt_out.actions = cast(list, opt_out.actions) for action in opt_out.actions: - if action[0].get_name() == "CutTwoQubitGate": - gate_ids.append(action[1][0]) + if action.action.get_name() == "CutTwoQubitGate": + gate_ids.append(action.gate_spec.instruction_id) else: # The cut-finding optimizer currently only supports 4 cutting # actions: {CutTwoQubitGate + these 3 wire cut types} - assert action[0].get_name() in ( + assert action.action.get_name() in ( "CutLeftWire", "CutRightWire", "CutBothWires", @@ -350,9 +352,9 @@ def find_cuts( # Insert all the wire cuts counter = 0 for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): - inst_id = action[1][0] - # action[2][0][0] will be either 1 (control) or 2 (target) - qubit_id = action[2][0][0] - 1 + inst_id = action.gate_spec.instruction_id + # args[0][0] will be either 1 (control) or 2 (target) + qubit_id = action.args[0][0] - 1 circ_out.data.insert( inst_id + counter, CircuitInstruction( @@ -360,10 +362,10 @@ def find_cuts( ), ) counter += 1 - if action[0].get_name() == "CutBothWires": + if action.action.get_name() == "CutBothWires": # There should be two wires specified in the action in this case - assert len(action[2]) == 2 - qubit_id2 = action[2][1][0] - 1 + assert len(action.args) == 2 + qubit_id2 = action.args[1][0] - 1 circ_out.data.insert( inst_id + counter, CircuitInstruction( diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 65406cda5..96d5cf64c 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -21,7 +21,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -64,7 +64,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -107,7 +107,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -186,7 +186,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -207,7 +207,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -269,7 +269,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.9.6" } }, "nbformat": 4, From 115fe0516d634e2c55ed392112b4bd7f5d852717 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 8 Mar 2024 16:36:33 -0500 Subject: [PATCH 087/128] lint --- circuit_knitting/cutting/cut_finding/circuit_interface.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 7cfb5e1d6..4fae8b10c 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -155,7 +155,7 @@ class SimpleGateList(CircuitInterface): def __init__( self, - input_circuit: Sequence[CircuitElement | str], + input_circuit: list[CircuitElement | str], init_qubit_names: list[Hashable] = list(), ): """Assign member variables.""" @@ -224,7 +224,7 @@ def insert_wire_cut( dest_wire_id: int, cut_type: str, ) -> None: - """Insert a wire cut into the output circuit, + """Insert a wire cut into the output circuit. Wire cuts are inserted just prior to the specified gate on the wire connected to the specified input of that gate. From 09291849cf7de0ad97da319815d60c1b6e07c7ef Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Sat, 9 Mar 2024 20:33:17 -0500 Subject: [PATCH 088/128] clean up notebook, cast statements. --- .../cutting/cut_finding/best_first_search.py | 2 - .../cutting/cut_finding/cco_utils.py | 1 - .../cutting/cut_finding/circuit_interface.py | 24 +++--- .../tutorials/LO_circuit_cut_finder.ipynb | 76 ------------------- 4 files changed, 14 insertions(+), 89 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index f8b73cbd1..9a401f5d1 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -270,7 +270,6 @@ def optimization_pass( self.num_backjumps += 1 prev_depth = depth - state = cast(DisjointSubcircuitsState, state) self.goal_state_func = cast(Callable, self.goal_state_func) if self.goal_state_func(state, *args): self.penultimate_stats = self.get_stats() @@ -281,7 +280,6 @@ def optimization_pass( self.next_state_func = cast(Callable, self.next_state_func) next_state_list = self.next_state_func(state, *args) - depth = cast(int, depth) self.put(next_state_list, depth + 1, args) # If all states have been explored, then the minimum has been reached diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index ebf1df059..e89d5c438 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -83,7 +83,6 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: qc_cut = QuantumCircuit(num_qubits) for k, op in enumerate([cut_circuit for cut_circuit in cut_circuit_list]): if cut_types[k] is None: # only append gates that are not cut. - op = cast(CircuitElement, op) op_name = op.name op_qubits = op.qubits op_params = op.params diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 4fae8b10c..4c1d7379e 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -24,8 +24,8 @@ class CircuitElement(NamedTuple): """Named tuple for specifying a circuit element.""" name: str - params: list[float | int] - qubits: list[int | tuple[str, int]] + params: Sequence[float | int] + qubits: Sequence[int | tuple[str, int]] gamma: int | float | None @@ -126,10 +126,12 @@ class SimpleGateList(CircuitInterface): Moreover the qubit names have been replaced with qubit IDs in the gate specification. - new_circuit (list): a list of the form [......] that defines - the cut circuit. The form of is as mentioned above. - As with ``circuit``, qubit IDs are used to identify - wires/qubits. + new_circuit (list): a list that defines the cut circuit. + the cut circuit. In the absence of wire cuts, it has + the form [......] The form of + is as mentioned above. As with ``circuit``, qubit IDs are used to identify + wires/qubits. After wire cuts ``new_circuit``has lists of the form + ["move", source_wire_id, destination_wire_id] inserted into it. cut_type (list): a list that assigns cut-type annotations to gates in ``new_circuit``. @@ -204,7 +206,9 @@ def get_multiqubit_gates( subcircuit: list[GateSpec] = list() for k, circ_element in enumerate(self.circuit): gate = circ_element[0] + gate = cast(CircuitElement, gate) cut_constraints = circ_element[1] + assert cut_constraints is None if gate != "barrier": if len(gate.qubits) > 1 and gate.name != "barrier": # type: ignore subcircuit.append(GateSpec(k, gate, cut_constraints)) @@ -258,13 +262,12 @@ def insert_wire_cut( self.replace_wire_ids(self.new_circuit[gate_pos:], wire_map) # Insert a move operator - self.new_circuit = cast(list, self.new_circuit) self.new_circuit.insert(gate_pos, ["move", src_wire_id, dest_wire_id]) self.cut_type.insert(gate_pos, cut_type) self.new_gate_id_map[gate_id:] += 1 # Update the output wires - op = cast(CircuitElement, self.circuit[gate_id][0]) + op = self.circuit[gate_id][0] qubit = op.qubits[input_id - 1] self.output_wires[qubit] = dest_wire_id @@ -283,7 +286,7 @@ def get_wire_names(self) -> list[Hashable]: def export_cut_circuit( self, name_mapping: None | str = "default", - ) -> Sequence[CircuitElement | Sequence]: + ) -> list[CircuitElement]: """Return a list of gates representing the cut circuit. If None is provided as the name_mapping, then the original qubit names are @@ -390,6 +393,7 @@ def sort_order(self, name: Hashable) -> int | float: def replace_wire_ids( self, gate_list: Sequence[CircuitElement | Sequence[str | int]], + # wire_map: Sequence[int | tuple[str, int]], wire_map: list[int], ) -> None: """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map.""" @@ -399,7 +403,7 @@ def replace_wire_ids( inst.qubits[k] = wire_map[inst.qubits[k]] # type: ignore elif isinstance(inst, list): for k in range(1, len(inst)): - inst[k] = wire_map[inst[k]] # type: ignore + inst[k] = wire_map[inst[k]] class NameToIDMap: diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index cbaef11a2..2d6e67a17 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -288,82 +288,6 @@ " \"\\n\",\n", " )" ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement\n", - "\n", - "\n", - "def test_circuit():\n", - " circuit = [\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 1], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 2], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[1, 2], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[1, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[2, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 5], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 6], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[5, 6], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 7], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[5, 7], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[6, 7], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[3, 4], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[3, 5], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[3, 6], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 1], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 2], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[1, 2], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[0, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[1, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[2, 3], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 5], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 6], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[5, 6], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[4, 7], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[5, 7], gamma=3),\n", - " CircuitElement(name=\"cx\", params=[], qubits=[6, 7], gamma=3),\n", - " ]\n", - " interface = SimpleGateList(circuit)\n", - " return interface" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'function' object has no attribute 'get_multiqubit_gates'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[7], line 8\u001b[0m\n\u001b[1;32m 4\u001b[0m settings\u001b[38;5;241m.\u001b[39mset_engine_selection(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCutOptimization\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBestFirst\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 6\u001b[0m constraint_obj \u001b[38;5;241m=\u001b[39m DeviceConstraints(qubits_per_QPU\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4\u001b[39m, num_QPUs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m op \u001b[38;5;241m=\u001b[39m \u001b[43mCutOptimization\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtest_circuit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconstraint_obj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m out, _ \u001b[38;5;241m=\u001b[39m op\u001b[38;5;241m.\u001b[39moptimization_pass()\n", - "File \u001b[0;32m~/circuit-knitting-toolbox/circuit_knitting/cutting/cut_finding/cut_optimization.py:225\u001b[0m, in \u001b[0;36mCutOptimization.__init__\u001b[0;34m(self, circuit_interface, optimization_settings, device_constraints, search_engine_config)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msearch_actions \u001b[38;5;241m=\u001b[39m cut_actions\n\u001b[1;32m 224\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args \u001b[38;5;241m=\u001b[39m CutOptimizationFuncArgs()\n\u001b[0;32m--> 225\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39mentangling_gates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcircuit\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_multiqubit_gates\u001b[49m()\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39msearch_actions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msearch_actions\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_args\u001b[38;5;241m.\u001b[39mmax_gamma \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msettings\u001b[38;5;241m.\u001b[39mget_max_gamma()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'function' object has no attribute 'get_multiqubit_gates'" - ] - } - ], - "source": [ - "from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization\n", - "\n", - "test_circuit = test_circuit()\n", - "settings = OptimizationSettings(rand_seed=12345)\n", - "\n", - "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", - "\n", - "constraint_obj = DeviceConstraints(qubits_per_QPU=4, num_QPUs=2)\n", - "\n", - "op = CutOptimization(test_circuit, settings, constraint_obj)\n", - "\n", - "out, _ = op.optimization_pass()" - ] } ], "metadata": { From 65108d8aebacc3541f59aba79a67b2b569b6c9f7 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 11 Mar 2024 10:31:10 -0400 Subject: [PATCH 089/128] Clean up type hints --- .../cutting/cut_finding/best_first_search.py | 23 +++++++++---------- .../cutting/cut_finding/cco_utils.py | 2 +- .../cutting/cut_finding/circuit_interface.py | 6 ++--- .../cutting/cut_finding/cut_optimization.py | 22 ++++++++---------- .../cutting/cut_finding/cutting_actions.py | 16 ++++++------- .../cut_finding/disjoint_subcircuits_state.py | 2 +- .../cut_finding/optimization_settings.py | 4 ++-- .../cut_finding/search_space_generator.py | 6 ++--- 8 files changed, 38 insertions(+), 43 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index 9a401f5d1..a2ece78e6 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -67,7 +67,7 @@ def put( self, state: DisjointSubcircuitsState, depth: int, - cost: int | float | tuple[int | float, int | float], + cost: float | tuple[float, float], ) -> None: """Push state onto the priority queue. @@ -81,7 +81,7 @@ def put( def get( self, ) -> tuple: - """Return the lowest cost state currently on the queue, along with the search depth of that state and its cost. + """Return the lowest cost state currently on the queue, along with its depth and cost. None, None, None is returned if the priority queue is empty. """ @@ -238,10 +238,13 @@ def optimization_pass( tuple[None, None] | tuple[ DisjointSubcircuitsState | None, - int | float | tuple[int | float, int | float], + float | tuple[float, float], ] ): - """Perform best-first search until either a goal state is reached, or cost-bounds are reached or no further goal states can be found. + """Perform best-first search. + + Run until either a goal state is reached, + or cost-bounds are reached or no further goal states can be found. If no further goal states can be found, None is returned. The cost of the returned state is also returned. Any input arguments to @@ -317,13 +320,11 @@ def get_stats(self, penultimate: bool = False) -> NDArray[np.int_] | None: def get_upperbound_cost( self, - ) -> int | float | tuple[int | float, int | float] | None: + ) -> float | tuple[float, float] | None: """Return the current upperbound cost.""" return self.upperbound_cost - def update_upperbound_cost( - self, cost_bound: int | float | tuple[int | float, int | float] - ) -> None: + def update_upperbound_cost(self, cost_bound: float | tuple[float, float]) -> None: """Update the cost upper bound based on an input cost bound.""" if cost_bound is not None and ( self.upperbound_cost is None or cost_bound < self.upperbound_cost @@ -361,7 +362,7 @@ def put( self.num_enqueues += 1 def update_minimum_reached( - self, min_cost: None | int | float | tuple[int | float, int | float] + self, min_cost: None | float | tuple[float, float] ) -> bool: """Update the min_reached flag indicating that a global optimum has been reached.""" if min_cost is None or ( @@ -371,9 +372,7 @@ def update_minimum_reached( return self.min_reached - def cost_bounds_exceeded( - self, cost: None | int | float | tuple[int | float, int | float] - ) -> bool: + def cost_bounds_exceeded(self, cost: None | float | tuple[float, float]) -> bool: """Return True if any cost bounds have been exceeded.""" return cost is not None and ( (self.mincost_bound is not None and cost > self.mincost_bound) diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index e89d5c438..9fa1fc555 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -49,7 +49,7 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: if inst.operation.name == "barrier" and len(inst.qubits) == circuit.num_qubits: circuit_element: CircuitElement | str = "barrier" else: - gamma: int | float | None = None + gamma = None if isinstance(inst.operation, Gate) and len(inst.qubits) == 2: gamma = QPDBasis.from_instruction(inst.operation).kappa name = inst.operation.name diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 4c1d7379e..cd9de2a20 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -26,7 +26,7 @@ class CircuitElement(NamedTuple): name: str params: Sequence[float | int] qubits: Sequence[int | tuple[str, int]] - gamma: int | float | None + gamma: float | None class GateSpec(NamedTuple): @@ -206,7 +206,6 @@ def get_multiqubit_gates( subcircuit: list[GateSpec] = list() for k, circ_element in enumerate(self.circuit): gate = circ_element[0] - gate = cast(CircuitElement, gate) cut_constraints = circ_element[1] assert cut_constraints is None if gate != "barrier": @@ -336,7 +335,8 @@ def export_subcircuits_as_string( for k, subcircuit in enumerate(self.subcircuits): subcircuit = cast(list, subcircuit) for wire in subcircuit: - out[wire_map[wire]] = alphabet[k] # type: ignore + wire_map = cast(list, wire_map) + out[wire_map[wire]] = alphabet[k] return "".join(out) def make_wire_mapping( diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index a61bbc118..5765fe824 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -26,7 +26,7 @@ SearchSpaceGenerator, ) from .disjoint_subcircuits_state import DisjointSubcircuitsState -from .circuit_interface import SimpleGateList, CircuitElement, GateSpec +from .circuit_interface import SimpleGateList, GateSpec from .optimization_settings import OptimizationSettings from .quantum_device_constraints import DeviceConstraints @@ -43,7 +43,7 @@ class CutOptimizationFuncArgs: def cut_optimization_cost_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs -) -> tuple[int | float, int]: +) -> tuple[float, int]: """Return the cost function. The particular cost function chosen here aims to minimize the gamma @@ -57,7 +57,7 @@ def cut_optimization_cost_func( def cut_optimization_upper_bound_cost_func( goal_state, func_args: CutOptimizationFuncArgs -) -> tuple[int | float, int | float]: +) -> tuple[float, float]: """Return the gamma upper bound.""" # pylint: disable=unused-argument return (goal_state.upper_bound_gamma(), np.inf) @@ -65,7 +65,7 @@ def cut_optimization_upper_bound_cost_func( def cut_optimization_min_cost_bound_func( func_args: CutOptimizationFuncArgs, -) -> tuple[int | float, int | float] | None: +) -> tuple[float, float] | None: """Return an a priori min-cost bound defined in the optimization settings.""" if func_args.max_gamma is None: # pragma: no cover return None @@ -89,7 +89,6 @@ def cut_optimization_next_state_func( # placed on how the current entangling gate is to be handled. gate = gate_spec.gate - gate = cast(CircuitElement, gate_spec.gate) if len(gate.qubits) == 2: action_list = func_args.search_actions.get_group("TwoQubitGates") else: @@ -98,7 +97,6 @@ def cut_optimization_next_state_func( ) gate_actions = gate_spec.cut_constraints - gate_actions = cast(list, gate_actions) action_list = get_action_subset(action_list, gate_actions) # Apply the search actions to generate a list of next states. @@ -272,7 +270,7 @@ def __init__( self.search_engine = sq self.goal_state_returned = False - def optimization_pass(self) -> tuple[DisjointSubcircuitsState, int | float]: + def optimization_pass(self) -> tuple[DisjointSubcircuitsState, float]: """Produce, at each call, a goal state representing a distinct set of cutting decisions. None is returned once no additional choices @@ -296,13 +294,11 @@ def get_stats(self, penultimate: bool = False) -> NDArray[np.int_]: """Return the search-engine statistics.""" return self.search_engine.get_stats(penultimate=penultimate) - def get_upperbound_cost(self) -> tuple[int | float, int | float]: + def get_upperbound_cost(self) -> tuple[float, float]: """Return the current upperbound cost.""" return self.search_engine.get_upperbound_cost() - def update_upperbound_cost( - self, cost_bound: tuple[int | float, int | float] - ) -> None: + def update_upperbound_cost(self, cost_bound: tuple[float, float]) -> None: """Update the cost upper bound based on an input cost bound.""" self.search_engine.update_upperbound_cost(cost_bound) @@ -318,7 +314,9 @@ def max_wire_cuts_circuit(circuit_interface: SimpleGateList) -> int: loss of generality we can assume that wire cutting is performed only on the inputs to multiqubit gates. """ - multiqubit_wires = [len(x.gate.qubits) for x in circuit_interface.get_multiqubit_gates()] # type: ignore + multiqubit_wires = [ + len(x.gate.qubits) for x in circuit_interface.get_multiqubit_gates() + ] return sum(multiqubit_wires) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 00b5d3488..c87fe6b6a 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -74,7 +74,7 @@ def next_state_primitive( self, state: DisjointSubcircuitsState, gate_spec: GateSpec, - max_width: int | float, + max_width: int, ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionApplyGate` to state given ``gate_spec``.""" gate = gate_spec.gate @@ -156,16 +156,15 @@ def next_state_primitive( new_state.assert_donot_merge_roots(r1, r2) - gamma_LB = cast(int, gamma_LB) - new_state.gamma_LB = cast(int, new_state.gamma_LB) + new_state.gamma_LB = cast(float, new_state.gamma_LB) new_state.gamma_LB *= gamma_LB for k in range(num_bell_pairs): new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) - gamma_UB = cast(int, gamma_UB) - new_state.gamma_UB = cast(int, new_state.gamma_UB) + gamma_UB = cast(float, gamma_UB) + new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.gamma_UB *= gamma_UB new_state.add_action(self, gate_spec, ((1, w1), (2, w2))) @@ -175,7 +174,7 @@ def next_state_primitive( @staticmethod def get_cost_params( gate_spec: GateSpec, - ) -> tuple[int | float | None, int, int | float | None]: + ) -> tuple[float | None, int, float | None]: """ Get the cost parameters for gate cuts. @@ -198,7 +197,6 @@ def export_cuts( ) -> None: """Insert an LO gate cut into the input circuit for the specified gate and cut arguments.""" # pylint: disable=unused-argument - assert isinstance(gate_spec.instruction_id, int) circuit_interface.insert_gate_cut(gate_spec.instruction_id, "LO") @@ -256,7 +254,7 @@ def next_state_primitive( new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) - new_state.gamma_UB = cast(int, new_state.gamma_UB) + new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.gamma_UB *= 4 new_state.add_action(self, gate_spec, (1, w1, rnew)) @@ -286,7 +284,6 @@ def insert_all_lo_wire_cuts( ) -> None: """Insert LO wire cuts into the input circuit for the specified gate and all cut arguments.""" gate_ID = gate_spec.instruction_id - gate_ID = cast(int, gate_ID) for input_ID, wire_ID, new_wire_ID in cut_args: circuit_interface.insert_wire_cut( gate_ID, input_ID, wire_map[wire_ID], wire_map[new_wire_ID], "LO" @@ -312,6 +309,7 @@ def next_state_primitive( ) -> list[DisjointSubcircuitsState]: """Return the new state that results from applying :class:`ActionCutRightWire` to state given the gate_spec.""" gate = gate_spec.gate + # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 0faf6b222..7b2ae8476 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -57,7 +57,7 @@ class CutIdentifier(NamedTuple): gate_cut_location: GateCutLocation -# Used for dentifying CutLeftWire and CutRightWire actions. +# Used for identifying CutLeftWire and CutRightWire actions. class OneWireCutIdentifier(NamedTuple): """Named tuple for specification of location of :class:`CutLeftWire` or :class:`CutRightWire` instances.""" diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 2021c485b..d276b6042 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -40,7 +40,7 @@ class OptimizationSettings: flags have been incorporated with an eye towards future releases. """ - max_gamma: int = 1024 + max_gamma: float = 1024 max_backjumps: int = 10000 rand_seed: int | None = None LO: bool = True @@ -64,7 +64,7 @@ def __post_init__(self): if self.engine_selections is None: self.engine_selections = {"CutOptimization": "BestFirst"} - def get_max_gamma(self) -> int: + def get_max_gamma(self) -> float: """Return the constraint on the maxiumum allowed value of gamma.""" return self.max_gamma diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index d556632ce..d66b17355 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -159,7 +159,7 @@ class SearchFunctions: cost_func: ( Callable[ [DisjointSubcircuitsState, CutOptimizationFuncArgs], - int | float | tuple[int | float, int | float], + float | tuple[float, float], ] | None ) = None @@ -179,13 +179,13 @@ class SearchFunctions: upperbound_cost_func: ( Callable[ [DisjointSubcircuitsState, CutOptimizationFuncArgs], - tuple[int | float, int | float], + tuple[float, float], ] | None ) = None mincost_bound_func: ( - Callable[[CutOptimizationFuncArgs], None | tuple[int | float, int | float]] + Callable[[CutOptimizationFuncArgs], None | tuple[float, float]] | None ) = None From bfd9411921439981887ec13c9a81ba9d70efd21a Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 11 Mar 2024 11:22:00 -0400 Subject: [PATCH 090/128] style --- .../cutting/cut_finding/search_space_generator.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index d66b17355..b992608d5 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -24,7 +24,9 @@ class ActionNames: - """Map action names to individual action objects and group names to lists of action objects that are used to generate a search space. + """Map action names to individual action objects and group names to lists of action objects. + + The action objects are used to generate a search space. Member Variables: @@ -44,7 +46,7 @@ def __init__(self): def copy( self, list_of_groups: list[DisjointSearchAction | None] | None = None ) -> ActionNames: - """Return a copy of :class:`ActionNames` containing only those actions whose group affiliations intersect with list_of_groups. + """Return a copy of :class:`ActionNames` containing only those actions whose group affiliations intersect with ``list_of_groups``. The default is to return a copy containing all actions. """ @@ -185,8 +187,7 @@ class SearchFunctions: ) = None mincost_bound_func: ( - Callable[[CutOptimizationFuncArgs], None | tuple[float, float]] - | None + Callable[[CutOptimizationFuncArgs], None | tuple[float, float]] | None ) = None From 7ffeb4177a744b195780b713beca451995f5e421 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 14 Mar 2024 17:20:25 -0400 Subject: [PATCH 091/128] Add tests, add qubit list to output. --- .../cutting/cut_finding/best_first_search.py | 141 +++++++++--------- .../cutting/cut_finding/cco_utils.py | 19 ++- .../cutting/cut_finding/circuit_interface.py | 46 +++--- .../cutting/cut_finding/cut_optimization.py | 74 +++++---- .../cutting/cut_finding/cutting_actions.py | 34 ++--- .../cut_finding/disjoint_subcircuits_state.py | 96 +++++++----- .../cutting/cut_finding/lo_cuts_optimizer.py | 22 +-- .../cut_finding/optimization_settings.py | 16 +- .../cut_finding/search_space_generator.py | 58 +++---- .../tutorials/LO_circuit_cut_finder.ipynb | 28 ++-- .../cut_finding/test_cut_finder_roundtrip.py | 37 +++-- .../cut_finding/test_cutting_actions.py | 31 ++-- .../test_disjoint_subcircuits_state.py | 45 +++--- 13 files changed, 346 insertions(+), 301 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index a2ece78e6..eed2c4518 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -33,7 +33,9 @@ class BestFirstPriorityQueue: The tuples that are pushed onto the priority queues have the form: - (, , , , ) + (, , , , ), + + where: (numeric or tuple) is a numeric cost or tuple of numeric lexically-ordered costs that are to be minimized. @@ -104,80 +106,82 @@ def clear(self) -> None: class BestFirstSearch: """Implement Dijkstra's best-first search algorithm. - The search proceeds by choosing the deepest, lowest-cost state in the search - frontier and generating next states. Successive calls to - :meth:`BestFirstSearch.optimization_pass()` will resume the search at the next deepest, - lowest-cost state in the search frontier. The costs of goal states that are returned - are used to constrain subsequent searches. None is returned if no - (additional) feasible solutions can be found, or when no (additional) - solutions can be found without exceeding the lowest upper-bound cost - across the goal states previously returned. + The search proceeds by choosing the deepest, lowest-cost state + in the search frontier and generating next states. Successive calls to + :meth:`BestFirstSearch.optimization_pass` will resume the search at + the next deepest, lowest-cost state in the search frontier. The costs + of goal states that are returned are used to constrain subsequent searches. + None is returned if no (additional) feasible solutions can be found, or + when no (additional) solutions can be found without exceeding the lowest + upper-bound cost across the goal states previously returned. + + Member Variables: - Member Variables: + ``rand_seed`` (int) is the seed to use when initializing Numpy random number + generators in :class:`BestFirstPriorityQueue` instances. - rand_seed (int) is the seed to use when initializing Numpy random number - generators in the bounded best-first priority-queue objects. + ``cost_func`` is a function that computes cost values from search states. + Input arguments to :meth:`BestFirstSearch.optimization_pass` are also passed + to the ``cost_func``. The cost returned can be numeric or tuples of numerics. + In the latter case, lexicographical comparisons are performed per Python semantics. - cost_func (lambda state, *args) is a function that computes cost values - from search states. Input arguments to :meth:`BestFirstSearch.optimization_pass()`are - also passed to the cost_func. The cost returned can be numeric or tuples - of numerics. In the latter case, lexicographical comparisons are - performed per Python semantics. - next_state_func (lambda state, *args) is a function that returns a list - of next states generated from the input state. Input arguments to - :meth:`BestFirstSearch.optimization_pass() are also passed to the next_state_func. + ``next_state_func`` is a function that returns a list + of next states generated from the input state. Input arguments to + to :meth:`BestFirstSearch.optimization_pass` are also passed to + the ``next_state_func``. - goal_state_func (lambda state, *args) is a function that returns True if - the input state is a solution state of the search. Input arguments to - :meth:`BestFirstSearch.optimization_pass() are also passed to the goal_state_func. + ``goal_state_func`` is a function that returns True if + the input state is a solution state of the search. Input arguments to + :meth:`BestFirstSearch.optimization_pass` are also passed to the ``goal_state_func``. - upperbound_cost_func (lambda goal_state, *args) can either be None or a - function that returns an upper bound to the optimal cost given a goal_state - as input. The upper bound is used to prune next-states from the search in - subsequent calls :meth:`BestFirstSearch.optimization_pass(). If upperbound_cost_func - is None, the cost of the goal_state as determined by cost_func is used as - an upper bound to the optimal cost. Input arguments to :meth:`BestFirstSearch.optimization_pass() - are also passed to the upperbound_cost_func. + ``upperbound_cost_func`` can either be None or a function that returns + an upper bound to the optimal cost given a goal_state as input. + The upper bound is used to prune next-states from the search in + subsequent calls :meth:`BestFirstSearch.optimization_pass`. + If upperbound_cost_funcis None, the cost of the ``goal_state`` as + determined by cost_func is used asan upper bound to the optimal cost. + Input arguments to :meth:`BestFirstSearch.optimization_pass` + are also passed to the ``upperbound_cost_func``. - mincost_bound_func (lambda *args) can either be None or a function that - returns a cost bound that is compared to the minimum cost across all - vertices in a search frontier. If the minimum cost exceeds the min-cost - bound, the search is terminated even if a goal state has not yet been found. - A mincost_bound_func that is None is equivalent to an infinite min-cost bound. + ``mincost_bound_func`` can either be None or a function that + returns a cost bound that is compared to the minimum cost across all + vertices in a search frontier. If the minimum cost exceeds the min-cost + bound, the search is terminated even if a goal state has not yet been found. + A ``mincost_bound_func`` that is None is equivalent to an infinite min-cost bound. - stop_at_first_min (Boolean) is a flag that indicates whether or not to - stop the search after the first minimum-cost goal state has been reached. + ``stop_at_first_min`` (Boolean) is a flag that indicates whether or not to + stop the search after the first minimum-cost goal state has been reached. - max_backjumps (int or None) is the maximum number of backjump operations that - can be performed before the search is forced to terminate. None indicates - that no restriction is placed in the number of backjump operations. + ``max_backjumps`` (int or None) is the maximum number of backjump operations that + can be performed before the search is forced to terminate. None indicates + that no restriction is placed on the number of backjump operations. - pqueue (:class:`BestFirstPriorityQueue`) is an instance of :class:`BestFirstPriorityQueue`. + ``pqueue`` is an instance of :class:`BestFirstPriorityQueue`. - upperbound_cost (float or tuple) is the cost bound obtained by applying - the upperbound_cost_func to the goal states that are encountered. + ``upperbound_cost`` (float or tuple) is the cost bound obtained by applying + the upperbound_cost_func to the goal states that are encountered. - mincost_bound (float or tuple) is the cost bound imposed on the minimum - cost across all vertices in the search frontier. The search is forced to - terminate when the minimum cost exceeds this cost bound. + ``mincost_bound`` (float or tuple) is the cost bound imposed on the minimum + cost across all vertices in the search frontier. The search is forced to + terminate when the minimum cost exceeds this cost bound. - min_reached (Boolean) is a flag that indicates whether or not the - first minimum-cost goal state has been reached. + ``min_reached`` (Boolean) is a flag that indicates whether or not the + first minimum-cost goal state has been reached. - num_states_visited (int) is the number of states that have been dequeued - and processed in the search. + ``num_states_visited`` (int) is the number of states that have been dequeued + and processed in the search. - num_next_states (int) is the number of next-states generated from the - states visited. + ``num_next_states`` (int) is the number of next-states generated from the + states visited. - num_enqueues (int) is the number of next-states pushed onto the search - priority queue after cost pruning. + ``num_enqueues`` (int) is the number of next-states pushed onto the search + priority queue after cost pruning. - num_backjumps (int) is the number of times a backjump operation is - performed. In the case of best-first search, a backjump occurs when the - depth of the lowest-cost state in the search frontier is less than or - equal to the depth of the previous lowest-cost state. + ``num_backjumps`` (int) is the number of times a backjump operation is + performed. In the case of (Dijkstra's) best-first search, a backjump + occurs when the depth of the lowest-cost state in the search frontier + is less than or equal to the depth of the previous lowest-cost state. """ def __init__( @@ -190,9 +194,9 @@ def __init__( In addition to specifying the optimization settings and the functions used to perform the search, an optional Boolean flag - can be provided to indicate whether to stop the search - after the first minimum-cost goal state has been reached (True), - or whether subsequent calls to :meth:`BestFirstSearch.optimization_pass() should + can be provided to indicate whether to stop the search after + the first minimum-cost goal state has been reached (True), or whether + subsequent calls to :meth:`BestFirstSearch.optimization_pass` should return any additional minimum-cost goal states that might exist (False). """ @@ -244,11 +248,14 @@ def optimization_pass( """Perform best-first search. Run until either a goal state is reached, - or cost-bounds are reached or no further goal states can be found. - - If no further goal states can be found, None is returned. - The cost of the returned state is also returned. Any input arguments to - :func:`optimization_pass` are passed along to the search-space functions employed. + or cost-bounds are reached or no further + goal states can be found. + + If no further goal states can be found, + None is returned. The cost of the returned + state is also returned. Any input arguments to + :meth:`optimization_pass` are passed along to + the search-space functions employed. """ if self.mincost_bound_func is not None: self.mincost_bound = self.mincost_bound_func(*args) # type: ignore @@ -373,7 +380,7 @@ def update_minimum_reached( return self.min_reached def cost_bounds_exceeded(self, cost: None | float | tuple[float, float]) -> bool: - """Return True if any cost bounds have been exceeded.""" + """Return True if any cost bounds have been exceeded.""" return cost is not None and ( (self.mincost_bound is not None and cost > self.mincost_bound) or (self.upperbound_cost is not None and cost > self.upperbound_cost) diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index 9fa1fc555..f57a83431 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, cast, Callable if TYPE_CHECKING: - from .cut_optimization import CutOptimizationFuncArgs + from .cut_optimization import CutOptimizationFuncArgs # pragma: no cover from .disjoint_subcircuits_state import DisjointSubcircuitsState from .search_space_generator import SearchFunctions from .best_first_search import BestFirstSearch @@ -65,6 +65,7 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: return circuit_list_rep +# currently not in use, written up for future use. def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: """Convert the cut circuit outputted by the cut finder into a :class:`qiskit.QuantumCircuit` instance. @@ -74,7 +75,7 @@ def cco_to_qc_circuit(interface: SimpleGateList) -> QuantumCircuit: Returns: qc_cut: The SimpleGateList converted into a :class:`qiskit.QuantumCircuit` instance. - TODO: This is a function that is not used for now and it only works for instances of LO gate cutting. + TODO: This function only works for instances of LO gate cutting. Expand to cover the wire cutting case if or when needed. """ cut_circuit_list = interface.export_cut_circuit(name_mapping=None) @@ -99,7 +100,10 @@ def select_search_engine( ) -> BestFirstSearch: """Select the search algorithm to use. - In this release, only Dijkstra's algorithm for best first search is supported. + In this release, the main search engine is always Dijkstra's best first search algorithm. + Note however that there is also :func:``greedy_best_first_search,`` which is used to warm start + the search algorithm. It can also provide a solution should the main search engine fail to find a + solution given the constraints on the computation it is allowed to perform. """ engine = optimization_settings.get_engine_selection(stage_of_optimization) @@ -121,8 +125,8 @@ def greedy_best_first_search( ) -> None | DisjointSubcircuitsState: """Perform greedy best-first search using the input starting state and the input search-space functions. - The resulting goal state is returned, or None if a deadend is reached (no backtracking is performed). Any - additional input arguments are passed as additional arguments to the search-space functions. + The resulting goal state is returned, or None if a deadend is reached. Any additional input argumnets + are passed as additional arguments to the search-space functions. """ search_space_funcs.goal_state_func = cast( Callable, search_space_funcs.goal_state_func @@ -148,5 +152,8 @@ def greedy_best_first_search( if best[-1] is not None: return greedy_best_first_search(best[-1], search_space_funcs, *args) - else: + # The else block below covers a rare edge case + # which needs a clever circuit to get tested. + # Excluding from test coverage for now. + else: # pragma: no cover return None diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index cd9de2a20..1a6cbefd2 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -92,7 +92,7 @@ def define_subcircuits(self, list_of_list_of_wires): class SimpleGateList(CircuitInterface): - """Convert a simple list of gates into the form needed by the circuit-cutting optimizer code. + """Convert a simple list of gates into the form needed by the optimizer. Elements of the input list must be instances of :class:`CircuitElement`. The only exception to this is a barrier when one is placed across @@ -106,17 +106,17 @@ class SimpleGateList(CircuitInterface): preferred ordering in the assignment of numeric qubit IDs to each name. Member Variables: - qubit_names (NametoIDMap): an instance of :class:`NametoIDMap` that maps + `qubit_names` (NametoIDMap): an instance of :class:`NametoIDMap` that maps qubit names to numerical qubit IDs. - num_qubits (int): the number of qubits in the input circuit. Qubit IDs + `num_qubits` (int): the number of qubits in the input circuit. Qubit IDs whose values are greater than or equal to num_qubits represent qubits that were introduced as the result of wire cutting. These qubits are - assigned generated names of the form ('cut', ) in the - qubit_names object, where is the name of the wire/qubit + assigned generated names of the form ('cut', ) in + ``qubit_names``, where is the name of the wire/qubit that was cut to create the new wire/qubit. - circuit (list): the internal representation of the circuit, which is + `circuit` (list): the internal representation of the circuit, which is a list of the following form: [ ... [, None] ...] @@ -126,24 +126,24 @@ class SimpleGateList(CircuitInterface): Moreover the qubit names have been replaced with qubit IDs in the gate specification. - new_circuit (list): a list that defines the cut circuit. + `new_circuit` (list): a list that defines the cut circuit. the cut circuit. In the absence of wire cuts, it has the form [......] The form of is as mentioned above. As with ``circuit``, qubit IDs are used to identify wires/qubits. After wire cuts ``new_circuit``has lists of the form - ["move", source_wire_id, destination_wire_id] inserted into it. + ["move", , ] inserted into it. - cut_type (list): a list that assigns cut-type annotations to gates + `cut_type` (list): a list that assigns cut-type annotations to gates in ``new_circuit``. - new_gate_ID_map (list): a list that maps the positions of gates + `new_gate_ID`_map (list): a list that maps the positions of gates in circuit to their new positions in ``new_circuit``. - output_wires (list): a list that maps qubit IDs in circuit to the corresponding + `output_wires` (list): a list that maps qubit IDs in circuit to the corresponding output wires of new_circuit so that observables defined for circuit can be remapped to ``new_circuit``. - subcircuits (list): a list of list of wire IDs, where each list of + `subcircuits` (list): a list of list of wire IDs, where each list of wire IDs defines a subcircuit. """ @@ -291,7 +291,7 @@ def export_cut_circuit( If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then the default_wire_name_mapping() method defines the name mapping. + then :meth:``default_wire_name_mapping()`` defines the name mapping. """ wire_map = self.make_wire_mapping(name_mapping) out = copy.deepcopy(self.new_circuit) @@ -310,7 +310,7 @@ def export_output_wires( If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then the default_wire_name_mapping() method defines the name mapping. + then :meth:``SimpleGateList.default_wire_name_mapping()`` defines the name mapping. """ wire_map = self.make_wire_mapping(name_mapping) out = dict() @@ -344,8 +344,8 @@ def make_wire_mapping( ) -> Sequence[int | tuple[str, int]]: """Return a wire-mapping list given an input specification of a name mapping. - If None is provided as the input name_mapping, then the original qubit names are mapped to themselves. - If "default" is used as the name_mapping, then the default_wire_name_mapping() method is used to define the name mapping. + If ``None ``is provided as the input name_mapping, then the original qubit names are mapped to themselves. + If "default" is used as the ``name_mapping``, then :meth:``default_wire_name_mapping`` is used to define the name mapping. """ if name_mapping is None: name_mapping = dict() @@ -367,7 +367,7 @@ def default_wire_name_mapping(self) -> dict[Hashable, int]: """Return a dictionary that maps wire names to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric IDs that are adjacent to the numeric ID of the wire prior to cutting so that Move - operators are then applied against adjacent qubits. This is ensured by the :func:`sort_order` method. + operators are then applied against adjacent qubits. This is ensured by :meth:`SimpleGateList.sort_order`. """ name_pairs = [(name, self.sort_order(name)) for name in self.get_wire_names()] @@ -380,7 +380,7 @@ def default_wire_name_mapping(self) -> dict[Hashable, int]: return name_map def sort_order(self, name: Hashable) -> int | float: - """Order numeric IDs of wires to enable :func:`default_wire_name_mapping`.""" + """Order numeric IDs of wires to enable :meth:`SimpleGateList.default_wire_name_mapping`.""" if isinstance(name, tuple): if name[0] == "cut": x = self.sort_order(name[1]) @@ -396,7 +396,7 @@ def replace_wire_ids( # wire_map: Sequence[int | tuple[str, int]], wire_map: list[int], ) -> None: - """Iterate through a list of gates and replace wire IDs with the values defined by the wire_map.""" + """Iterate through a list of gates and replace wire IDs with the values defined by the ``wire_map``.""" for inst in gate_list: if isinstance(inst, CircuitElement): for k in range(len(inst.qubits)): @@ -410,7 +410,7 @@ class NameToIDMap: """Class used to construct maps between hashable items (e.g., qubit names) and natural numbers (e.g., qubit IDs).""" def __init__(self, init_names: list[Hashable]): - """Allow the name dictionary to be initialized with the names in init_names in the order the names appear. + """Allow the name dictionary to be initialized with the names in ``init_names`` in the order the names appear. This is done in order to force a preferred ordering in the assigment of item IDs to those names. """ @@ -428,7 +428,7 @@ def get_id(self, item_name: Hashable) -> int: item ID is assigned. """ if item_name not in self.item_dict: - while self.next_id in self.id_dict: + while self.next_id in self.id_dict: # pragma: no cover self.next_id += 1 self.item_dict[item_name] = self.next_id @@ -448,9 +448,9 @@ def define_id(self, item_id: int, item_name: Hashable) -> None: self.id_dict[item_id] = item_name def get_name(self, item_id: int) -> Hashable | None: - """Return the name associated with the specified item ID. + """Return the name associated with the specified ``item_id``. - None is returned if item_ID does not (yet) exist. + None is returned if ``item_id`` does not (yet) exist. """ if item_id not in self.id_dict: return None diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 5765fe824..27286e2e0 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -46,10 +46,10 @@ def cut_optimization_cost_func( ) -> tuple[float, int]: """Return the cost function. - The particular cost function chosen here aims to minimize the gamma - while also (secondarily) giving preference to circuit partitionings - that balance the sizes of the resulting partitions, by minimizing the - maximum width across subcircuits. + The particular cost function chosen here aims to minimize the classical + overhead, gamma, while also (secondarily) giving preference to circuit + partitionings that balance the sizes of the resulting partitions, by + minimizing the maximum width across subcircuits. """ # pylint: disable=unused-argument return (state.lower_bound_gamma(), state.get_max_width()) @@ -58,7 +58,7 @@ def cut_optimization_cost_func( def cut_optimization_upper_bound_cost_func( goal_state, func_args: CutOptimizationFuncArgs ) -> tuple[float, float]: - """Return the gamma upper bound.""" + """Return the value of gamma computed assuming all LO cuts.""" # pylint: disable=unused-argument return (goal_state.upper_bound_gamma(), np.inf) @@ -66,7 +66,7 @@ def cut_optimization_upper_bound_cost_func( def cut_optimization_min_cost_bound_func( func_args: CutOptimizationFuncArgs, ) -> tuple[float, float] | None: - """Return an a priori min-cost bound defined in the optimization settings.""" + """Return the a priori min-cost bound defined in the optimization settings.""" if func_args.max_gamma is None: # pragma: no cover return None @@ -77,11 +77,12 @@ def cut_optimization_next_state_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> list[DisjointSubcircuitsState]: """Generate a list of next states from the input state.""" - # Get the entangling gate spec that is to be processed next based - # on the search level of the input state. assert func_args.entangling_gates is not None assert func_args.search_actions is not None + # Get the entangling gate spec that is to be processed next based + # on the search level of the input state. + gate_spec = func_args.entangling_gates[state.get_search_level()] # Determine which cutting actions can be performed, taking into @@ -117,7 +118,7 @@ def cut_optimization_goal_state_func( ### Global variable that holds the search-space functions for generating -### the cut optimization search space +### the cut optimization search space. cut_optimization_search_funcs = SearchFunctions( cost_func=cut_optimization_cost_func, upperbound_cost_func=cut_optimization_upper_bound_cost_func, @@ -134,7 +135,13 @@ def greedy_cut_optimization( search_space_funcs: SearchFunctions = cut_optimization_search_funcs, search_actions: ActionNames = disjoint_subcircuit_actions, ) -> DisjointSubcircuitsState | None: - """Peform a first pass at cut optimization using greedy best first search.""" + """Peform a first pass at cut optimization using greedy best first search. + + This step is effectively used to warm start our algorithm. It ignores the user + specified constraint ``max_gamma``. Its primary purpose is to estimate an upper + bound on the actual minimum gamma. Its secondary purpose is to provide a guaranteed + "anytime" solution (``). + """ func_args = CutOptimizationFuncArgs() func_args.entangling_gates = circuit_interface.get_multiqubit_gates() func_args.search_actions = search_actions @@ -155,34 +162,30 @@ class CutOptimization: Because of the condition of no qubit reuse, it is assumed that there is no circuit folding (i.e., when mid-circuit measurement and active - reset are not available). - - CutOptimization focuses on using circuit cutting to create disjoint subcircuits. - It then uses upper and lower bounds on the resulting - gamma in order to decide where and how to cut while deferring the exact - choices of quasiprobability decompositions. + reset are not available). Cuts are placed with the goal of finding + separable subcircuits. Member Variables: - circuit (:class:`CircuitInterface`) is the interface for the circuit + ``circuit`` (:class:`CircuitInterface`) is the interface for the circuit to be cut. - settings (:class:`OptimizationSettings`) contains the settings that + ``settings`` (:class:`OptimizationSettings`) contains the settings that control the optimization process. - constraints (:class:`DeviceConstraints`) contains the device constraints + ``constraints`` (:class:`DeviceConstraints`) contains the device constraints that solutions must obey. - search_funcs (:class:`SearchFunctions`) holds the functions needed to generate + ``search_funcs`` (:class:`SearchFunctions`) holds the functions needed to generate and explore the cut optimization search space. - func_args (:class:`CutOptimizationFuncArgs`) contains the necessary device constraints + ``func_args`` (:class:`CutOptimizationFuncArgs`) contains the necessary device constraints and optimization settings parameters that are needed by the cut optimization search-space function. - search_actions (:class:`ActionNames`) contains the allowed actions that are used to + ``search_actions`` (:class:`ActionNames`) contains the allowed actions that are used to generate the search space. - search_engine (:class`BestFirstSearch`) implements the search algorithm. + ``search_engine`` (:class`BestFirstSearch`) implements the search algorithm. """ def __init__( @@ -197,14 +200,7 @@ def __init__( ) }, ): - """Assign member variables. - - An instance of :class:`CutOptimization` must be initialized with - a specification of all of the parameters of the optimization to be - performed: i.e., the circuit to be cut, the optimization settings, - the target-device constraints, the functions for generating the - search space, and the allowed search actions. - """ + """Assign member variables.""" generator = search_engine_config["CutOptimization"] search_space_funcs = generator.functions search_space_actions = generator.actions @@ -237,15 +233,17 @@ def __init__( ################################################################################ # Use the upper bound for the optimal gamma to determine the maximum - # number of wire cuts that can be performed when allocating the - # data structures in the actual state. + # number of wire cuts that can be performed. max_wire_cuts = max_wire_cuts_circuit(self.circuit) if self.greedy_goal_state is not None: mwc = max_wire_cuts_gamma(self.greedy_goal_state.upper_bound_gamma()) max_wire_cuts = min(max_wire_cuts, mwc) - elif self.func_args.max_gamma is not None: + # The elif block below covers a rare edge case + # which would need a clever circuit to get tested. + # Excluding from test coverage for now. + elif self.func_args.max_gamma is not None: # pragma: no cover mwc = max_wire_cuts_gamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) @@ -273,9 +271,9 @@ def __init__( def optimization_pass(self) -> tuple[DisjointSubcircuitsState, float]: """Produce, at each call, a goal state representing a distinct set of cutting decisions. - None is returned once no additional choices - of cuts can be made without exceeding the minimum upper bound across - all cutting decisions previously returned, given the optimization settings. + None is returned once no additional choices of cuts can be made + without exceeding the minimum upper bound across all cutting + decisions previously returned. """ state, cost = self.search_engine.optimization_pass(self.func_args) if state is None and not self.goal_state_returned: @@ -321,5 +319,5 @@ def max_wire_cuts_circuit(circuit_interface: SimpleGateList) -> int: def max_wire_cuts_gamma(max_gamma: float | int) -> int: - """Calculate an upper bound on the maximum number of wire cuts that can be made given the maximum allowed gamma.""" + """Calculate an upper bound on the maximum number of wire cuts that can be made, given the maximum allowed gamma.""" return int(np.ceil(np.log2(max_gamma + 1) - 1)) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index c87fe6b6a..e92bab10c 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -21,7 +21,7 @@ from .disjoint_subcircuits_state import DisjointSubcircuitsState from .circuit_interface import GateSpec -# Object that holds action names for constructing disjoint subcircuits +# Global variable that holds action names for constructing disjoint subcircuits disjoint_subcircuit_actions = ActionNames() @@ -46,10 +46,10 @@ def next_state( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return a list of search states that result from applying the action to gate_spec in the specified :class:`DisjointSubcircuitsState` state. + """Return a list of search states that result from applying the action to ``gate_spec`` in the specified :class:`DisjointSubcircuitsState` state. This is subject to the constraint that the number of resulting qubits (wires) - in each subcircuit cannot exceed max_width. + in each subcircuit cannot exceed ``max_width``. """ next_list = self.next_state_primitive(state, gate_spec, max_width) @@ -76,7 +76,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionApplyGate` to state given ``gate_spec``.""" + """Return the new state that results from applying the gate given by ``gate_spec``.""" gate = gate_spec.gate # extract the root wire for the first qubit @@ -128,7 +128,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionCutTwoQubitGate` to state given ``gate_spec``.""" + """Return the state that results from cutting the gate given by ``gate_spec``.""" gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. @@ -139,7 +139,7 @@ def next_state_primitive( gamma_LB, num_bell_pairs, gamma_UB = self.get_cost_params(gate_spec) - if gamma_LB is None: + if gamma_LB is None: # pragma: no cover return list() q1 = gate.qubits[0] @@ -159,7 +159,7 @@ def next_state_primitive( new_state.gamma_LB = cast(float, new_state.gamma_LB) new_state.gamma_LB *= gamma_LB - for k in range(num_bell_pairs): + for k in range(num_bell_pairs): # pragma: no cover new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) @@ -179,7 +179,7 @@ def get_cost_params( Get the cost parameters for gate cuts. This method returns a tuple of the form: - (gamma_lower_bound, num_bell_pairs, gamma_upper_bound) + (, , ) Since CKT does not support LOCC at the moment, these tuples will be of the form (gamma, 0, gamma). @@ -200,7 +200,7 @@ def export_cuts( circuit_interface.insert_gate_cut(gate_spec.instruction_id, "LO") -### Adds ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions +### Add ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutTwoQubitGate()) @@ -221,7 +221,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionCutLeftWire` to state given the gate_spec.""" + """Return the state that results from cutting the left (first input) wire of the gate given by ``gate_spec``.""" gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. @@ -272,7 +272,7 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutLeftWire to the global variable disjoint_subcircuit_actions +### Add ActionCutLeftWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutLeftWire()) @@ -307,7 +307,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionCutRightWire` to state given the gate_spec.""" + """Return the state that results from cutting the right (second input) wire of the gate given by ``gate_spec``.""" gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. @@ -358,7 +358,7 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutRightWire to the global variable disjoint_subcircuit_actions +### Add ActionCutRightWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutRightWire()) @@ -379,7 +379,7 @@ def next_state_primitive( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return the new state that results from applying :class:`ActionCutBothWires` to state given the gate_spec.""" + """Return the new state that results from cutting both input wires of the gate given by ``gate_spec``.""" gate = gate_spec.gate # Cutting of multi-qubit gates is not supported in this release. @@ -389,11 +389,11 @@ def next_state_primitive( ) # If the wire-cut limit would be exceeded, return the empty list - if not state.can_add_wires(2): + if not state.can_add_wires(2): #pragma: no cover return list() # If the maximum width is less than two, return the empty list - if max_width < 2: + if max_width < 2: #pragma: no cover return list() q1 = gate.qubits[0] @@ -432,5 +432,5 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Adds ActionCutBothWires to the global variable disjoint_subcircuit_actions +### Add ActionCutBothWires to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutBothWires()) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 7b2ae8476..e9c93d434 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -18,14 +18,22 @@ from numpy.typing import NDArray from collections import Counter from .circuit_interface import SimpleGateList, GateSpec -from typing import Hashable, Iterable, TYPE_CHECKING, no_type_check, cast, NamedTuple +from typing import ( + Hashable, + Iterable, + TYPE_CHECKING, + no_type_check, + cast, + NamedTuple, + Sequence, +) if TYPE_CHECKING: # pragma: no cover from .cutting_actions import DisjointSearchAction class Action(NamedTuple): - """Named tuple for specification of cutting action.""" + """Named tuple for specification of search (cutting) action.""" action: DisjointSearchAction gate_spec: GateSpec @@ -37,6 +45,7 @@ class GateCutLocation(NamedTuple): instruction_id: int gate_name: str + qubits: Sequence class WireCutLocation(NamedTuple): @@ -47,6 +56,7 @@ class WireCutLocation(NamedTuple): instruction_id: int gate_name: str + qubits: Sequence input: int @@ -70,49 +80,49 @@ class DisjointSubcircuitsState: Each wire cut introduces a new wire. A mapping from qubit IDs in QASM-like statements to wire IDs is therefore created - and maintained. Groups of wires form subcircuits. The mapping + and maintained. Groups of wires form subcircuits. The mapping from wires to subcircuits is represented using an up-tree data structure over wires. The number of wires (width) in each subcircuit is also tracked to ensure subcircuits will fit on target quantum devices. Member Variables: - wiremap: an int Numpy array that provides the mapping from qubit IDs + ``wiremap``: an int Numpy array that provides the mapping from qubit IDs to wire IDs. - num_wires: an int which is the number of wires in the cut circuit. + ``num_wires``: an int which is the number of wires in the cut circuit. - uptree: an int Numpy array that contains the uptree data structure that - defines groups of wires that form subcircuits. The uptree array - map wire IDs to parent wire IDs in a subcircuit. If a wire points + ``uptree``: an int Numpy array that contains the uptree data structure that + defines groups of wires that form subcircuits. The uptree array + map wire IDs to parent wire IDs in a subcircuit. If a wire points to itself, then that wire is the root wire in the corresponding - subcircuit. Otherwise, you need to follow the parent links to find + subcircuit. Otherwise, you need to follow the parent links to find the root wire that corresponds to that subcircuit. - width: an int Numpy array that contains the number of wires in each + ``width``: an int Numpy array that contains the number of wires in each subcircuit. The values of width are valid only for root wire IDs. - bell_pairs: a list of pairs of subcircuits (wires) that + ``bell_pairs``: a list of pairs of subcircuits (wires) that define the virtual Bell pairs that would need to be constructed in order to implement optimal LOCC wire and gate cuts using ancillas. - gamma_LB: a float that is the cumulative lower-bound gamma for circuit cuts - that cannot be constructed using Bell pairs. + ``gamma_LB``: a float that is the cumulative lower-bound gamma for LOCC + circuit cuts that cannot be constructed using Bell pairs. - gamma_UB: a float that is the cumulative upper-bound gamma for all circuit - cuts assuming all cuts are LO. + ``gamma_UB``: a float that is the cumulative upper-bound gamma for all + circuit cuts assuming all cuts are LO. - no_merge: a list that contains a list of subcircuit merging constaints. + ``no_merge``: a list that contains a list of subcircuit merging constaints. Each constraint can either be a pair of wire IDs or a list of pairs - of wire IDs. In the case of a pair of wire IDs, the constraint is + of wire IDs. In the case of a pair of wire IDs, the constraint is that the subcircuits that contain those wire IDs cannot be merged - by subsequent search actions. In the case of a list of pairs of + by subsequent search actions. In the case of a list of pairs of wire IDs, the constraint is that at least one pair of corresponding subcircuits cannot be merged. - actions: a list of instances of :class:`Action`. + ``actions``: a list of instances of :class:`Action`. - level: an int which specifies the level in the search tree at which this search + ``level``: an int which specifies the level in the search tree at which this search state resides, with 0 being the root of the search tree. """ @@ -209,6 +219,7 @@ def cut_actions_sublist(self) -> list[NamedTuple]: WireCutLocation( cut_actions[i].gate_spec.instruction_id, cut_actions[i].gate_spec.gate.name, + cut_actions[i].gate_spec.gate.qubits, cut_actions[i].args[0][0], ), ) @@ -224,10 +235,11 @@ def cut_actions_sublist(self) -> list[NamedTuple]: GateCutLocation( cut_actions[i].gate_spec.instruction_id, cut_actions[i].gate_spec.gate.name, + cut_actions[i].gate_spec.gate.qubits, ), ) ) - if not self.cut_actions_list: + if not self.cut_actions_list: # pragma: no cover self.cut_actions_list = cut_actions return self.cut_actions_list @@ -273,13 +285,16 @@ def get_wire_root_mapping(self) -> list[int]: return [self.find_wire_root(i) for i in range(self.num_wires)] def find_root_bell_pair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: - """Find the root wires for a Bell pair (represented as a pair of wires) and return a sorted tuple representing the Bell pair.""" + """Find the root wires for a Bell pair (represented as a pair of wires). + + Additionally, return a sorted tuple representing the Bell pair. + """ r0 = self.find_wire_root(bell_pair[0]) r1 = self.find_wire_root(bell_pair[1]) return (r0, r1) if (r0 < r1) else (r1, r0) def lower_bound_gamma(self) -> float: - """Calculate a lower bound for gamma using the current counts for the different types of circuit cuts.""" + """Return a lower bound for gamma using the current counts for the circuit cuts involving bell pairs.""" self.bell_pairs = cast(list, self.bell_pairs) root_bell_pairs = map(lambda x: self.find_root_bell_pair(x), self.bell_pairs) @@ -287,23 +302,23 @@ def lower_bound_gamma(self) -> float: return self.gamma_LB * calc_root_bell_pairs_gamma(root_bell_pairs) def upper_bound_gamma(self) -> float: - """Calculate an upper bound for gamma using the current counts for the different types of circuit cuts.""" + """Return an upper bound for gamma using the current counts for the different types of (LO) circuit cuts.""" self.gamma_UB = cast(float, self.gamma_UB) return self.gamma_UB def can_add_wires(self, num_wires: int) -> bool: - """Return True if an additional num_wires can be cut without exceeding the maximum allowed number of wire cuts.""" + """Return ``True`` if an additional ``num_wires`` can be cut without exceeding the maximum allowed number of wire cuts.""" self.num_wires = cast(int, self.num_wires) self.uptree = cast(NDArray[np.int_], self.uptree) return self.num_wires + num_wires <= self.uptree.shape[0] def can_expand_subcircuit(self, root: int, num_wires: int, max_width: int) -> bool: - """Return True if num_wires can be added to subcircuit root without exceeding the maximum allowed number of qubits.""" + """Return ``True`` if ``num_wires`` can be added to subcircuit root without exceeding the maximum allowed number of qubits.""" self.width = cast(NDArray[np.int_], self.width) return self.width[root] + num_wires <= max_width def new_wire(self, qubit: Hashable) -> int: - """Cut the wire associated with qubit and return the ID of the new wire now associated with qubit.""" + """Cut the wire associated with ``qubit`` and return the ID of the new wire now associated with qubit.""" self.num_wires = cast(int, self.num_wires) self.uptree = cast(NDArray[np.int_], self.uptree) assert self.num_wires < self.uptree.shape[0], ( @@ -318,13 +333,16 @@ def new_wire(self, qubit: Hashable) -> int: return self.wiremap[qubit] def get_wire(self, qubit: Hashable) -> int: - """Return the ID of the wire currently associated with qubit.""" + """Return the ID of the wire currently associated with ``qubit``.""" self.wiremap = cast(NDArray[np.int_], self.wiremap) qubit = cast(int, qubit) return self.wiremap[qubit] def find_wire_root(self, wire: int) -> int: - """Return the ID of the root wire in the subcircuit that contains wire and collapse the path to the root.""" + """Return the ID of the root wire in the subcircuit that contains wire. + + Additionally, collapse the path to the root. + """ # Find the root wire in the subcircuit root = wire self.uptree = cast(NDArray[np.int_], self.uptree) @@ -340,13 +358,16 @@ def find_wire_root(self, wire: int) -> int: return root def find_qubit_root(self, qubit: Hashable) -> int: - """Return the ID of the root wire in the subcircuit currently associated with qubit and collapse the path to the root.""" + """Return the ID of the root wire in the subcircuit associated with ``qubit``. + + Additionally, collapse the path to the root. + """ self.wiremap = cast(NDArray[np.int_], self.wiremap) qubit = cast(int, qubit) return self.find_wire_root(self.wiremap[qubit]) def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: - """Return True if the subcircuits represented by root wire IDs root_1 and root_2 should not be merged.""" + """Return True if the subcircuits represented by root wire IDs ``root_1`` and ``root_2`` should not be merged.""" self.uptree = cast(NDArray[np.int_], self.uptree) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( "Arguments must be roots: " @@ -367,7 +388,7 @@ def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: return False def verify_merge_constraints(self) -> bool: - """Return True if all merge constraints are satisfied.""" + """Return ``True`` if all merge constraints are satisfied.""" self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: r1 = self.find_wire_root(clause[0]) @@ -378,7 +399,7 @@ def verify_merge_constraints(self) -> bool: return True def assert_donot_merge_roots(self, wire_1: int, wire_2: int) -> None: - """Add a constraint that the subcircuits associated with wires IDs wire_1 and wire_2 should not be merged.""" + """Add a constraint that the subcircuits associated with IDs ``wire_1`` and ``wire_2`` should not be merged.""" assert self.find_wire_root(wire_1) != self.find_wire_root( wire_2 ), f"{wire_1} cannot be the same subcircuit as {wire_2}" @@ -387,7 +408,10 @@ def assert_donot_merge_roots(self, wire_1: int, wire_2: int) -> None: self.no_merge.append((wire_1, wire_2)) def merge_roots(self, root_1: int, root_2: int) -> None: - """Merge the subcircuits associated with root wire IDs root_1 and root_2 update the statistics (i.e., width) associated with the newly merged subcircuit.""" + """Merge the subcircuits associated with root wire IDs ``root_1`` and ``root_2``. + + Additionally, update the statistics (i.e., width) associated with the merged subcircuit. + """ self.uptree = cast(NDArray[np.int_], self.uptree) self.width = cast(NDArray[np.int_], self.width) assert root_1 == self.uptree[root_1] and root_2 == self.uptree[root_2], ( @@ -420,7 +444,7 @@ def get_search_level(self) -> int: return self.level def set_next_level(self, state: DisjointSubcircuitsState) -> None: - """Set the search level of self to one plus the search level of the input state.""" + """Set the search level to one plus the search level of the input state.""" self.level = cast(int, self.level) state.level = cast(int, state.level) self.level = state.level + 1 @@ -471,5 +495,5 @@ def calc_root_bell_pairs_gamma(root_bell_pairs: Iterable[Hashable]) -> float: def get_actions_list( action_list: list[Action], ) -> list[Action]: - """Return a list specifying objects that represent cutting actions assoicated with an instance of :class:`DisjointSubcircuitsState`.""" + """Return a list of cutting actions that have been performed on a state.""" return action_list diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 534dbab3e..511d160f7 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -41,18 +41,18 @@ class LOCutsOptimizer: """Optimize circuit cuts for the case in which only LO decompositions are employed. - The search_engine_config dictionary that configures the optimization + The ``search_engine_config`` dictionary that configures the optimization algorithms must be specified in the constructor. For flexibility, the circuit_interface, optimization_settings, and device_constraints can - be specified either in the constructor or in :meth:LOCutsOptimizer.optimize(). + be specified either in the constructor or in :meth:`LOCutsOptimizer.optimize`. In the latter case, the values provided overwrite the previous values. - circuit_interface, an instance of :class:`CircuitInterface`, defines the circuit to be cut. - The circuit_interface object that is passed to the :meth:`LOCutsOptimizer.optimize()` + ``circuit_interface``, an instance of :class:`CircuitInterface`, defines the circuit to be cut. + The circuit_interface object that is passed to the :meth:`LOCutsOptimizer.optimize` is updated to reflect the optimized circuit cuts that were identified. - :meth:`LOCutsOptimizer.optimize()` returns ``best_result``, an instance of :class:`DisjointSubcircuitsState`, + :meth:`LOCutsOptimizer.optimize` returns ``best_result``, an instance of :class:`DisjointSubcircuitsState`, which is the lowest-cost :class:`DisjointSubcircuitsState` instance identified in the search. """ @@ -82,17 +82,17 @@ def optimize( optimization_settings: OptimizationSettings | None = None, device_constraints: DeviceConstraints | None = None, ) -> DisjointSubcircuitsState | None: - """Optimize the cutting of a circuit by calling :meth:`CutOptimization.optimization_pass()`. + """Optimize the cutting of a circuit by calling :meth:`CutOptimization.optimization_pass`. Args: - circuit_interface: defines the circuit to be + ``circuit_interface``: defines the circuit to be cut. This object is then updated with the optimized cuts that were identified. - optimization_settings: defines the settings + ``optimization_settings``: defines the settings to be used for the optimization. - device_constraints: the capabilties of + ``device_constraints``: the capabilties of the target quantum hardware. Returns: @@ -138,7 +138,7 @@ def optimize( if min_cost is not None: self.best_result = min_cost[-1] self.best_result.export_cuts(self.circuit_interface) - else: + else: # pragma: no cover self.best_result = None return self.best_result @@ -161,7 +161,7 @@ def minimum_reached(self) -> bool: def print_state_list( state_list: list[DisjointSubcircuitsState], ) -> None: # pragma: no cover - """Call the :meth:`print()` method defined for a :class:`DisjointSubcircuitsState` instance.""" + """Call :meth:`print` defined for a :class:`DisjointSubcircuitsState` instance.""" for x in state_list: print() x.print(simple=True) diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index d276b6042..899b9cf34 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -21,17 +21,19 @@ class OptimizationSettings: """Specify the parameters that control the optimization. - max_gamma specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered feasible. + ``max_gamma`` specifies a constraint on the maximum value of gamma that a + solution is allowed to have to be considered feasible. If a solution exists + but the associated gamma exceeds ``max_gamma``, :func:`.greedy_best_first_search`, + which is used to warm start, the search engine will still attempt to return a + solution. - engine_selections is a dictionary that defines the selection - of search engines for the optimization. In this release - only "BestFirst" or Dijkstra's best-first search is supported. + ``engine_selections`` is a dictionary that defines the selection + of search engines for the optimization. - max_backjumps specifies a constraint on the maximum number of backjump + ``max_backjumps`` specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - rand_seed is a seed used to provide a repeatable initialization + ``rand_seed`` is a seed used to provide a repeatable initialization of the pesudorandom number generators used by the optimization. If None is used as the random seed, then a seed is obtained using an operating-system call to achieve an unrepeatable randomized initialization. diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index b992608d5..07b76424d 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -30,9 +30,9 @@ class ActionNames: Member Variables: - action_dict: maps action names to action objects. + ``action_dict``: maps action names to action objects. - group_dict: maps group names to lists of action objects. + ``group_dict``: maps group names to lists of action objects. """ action_dict: dict[str, DisjointSearchAction] @@ -59,7 +59,7 @@ def copy( return new_container def define_action(self, action_object: DisjointSearchAction) -> None: - """Insert the specified action object into the look-up dictionaries using the name of the action and its group names.""" + """Insert the specified ``action_object`` into the look-up dictionaries using the name of the action and its group names.""" assert ( action_object.get_name() not in self.action_dict ), f"Action {action_object.get_name()} is already defined" @@ -79,18 +79,18 @@ def define_action(self, action_object: DisjointSearchAction) -> None: self.group_dict[group_name].append(action_object) def get_action(self, action_name: str) -> DisjointSearchAction | None: - """Return the action object associated with the specified name. + """Return the action object associated with the specified ``action_name``. - None is returned if there is no associated action object. + ``None`` is returned if there is no associated action object. """ if action_name in self.action_dict: return self.action_dict[action_name] return None - def get_group(self, group_name: str) -> list | None: - """Return the list of action objects associated with the group_name. + def get_group(self, group_name: str) -> list[DisjointSearchAction] | None: + """Return the list of action objects associated with ``group_name``. - None is returned if there are no associated action objects. + ``None`` is returned if there are no associated action objects. """ if group_name in self.group_dict: return self.group_dict[group_name] @@ -101,7 +101,7 @@ def get_action_subset( action_list: list[DisjointSearchAction] | None, action_groups: list[DisjointSearchAction | None] | None, ) -> list[DisjointSearchAction] | None: - """Return the subset of actions in action_list whose group affiliations intersect with action_groups.""" + """Return the subset of actions in ``action_list`` whose group affiliations intersect with ``action_groups``.""" if action_groups is None: return action_list @@ -126,36 +126,36 @@ class SearchFunctions: Member Variables: - cost_func (lambda state, *args) is a function that computes cost values - from search states. The cost returned can be numeric or tuples of - numerics. In the latter case, lexicographical comparisons are performed + ``cost_func``: a function that computes cost values + from search states. The cost returned can be numeric or tuples of + numerics. In the latter case, lexicographical comparisons are performed per Python semantics. - next_state_func (lambda state, *args) is a function that returns a list - of next states generated from the input state. An ActionNames object - should be incorporated into the additional input arguments in order to - generate next-states. + ``next_state_func``: a function that returns a list + of next states generated from the input state. An :class:`ActionNames` + instance should be incorporated into the additional input arguments + in order to generate next-states. - goal_state_func (lambda state, *args) is a function that returns True if + ``goal_state_func``: a function that returns ``True`` if the input state is a solution state of the search. - upperbound_cost_func (lambda goal_state, *args) can either be None or a - function that returns an upper bound to the optimal cost given a goal_state + ``upperbound_cost_func`` can either be ``None`` or a + function that returns an upper bound to the optimal cost given a ``goal_state`` as input. The upper bound is used to prune next-states from the search in - subsequent calls to the :func:`optimization_pass` method of the search algorithm. - If upperbound_cost_func is None, the cost of the goal_state as determined - by cost_func is used as an upper bound to the optimal cost. If the - upperbound_cost_func returns None, the effect is equivalent to returning + subsequent calls to the :meth:`optimization_pass` method of the search algorithm. + If upperbound_cost_func is ``None``, the cost of the ``goal_state`` as determined + by ``cost_func`` is used as an upper bound to the optimal cost. If the + ``upperbound_cost_func`` returns ``None``, the effect is equivalent to returning an infinite upper bound (i.e., no cost pruning is performed on subsequent - optimization calls. + optimization calls). - mincost_bound_func (lambda *args) can either be None or a function that + ``mincost_bound_func`` can either be ``None`` or a function that returns a cost bound that is compared to the minimum cost across all - vertices in a search frontier. If the minimum cost exceeds the min-cost + vertices in a search frontier. If the minimum cost exceeds the min-cost bound, the search is terminated even if a goal state has not yet been found. - Returning None is equivalent to returning an infinite min-cost bound (i.e., - min-cost checking is effectively not performed). A mincost_bound_func that - is None is likewise equivalent to an infinite min-cost bound. + Returning ``None`` is equivalent to returning an infinite min-cost bound (i.e., + min-cost checking is effectively not performed). A ``mincost_bound_func`` that + is ``None`` is likewise equivalent to an infinite min-cost bound. """ cost_func: ( diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 2d6e67a17..d7bb0a7f3 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -43,7 +43,7 @@ "
" ] }, - "execution_count": 2, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -87,14 +87,14 @@ "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx'))]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx'))]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", "Subcircuits: AABB \n", "\n" ] @@ -156,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -166,7 +166,7 @@ "
" ] }, - "execution_count": 4, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -196,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -214,35 +214,35 @@ "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 3.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx'))]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', input=1))]\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', input=1))]\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4], input=1))]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', input=1))]\n", + "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3], input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", " Gamma = 243.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx')), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx'))]\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", "Subcircuits: ABCDDEF \n", "\n" ] diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index 3537567f9..eb1945f52 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -29,6 +29,14 @@ from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization +@fixture +def empty_circuit(): + qc = QuantumCircuit(3) + qc.barrier([0]) + qc.barrier([1]) + qc.barrier([2]) + + @fixture def gate_cut_test_setup(): qc = EfficientSU2(4, entanglement="linear", reps=2).decompose() @@ -92,7 +100,7 @@ def test_no_cuts( def test_gate_cuts( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - # QPU with 2 qubits requires cutting. + # QPU with 2 qubits enforces cutting. qubits_per_QPU = 2 num_QPUs = 2 @@ -109,11 +117,15 @@ def test_gate_cuts( assert cut_actions_list == [ CutIdentifier( cut_action="CutTwoQubitGate", - gate_cut_location=GateCutLocation(instruction_id=9, gate_name="cx"), + gate_cut_location=GateCutLocation( + instruction_id=9, gate_name="cx", qubits=[1, 2] + ), ), CutIdentifier( cut_action="CutTwoQubitGate", - gate_cut_location=GateCutLocation(instruction_id=20, gate_name="cx"), + gate_cut_location=GateCutLocation( + instruction_id=20, gate_name="cx", qubits=[1, 2] + ), ), ] @@ -152,7 +164,7 @@ def test_wire_cuts( OneWireCutIdentifier( cut_action="CutLeftWire", wire_cut_location=WireCutLocation( - instruction_id=10, gate_name="cx", input=1 + instruction_id=10, gate_name="cx", qubits=[3, 4], input=1 ), ) ] @@ -208,7 +220,9 @@ def test_multiqubit_cuts( ) -def test_updated_cost_bounds( +# Even if the input cost bounds are too stringent, greedy_cut_optimization +# is able to return a solution. +def test_greedy_search( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): qubits_per_QPU = 3 @@ -218,14 +232,11 @@ def test_updated_cost_bounds( constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) - # Perform cut finding with the default cost upper bound. + # Impose a stringent cost upper bound. cut_opt = CutOptimization(interface, settings, constraint_obj) - state, _ = cut_opt.optimization_pass() - assert state is not None - - # Update and lower cost upper bound. cut_opt.update_upperbound_cost((2, 4)) - state, _ = cut_opt.optimization_pass() + state, cost = cut_opt.optimization_pass() - # Since any cut has a cost of at least 3, the returned state must be None. - assert state is None + # 2 cnot cuts are still found + assert state is not None + assert cost[0] == 9 diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index 1de26e7c8..ca6d19a73 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -5,6 +5,7 @@ from circuit_knitting.cutting.cut_finding.circuit_interface import ( CircuitElement, SimpleGateList, + GateSpec, ) from circuit_knitting.cutting.cut_finding.cutting_actions import ( ActionApplyGate, @@ -31,7 +32,7 @@ def test_circuit(): interface = SimpleGateList(circuit) - # initialize instance of :class:`DisjointSubcircuitsState`. + # initialize instance of DisjointSubcircuitsState. state = DisjointSubcircuitsState(interface.get_num_qubits(), 2) two_qubit_gate = interface.get_multiqubit_gates()[0] @@ -42,9 +43,7 @@ def test_circuit(): def test_action_apply_gate( test_circuit: Callable[ [], - tuple[ - SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] - ], + tuple[SimpleGateList, DisjointSubcircuitsState, GateSpec], ] ): """Test the application of a gate without any cutting actions.""" @@ -64,9 +63,7 @@ def test_action_apply_gate( def test_cut_two_qubit_gate( test_circuit: Callable[ [], - tuple[ - SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] - ], + tuple[SimpleGateList, DisjointSubcircuitsState, GateSpec], ] ): """Test the action of cutting a two qubit gate.""" @@ -83,18 +80,12 @@ def test_cut_two_qubit_gate( assert actions_list == [ CutIdentifier( cut_action="CutTwoQubitGate", - gate_cut_location=GateCutLocation(instruction_id=2, gate_name="cx"), + gate_cut_location=GateCutLocation( + instruction_id=2, gate_name="cx", qubits=[0, 1] + ), # In renaming qubits here,"q1" -> 0, "q0" -> 1. ) ] - # assert actions_list == [ - # [ - # "CutTwoQubitGate", - # [2, CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3), None], - # ((1, 0), (2, 1)), - # ] - # ] - assert cut_gate.get_cost_params(two_qubit_gate) == ( 3, 0, @@ -110,9 +101,7 @@ def test_cut_two_qubit_gate( def test_cut_left_wire( test_circuit: Callable[ [], - tuple[ - SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] - ], + tuple[SimpleGateList, DisjointSubcircuitsState, GateSpec], ] ): """Test the action of cutting the first (left) input wire to a two qubit gate.""" @@ -136,9 +125,7 @@ def test_cut_left_wire( def test_cut_right_wire( test_circuit: Callable[ [], - tuple[ - SimpleGateList, DisjointSubcircuitsState, list[int | CircuitElement | None] - ], + tuple[SimpleGateList, DisjointSubcircuitsState, GateSpec], ] ): """Test the action of cutting the second (right) input wire to a two qubit gate.""" diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 79291251f..93d23520e 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -11,6 +11,7 @@ from circuit_knitting.cutting.cut_finding.circuit_interface import ( SimpleGateList, CircuitElement, + GateSpec, ) @@ -43,9 +44,7 @@ def test_circuit(): def test_state_uncut( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, _ = test_circuit @@ -65,9 +64,7 @@ def test_state_uncut( def test_apply_gate( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, two_qubit_gate = test_circuit @@ -93,9 +90,7 @@ def test_apply_gate( def test_cut_gate( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, two_qubit_gate = test_circuit @@ -129,9 +124,7 @@ def test_cut_gate( def test_cut_left_wire( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, two_qubit_gate = test_circuit @@ -176,9 +169,7 @@ def test_cut_left_wire( def test_cut_right_wire( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, two_qubit_gate = test_circuit @@ -213,9 +204,7 @@ def test_cut_right_wire( def test_cut_both_wires( - test_circuit: Callable[ - [], tuple[DisjointSubcircuitsState, list[int | CircuitElement | None]] - ] + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): state, two_qubit_gate = test_circuit @@ -260,3 +249,23 @@ def test_cut_both_wires( assert next_state.upper_bound_gamma() == 16 # The 4^n scaling that comes with LO. assert next_state.verify_merge_constraints() is True + + next_state.no_merge = [ + (0, 2), + (1, 3), + (2, 3), + ] # Enforce an incorrect set of no-merge constraints + # and verify that verify_merge_constraints is False. + assert next_state.verify_merge_constraints() is False + + +# def no_wire_cuts(test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]]): +# state, two_qubit_gate = test_circuit + +# next_state = disjoint_subcircuit_actions.get_action("CutBothWires").next_state( +# state, two_qubit_gate, 1 +# )[ +# 0 +# ] # Imposing a max_width < 2 means no wire cuts. + +# assert next_state == [] From 3609d1747e02ef215c43cffa16fbb0b50a3faaf8 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 14 Mar 2024 17:24:00 -0400 Subject: [PATCH 092/128] style --- circuit_knitting/cutting/cut_finding/cutting_actions.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index e92bab10c..cfe364214 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -389,11 +389,11 @@ def next_state_primitive( ) # If the wire-cut limit would be exceeded, return the empty list - if not state.can_add_wires(2): #pragma: no cover + if not state.can_add_wires(2): # pragma: no cover return list() # If the maximum width is less than two, return the empty list - if max_width < 2: #pragma: no cover + if max_width < 2: # pragma: no cover return list() q1 = gate.qubits[0] From b10c959cc447e73659d96e1f659c19d5e9b233b8 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 15 Mar 2024 15:41:04 -0400 Subject: [PATCH 093/128] Add tests --- .../cutting/cut_finding/circuit_interface.py | 10 ++-- .../cutting/cut_finding/cut_optimization.py | 4 +- .../cutting/cut_finding/cutting_actions.py | 24 ++++----- .../cut_finding/disjoint_subcircuits_state.py | 21 ++++---- .../cutting/cut_finding/lo_cuts_optimizer.py | 6 +-- .../cut_finding/search_space_generator.py | 2 +- .../tutorials/LO_circuit_cut_finder.ipynb | 51 +++++++++++++++++++ .../cut_finding/test_cut_finder_roundtrip.py | 2 +- .../cut_finding/test_cutting_actions.py | 3 +- .../test_disjoint_subcircuits_state.py | 18 ++++--- 10 files changed, 97 insertions(+), 44 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 1a6cbefd2..3235de35c 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -17,7 +17,7 @@ import string from numpy.typing import NDArray from abc import ABC, abstractmethod -from typing import NamedTuple, Hashable, Iterable, cast, Sequence +from typing import NamedTuple, Hashable, Iterable, cast, Sequence, List class CircuitElement(NamedTuple): @@ -296,7 +296,7 @@ def export_cut_circuit( wire_map = self.make_wire_mapping(name_mapping) out = copy.deepcopy(self.new_circuit) - wire_map = cast(list, wire_map) + wire_map = cast(List[int], wire_map) self.replace_wire_ids(out, wire_map) return out @@ -330,12 +330,12 @@ def export_subcircuits_as_string( wire_map = self.make_wire_mapping(name_mapping) out: Sequence[int | str] = list(range(self.get_num_wires())) - out = cast(list, out) + out = cast(List[str], out) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): - subcircuit = cast(list, subcircuit) + subcircuit = cast(List[int], subcircuit) for wire in subcircuit: - wire_map = cast(list, wire_map) + wire_map = cast(List[int], wire_map) out[wire_map[wire]] = alphabet[k] return "".join(out) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 27286e2e0..c1e9aefa2 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -15,7 +15,7 @@ import numpy as np from dataclasses import dataclass -from typing import cast +from typing import cast, List from numpy.typing import NDArray from .search_space_generator import ActionNames from .cco_utils import select_search_engine, greedy_best_first_search @@ -113,7 +113,7 @@ def cut_optimization_goal_state_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> bool: """Return True if the input state is a goal state.""" - func_args.entangling_gates = cast(list, func_args.entangling_gates) + func_args.entangling_gates = cast(List[GateSpec], func_args.entangling_gates) return state.get_search_level() >= len(func_args.entangling_gates) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index cfe364214..6113e8e0f 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -17,7 +17,7 @@ from abc import ABC, abstractmethod from .circuit_interface import SimpleGateList from .search_space_generator import ActionNames -from typing import Hashable, cast +from typing import Hashable, cast, List from .disjoint_subcircuits_state import DisjointSubcircuitsState from .circuit_interface import GateSpec @@ -46,7 +46,7 @@ def next_state( gate_spec: GateSpec, max_width: int, ) -> list[DisjointSubcircuitsState]: - """Return a list of search states that result from applying the action to ``gate_spec`` in the specified :class:`DisjointSubcircuitsState` state. + """Return list of states resulting from applying associated instance of :class:`DisjointSearchAction` to ``gate_spec``. This is subject to the constraint that the number of resulting qubits (wires) in each subcircuit cannot exceed ``max_width``. @@ -134,7 +134,7 @@ def next_state_primitive( # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "In this release, only the cutting of two qubit gates is supported." + "In the current version, only the cutting of two qubit gates is supported." ) gamma_LB, num_bell_pairs, gamma_UB = self.get_cost_params(gate_spec) @@ -160,7 +160,7 @@ def next_state_primitive( new_state.gamma_LB *= gamma_LB for k in range(num_bell_pairs): # pragma: no cover - new_state.bell_pairs = cast(list, new_state.bell_pairs) + new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) gamma_UB = cast(float, gamma_UB) @@ -227,7 +227,7 @@ def next_state_primitive( # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "In this release, only the cutting of two qubit gates is supported." + "In the current version, only the cutting of two qubit gates is supported." ) # If the wire-cut limit would be exceeded, return the empty list @@ -252,7 +252,7 @@ def next_state_primitive( new_state.merge_roots(rnew, r2) new_state.assert_donot_merge_roots(r1, r2) # Because r2 < rnew - new_state.bell_pairs = cast(list, new_state.bell_pairs) + new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.gamma_UB *= 4 @@ -339,7 +339,7 @@ def next_state_primitive( new_state.assert_donot_merge_roots(r1, r2) # Because r1 < rnew new_state.gamma_UB = cast(float, new_state.gamma_UB) - new_state.bell_pairs = cast(list, new_state.bell_pairs) + new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB *= 4 @@ -385,15 +385,15 @@ def next_state_primitive( # Cutting of multi-qubit gates is not supported in this release. if len(gate.qubits) != 2: # pragma: no cover raise ValueError( - "In this release, only the cutting of two qubit gates is supported." + "In the current version, only the cutting of two qubit gates is supported." ) - # If the wire-cut limit would be exceeded, return the empty list + # If the wire-cut limit would be exceeded, do not cut. if not state.can_add_wires(2): # pragma: no cover return list() - # If the maximum width is less than two, return the empty list - if max_width < 2: # pragma: no cover + # If the maximum width is less than two, do not cut. + if max_width < 2: return list() q1 = gate.qubits[0] @@ -411,7 +411,7 @@ def next_state_primitive( new_state.assert_donot_merge_roots(r1, rnew_1) # Because r1 < rnew_1 new_state.assert_donot_merge_roots(r2, rnew_2) # Because r2 < rnew_2 - new_state.bell_pairs = cast(list, new_state.bell_pairs) + new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.bell_pairs.append((r1, rnew_1)) new_state.bell_pairs.append((r2, rnew_2)) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index e9c93d434..47e533021 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -26,6 +26,7 @@ cast, NamedTuple, Sequence, + List, ) if TYPE_CHECKING: # pragma: no cover @@ -148,12 +149,12 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No self.uptree: NDArray[np.int_] | None = None self.width: NDArray[np.int_] | None = None - self.bell_pairs: list[tuple[int, int]] | None = None + self.bell_pairs: List[tuple[int, int]] | None = None self.gamma_LB: float | None = None self.gamma_UB: float | None = None - self.no_merge: list[tuple] | None = None - self.actions: list[Action] | None = None + self.no_merge: List[tuple] | None = None + self.actions: List[Action] | None = None self.cut_actions_list: list | None = None self.level: int | None = None @@ -206,11 +207,11 @@ def cut_actions_sublist(self) -> list[NamedTuple]: Also include the locations of these actions which are specified in terms of the associated gates and wires. """ - self.actions = cast(list, self.actions) + self.actions = cast(List[Action], self.actions) cut_actions = get_actions_list(self.actions) # Output formatting for LO gate and wire cuts - self.cut_actions_list = cast(list, self.cut_actions_list) + self.cut_actions_list = cast(List, self.cut_actions_list) for i in range(len(cut_actions)): if cut_actions[i].action.get_name() in ("CutLeftWire", "CutRightWire"): self.cut_actions_list.append( @@ -247,7 +248,7 @@ def cut_actions_sublist(self) -> list[NamedTuple]: def print(self, simple: bool = False) -> None: # pragma: no cover """Print the various properties of a :class:`DisjointSubcircuitState`.""" cut_actions_list = self.cut_actions_sublist() - self.actions = cast(list, self.actions) + self.actions = cast(List[Action], self.actions) if simple: print(cut_actions_list) else: @@ -295,7 +296,7 @@ def find_root_bell_pair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: def lower_bound_gamma(self) -> float: """Return a lower bound for gamma using the current counts for the circuit cuts involving bell pairs.""" - self.bell_pairs = cast(list, self.bell_pairs) + self.bell_pairs = cast(List[tuple[int, int]], self.bell_pairs) root_bell_pairs = map(lambda x: self.find_root_bell_pair(x), self.bell_pairs) self.gamma_LB = cast(float, self.gamma_LB) @@ -375,7 +376,7 @@ def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: + f"or {root_2} != {self.uptree[root_2]}" ) - self.no_merge = cast(list, self.no_merge) + self.no_merge = cast(List[tuple], self.no_merge) for clause in self.no_merge: r1 = self.find_wire_root(clause[0]) r2 = self.find_wire_root(clause[1]) @@ -389,7 +390,7 @@ def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: def verify_merge_constraints(self) -> bool: """Return ``True`` if all merge constraints are satisfied.""" - self.no_merge = cast(list, self.no_merge) + self.no_merge = cast(List[tuple], self.no_merge) for clause in self.no_merge: r1 = self.find_wire_root(clause[0]) r2 = self.find_wire_root(clause[1]) @@ -435,7 +436,7 @@ def add_action( ) -> None: """Append the specified action to the list of search-space actions that have been performed.""" if action_obj.get_name() is not None: - self.actions = cast(list, self.actions) + self.actions = cast(List[Action], self.actions) self.actions.append(Action(action_obj, gate_spec, [args])) def get_search_level(self) -> int: diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 511d160f7..a5023c82d 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -96,9 +96,9 @@ def optimize( the target quantum hardware. Returns: - The lowest-cost instance of :class:`DisjointSubcircuitsState` identified in - the search, or None if no solution could be found. In the - case of the former, the circuit_interface object is also + The lowest-cost instance of :class:`DisjointSubcircuitsState` + identified in the search, or None if no solution could be found. + In case of the former, the circuit_interface object is also updated as a side effect to incorporate the cuts found. """ if circuit_interface is not None: diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 07b76424d..5f4bd0a52 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -144,7 +144,7 @@ class SearchFunctions: as input. The upper bound is used to prune next-states from the search in subsequent calls to the :meth:`optimization_pass` method of the search algorithm. If upperbound_cost_func is ``None``, the cost of the ``goal_state`` as determined - by ``cost_func`` is used as an upper bound to the optimal cost. If the + by ``cost_func`` is used as an upper bound to the optimal cost. If ``upperbound_cost_func`` returns ``None``, the effect is equivalent to returning an infinite upper bound (i.e., no cost pruning is performed on subsequent optimization calls). diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index d7bb0a7f3..0296c30c6 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -288,6 +288,57 @@ " \"\\n\",\n", " )" ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement\n", + "from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import (\n", + " DisjointSubcircuitsState,\n", + ")\n", + "from circuit_knitting.cutting.cut_finding.cutting_actions import (\n", + " disjoint_subcircuit_actions,\n", + ")\n", + "\n", + "\n", + "def test_circuit():\n", + " circuit = [\n", + " CircuitElement(name=\"h\", params=[], qubits=[\"q1\"], gamma=None),\n", + " CircuitElement(name=\"barrier\", params=[], qubits=[\"q1\"], gamma=None),\n", + " CircuitElement(name=\"s\", params=[], qubits=[\"q0\"], gamma=None),\n", + " \"barrier\",\n", + " CircuitElement(name=\"cx\", params=[], qubits=[\"q1\", \"q0\"], gamma=3),\n", + " ]\n", + "\n", + " interface = SimpleGateList(circuit)\n", + "\n", + " # initialize DisjointSubcircuitsState object.\n", + " state = DisjointSubcircuitsState(interface.get_num_qubits(), 2)\n", + "\n", + " two_qubit_gate = interface.get_multiqubit_gates()[0]\n", + "\n", + " return state, two_qubit_gate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "state, two_qubit_gate = test_circuit()\n", + "\n", + "next_state = disjoint_subcircuit_actions.get_action(\"CutBothWires\").next_state(\n", + " state, two_qubit_gate, 1\n", + ")[\n", + " 0\n", + "] # Imposing a max_width < 2 means no wire cuts.\n", + "\n", + "assert next_state == []" + ] } ], "metadata": { diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index eb1945f52..ebc7cf92b 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -232,7 +232,7 @@ def test_greedy_search( constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) - # Impose a stringent cost upper bound. + # Impose a stringent cost upper bound, insist gamma <=2. cut_opt = CutOptimization(interface, settings, constraint_obj) cut_opt.update_upperbound_cost((2, 4)) state, cost = cut_opt.optimization_pass() diff --git a/test/cutting/cut_finding/test_cutting_actions.py b/test/cutting/cut_finding/test_cutting_actions.py index ca6d19a73..84a89ad71 100644 --- a/test/cutting/cut_finding/test_cutting_actions.py +++ b/test/cutting/cut_finding/test_cutting_actions.py @@ -148,8 +148,7 @@ def test_cut_right_wire( def test_defined_actions(): - # Check that unsupported cutting actions return None - # when the action or corresponding group is requested. + """Check that unsupported cutting actions return None""" assert ActionNames().get_action("LOCCGateCut") is None diff --git a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py index 93d23520e..8b53f044c 100644 --- a/test/cutting/cut_finding/test_disjoint_subcircuits_state.py +++ b/test/cutting/cut_finding/test_disjoint_subcircuits_state.py @@ -46,6 +46,7 @@ def test_circuit(): def test_state_uncut( test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): + state, _ = test_circuit assert list(state.wiremap) == [0, 1] @@ -126,6 +127,7 @@ def test_cut_gate( def test_cut_left_wire( test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] ): + state, two_qubit_gate = test_circuit next_state = disjoint_subcircuit_actions.get_action("CutLeftWire").next_state( @@ -259,13 +261,13 @@ def test_cut_both_wires( assert next_state.verify_merge_constraints() is False -# def no_wire_cuts(test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]]): -# state, two_qubit_gate = test_circuit +def test_no_wire_cuts( + test_circuit: Callable[[], tuple[DisjointSubcircuitsState, GateSpec]] +): + state, two_qubit_gate = test_circuit -# next_state = disjoint_subcircuit_actions.get_action("CutBothWires").next_state( -# state, two_qubit_gate, 1 -# )[ -# 0 -# ] # Imposing a max_width < 2 means no wire cuts. + next_state = disjoint_subcircuit_actions.get_action("CutBothWires").next_state( + state, two_qubit_gate, 1 + ) # Imposing a max_width < 2 means no wire cuts. -# assert next_state == [] + assert next_state == [] From e71dc7ef8cf1a3ac0afe30bbb21492068601c5f7 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 15 Mar 2024 17:07:58 -0400 Subject: [PATCH 094/128] Remove subscripting in cast statements --- .../cutting/cut_finding/circuit_interface.py | 10 ++-- .../cutting/cut_finding/cut_optimization.py | 2 +- .../cutting/cut_finding/cutting_actions.py | 10 ++-- .../cut_finding/disjoint_subcircuits_state.py | 21 ++++---- .../tutorials/LO_circuit_cut_finder.ipynb | 53 +------------------ 5 files changed, 22 insertions(+), 74 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 3235de35c..1a6cbefd2 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -17,7 +17,7 @@ import string from numpy.typing import NDArray from abc import ABC, abstractmethod -from typing import NamedTuple, Hashable, Iterable, cast, Sequence, List +from typing import NamedTuple, Hashable, Iterable, cast, Sequence class CircuitElement(NamedTuple): @@ -296,7 +296,7 @@ def export_cut_circuit( wire_map = self.make_wire_mapping(name_mapping) out = copy.deepcopy(self.new_circuit) - wire_map = cast(List[int], wire_map) + wire_map = cast(list, wire_map) self.replace_wire_ids(out, wire_map) return out @@ -330,12 +330,12 @@ def export_subcircuits_as_string( wire_map = self.make_wire_mapping(name_mapping) out: Sequence[int | str] = list(range(self.get_num_wires())) - out = cast(List[str], out) + out = cast(list, out) alphabet = string.ascii_uppercase + string.ascii_lowercase for k, subcircuit in enumerate(self.subcircuits): - subcircuit = cast(List[int], subcircuit) + subcircuit = cast(list, subcircuit) for wire in subcircuit: - wire_map = cast(List[int], wire_map) + wire_map = cast(list, wire_map) out[wire_map[wire]] = alphabet[k] return "".join(out) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index c1e9aefa2..57f266360 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -113,7 +113,7 @@ def cut_optimization_goal_state_func( state: DisjointSubcircuitsState, func_args: CutOptimizationFuncArgs ) -> bool: """Return True if the input state is a goal state.""" - func_args.entangling_gates = cast(List[GateSpec], func_args.entangling_gates) + func_args.entangling_gates = cast(list, func_args.entangling_gates) return state.get_search_level() >= len(func_args.entangling_gates) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index 6113e8e0f..f2c8451c9 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -17,7 +17,7 @@ from abc import ABC, abstractmethod from .circuit_interface import SimpleGateList from .search_space_generator import ActionNames -from typing import Hashable, cast, List +from typing import Hashable, cast from .disjoint_subcircuits_state import DisjointSubcircuitsState from .circuit_interface import GateSpec @@ -160,7 +160,7 @@ def next_state_primitive( new_state.gamma_LB *= gamma_LB for k in range(num_bell_pairs): # pragma: no cover - new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) gamma_UB = cast(float, gamma_UB) @@ -252,7 +252,7 @@ def next_state_primitive( new_state.merge_roots(rnew, r2) new_state.assert_donot_merge_roots(r1, r2) # Because r2 < rnew - new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.gamma_UB *= 4 @@ -339,7 +339,7 @@ def next_state_primitive( new_state.assert_donot_merge_roots(r1, r2) # Because r1 < rnew new_state.gamma_UB = cast(float, new_state.gamma_UB) - new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.bell_pairs.append((r1, r2)) new_state.gamma_UB *= 4 @@ -411,7 +411,7 @@ def next_state_primitive( new_state.assert_donot_merge_roots(r1, rnew_1) # Because r1 < rnew_1 new_state.assert_donot_merge_roots(r2, rnew_2) # Because r2 < rnew_2 - new_state.bell_pairs = cast(List[tuple[int, int]], new_state.bell_pairs) + new_state.bell_pairs = cast(list, new_state.bell_pairs) new_state.gamma_UB = cast(float, new_state.gamma_UB) new_state.bell_pairs.append((r1, rnew_1)) new_state.bell_pairs.append((r2, rnew_2)) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 47e533021..e9c93d434 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -26,7 +26,6 @@ cast, NamedTuple, Sequence, - List, ) if TYPE_CHECKING: # pragma: no cover @@ -149,12 +148,12 @@ def __init__(self, num_qubits: int | None = None, max_wire_cuts: int | None = No self.uptree: NDArray[np.int_] | None = None self.width: NDArray[np.int_] | None = None - self.bell_pairs: List[tuple[int, int]] | None = None + self.bell_pairs: list[tuple[int, int]] | None = None self.gamma_LB: float | None = None self.gamma_UB: float | None = None - self.no_merge: List[tuple] | None = None - self.actions: List[Action] | None = None + self.no_merge: list[tuple] | None = None + self.actions: list[Action] | None = None self.cut_actions_list: list | None = None self.level: int | None = None @@ -207,11 +206,11 @@ def cut_actions_sublist(self) -> list[NamedTuple]: Also include the locations of these actions which are specified in terms of the associated gates and wires. """ - self.actions = cast(List[Action], self.actions) + self.actions = cast(list, self.actions) cut_actions = get_actions_list(self.actions) # Output formatting for LO gate and wire cuts - self.cut_actions_list = cast(List, self.cut_actions_list) + self.cut_actions_list = cast(list, self.cut_actions_list) for i in range(len(cut_actions)): if cut_actions[i].action.get_name() in ("CutLeftWire", "CutRightWire"): self.cut_actions_list.append( @@ -248,7 +247,7 @@ def cut_actions_sublist(self) -> list[NamedTuple]: def print(self, simple: bool = False) -> None: # pragma: no cover """Print the various properties of a :class:`DisjointSubcircuitState`.""" cut_actions_list = self.cut_actions_sublist() - self.actions = cast(List[Action], self.actions) + self.actions = cast(list, self.actions) if simple: print(cut_actions_list) else: @@ -296,7 +295,7 @@ def find_root_bell_pair(self, bell_pair: tuple[int, int]) -> tuple[int, int]: def lower_bound_gamma(self) -> float: """Return a lower bound for gamma using the current counts for the circuit cuts involving bell pairs.""" - self.bell_pairs = cast(List[tuple[int, int]], self.bell_pairs) + self.bell_pairs = cast(list, self.bell_pairs) root_bell_pairs = map(lambda x: self.find_root_bell_pair(x), self.bell_pairs) self.gamma_LB = cast(float, self.gamma_LB) @@ -376,7 +375,7 @@ def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: + f"or {root_2} != {self.uptree[root_2]}" ) - self.no_merge = cast(List[tuple], self.no_merge) + self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: r1 = self.find_wire_root(clause[0]) r2 = self.find_wire_root(clause[1]) @@ -390,7 +389,7 @@ def check_donot_merge_roots(self, root_1: int, root_2: int) -> bool: def verify_merge_constraints(self) -> bool: """Return ``True`` if all merge constraints are satisfied.""" - self.no_merge = cast(List[tuple], self.no_merge) + self.no_merge = cast(list, self.no_merge) for clause in self.no_merge: r1 = self.find_wire_root(clause[0]) r2 = self.find_wire_root(clause[1]) @@ -436,7 +435,7 @@ def add_action( ) -> None: """Append the specified action to the list of search-space actions that have been performed.""" if action_obj.get_name() is not None: - self.actions = cast(List[Action], self.actions) + self.actions = cast(list, self.actions) self.actions.append(Action(action_obj, gate_spec, [args])) def get_search_level(self) -> int: diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 0296c30c6..aa6f82aed 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -288,57 +288,6 @@ " \"\\n\",\n", " )" ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "from circuit_knitting.cutting.cut_finding.circuit_interface import CircuitElement\n", - "from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import (\n", - " DisjointSubcircuitsState,\n", - ")\n", - "from circuit_knitting.cutting.cut_finding.cutting_actions import (\n", - " disjoint_subcircuit_actions,\n", - ")\n", - "\n", - "\n", - "def test_circuit():\n", - " circuit = [\n", - " CircuitElement(name=\"h\", params=[], qubits=[\"q1\"], gamma=None),\n", - " CircuitElement(name=\"barrier\", params=[], qubits=[\"q1\"], gamma=None),\n", - " CircuitElement(name=\"s\", params=[], qubits=[\"q0\"], gamma=None),\n", - " \"barrier\",\n", - " CircuitElement(name=\"cx\", params=[], qubits=[\"q1\", \"q0\"], gamma=3),\n", - " ]\n", - "\n", - " interface = SimpleGateList(circuit)\n", - "\n", - " # initialize DisjointSubcircuitsState object.\n", - " state = DisjointSubcircuitsState(interface.get_num_qubits(), 2)\n", - "\n", - " two_qubit_gate = interface.get_multiqubit_gates()[0]\n", - "\n", - " return state, two_qubit_gate" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "state, two_qubit_gate = test_circuit()\n", - "\n", - "next_state = disjoint_subcircuit_actions.get_action(\"CutBothWires\").next_state(\n", - " state, two_qubit_gate, 1\n", - ")[\n", - " 0\n", - "] # Imposing a max_width < 2 means no wire cuts.\n", - "\n", - "assert next_state == []" - ] } ], "metadata": { From 14803d02af2796f7f7f98798347a838298190543 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 15 Mar 2024 17:10:27 -0400 Subject: [PATCH 095/128] Fix tests. --- circuit_knitting/cutting/cut_finding/cut_optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 57f266360..27286e2e0 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -15,7 +15,7 @@ import numpy as np from dataclasses import dataclass -from typing import cast, List +from typing import cast from numpy.typing import NDArray from .search_space_generator import ActionNames from .cco_utils import select_search_engine, greedy_best_first_search From 915052b787bf9659a62cfed4e80c513629bc660c Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 18 Mar 2024 11:20:20 -0500 Subject: [PATCH 096/128] Fix docstring. Improve error message. Add test. --- .../cutting/cut_finding/cut_optimization.py | 3 +- .../cutting/cutting_decomposition.py | 45 ++++++++++--------- .../cut_finding/test_cut_finder_roundtrip.py | 6 +-- test/cutting/test_cutting_decomposition.py | 11 +++++ 4 files changed, 41 insertions(+), 24 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 27286e2e0..924bb37e3 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -94,7 +94,8 @@ def cut_optimization_next_state_func( action_list = func_args.search_actions.get_group("TwoQubitGates") else: raise ValueError( - "In the current version, only the cutting of two qubit gates is supported." + "The input circuit must contain only single and two-qubits gates. Found " + f"{len(gate.qubits)}-qubit gate: ({gate.name})." ) gate_actions = gate_spec.cut_constraints diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 4c82883dd..ac0cb3be1 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -278,24 +278,25 @@ def find_cuts( Find cut locations in a circuit, given optimization settings and QPU constraints. Args: - circuit: The circuit to cut - + circuit: The circuit to cut. The circuit must contain only single and two-qubit + gates. optimization: Settings dictionary for controlling optimizer behavior. Currently, only a best-first optimizer is supported. - - max_gamma: Specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered - feasible. Not that the sampling overhead is ``gamma ** 2``. - - max_backjumps: Specifies a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. - - rand_seed: Used to provide a repeatable initialization of the pseudorandom - number generators used by the optimization. If ``None`` is used as the - seed, then a seed is obtained using an operating system call to achieve - an unrepeatable random initialization. + + - max_gamma: Specifies a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered + feasible. Not that the sampling overhead is ``gamma ** 2``. + - max_backjumps: Specifies a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. + - rand_seed: Used to provide a repeatable initialization of the pseudorandom + number generators used by the optimization. If ``None`` is used as the + seed, then a seed is obtained using an operating system call to achieve + an unrepeatable random initialization. constraints: Dictionary for specifying the constraints on the quantum device(s). - - qubits_per_QPU: The maximum number of qubits each subcircuit can contain - after cutting. - - num_QPUs: The maximum number of subcircuits produced after cutting + - qubits_per_QPU: The maximum number of qubits each subcircuit can contain + after cutting. + - num_QPUs: The maximum number of subcircuits produced after cutting Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits @@ -303,12 +304,16 @@ def find_cuts( specified in ``constraints``. A metadata dictionary: - - cuts: A list of length-2 tuples describing each cut in the output circuit. - The tuples are formatted as ``(cut_type: str, cut_id: int)``. The - cut ID is the index of the cut gate or wire in the output circuit's - ``data`` field. - - sampling_overhead: The sampling overhead incurred from cutting the specified - gates and wires. + + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. + + Raises: + ValueError: The input circuit contains a gate acting on more than 2 qubits. """ circuit_cco = qc_to_cco_circuit(circuit) interface = SimpleGateList(circuit_cco) diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index ebc7cf92b..8ba5d25dd 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -214,9 +214,9 @@ def test_multiqubit_cuts( with raises(ValueError) as e_info: _ = optimization_pass.optimize() - assert ( - e_info.value.args[0] - == "In the current version, only the cutting of two qubit gates is supported." + assert e_info.value.args[0] == ( + "The input circuit must contain only single and two-qubits gates. " + "Found 3-qubit gate: (ccx)." ) diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index 18ab41c1e..1ee202845 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -272,6 +272,17 @@ def test_find_cuts(self): assert {"Wire Cut", "Gate Cut"} == cut_types assert np.isclose(127.06026169, metadata["sampling_overhead"], atol=1e-8) + with self.subTest("3-qubit gate"): + circuit = random_circuit(3, 2, max_operands=3, seed=99) + with pytest.raises(ValueError) as e_info: + cut_circ, metadata = find_cuts( + circuit, {"rand_seed": 111}, {"qubits_per_QPU": 4, "num_QPUs": 2} + ) + assert e_info.value.args[0] == ( + "The input circuit must contain only single and two-qubits gates. " + "Found 3-qubit gate: (cswap)." + ) + def test_cut_gates(self): with self.subTest("simple circuit"): compare_qc = QuantumCircuit(2) From 5d38550b0e19cd7d2ecdf964946496b18c2f10ab Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 18 Mar 2024 16:55:20 -0400 Subject: [PATCH 097/128] Update tutorial, add classes for constraints and settings --- circuit_knitting/cutting/__init__.py | 5 +- .../cutting/cut_finding/best_first_search.py | 18 ++-- .../cutting/cut_finding/cut_optimization.py | 4 +- .../cut_finding/optimization_settings.py | 27 ++++-- .../cut_finding/quantum_device_constraints.py | 15 ++-- .../cutting/cutting_decomposition.py | 44 ++++----- .../tutorials/04_automatic_cut_finding.ipynb | 10 ++- .../tutorials/LO_circuit_cut_finder.ipynb | 90 ++++++++++--------- test/cutting/cut_finding/__init__.py | 10 +++ .../cut_finding/test_best_first_search.py | 4 +- .../cut_finding/test_cut_finder_roundtrip.py | 42 ++++----- .../test_quantum_device_constraints.py | 15 ++-- test/cutting/test_cutting_decomposition.py | 8 +- 13 files changed, 167 insertions(+), 125 deletions(-) diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index f739a145c..323de1d8c 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -87,6 +87,8 @@ from .cutting_experiments import generate_cutting_experiments from .cutting_reconstruction import reconstruct_expectation_values from .wire_cutting_transforms import cut_wires, expand_observables +from .cut_finding.quantum_device_constraints import DeviceConstraints +from .cut_finding.optimization_settings import OptimizationParameters __all__ = [ "find_cuts", @@ -98,5 +100,6 @@ "PartitionedCuttingProblem", "cut_wires", "expand_observables", - "find_cuts", + "DeviceConstraints", + "OptimizationParameters", ] diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index eed2c4518..af943da8b 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -33,7 +33,7 @@ class BestFirstPriorityQueue: The tuples that are pushed onto the priority queues have the form: - (, , , , ), + (, , , , ), where: @@ -45,7 +45,7 @@ class BestFirstPriorityQueue: have identical costs, priority is given to the deepest states to encourage depth-first behavior. - is a pseudo-random number that randomly break ties in a + is a pseudo-random number that randomly break ties in a stable manner if several search states have identical costs at identical search depths. @@ -59,9 +59,9 @@ class BestFirstPriorityQueue: internally by the priority-queue implementation. """ - def __init__(self, rand_seed: int | None): + def __init__(self, seed: int | None): """Assign member variables.""" - self.rand_gen: Generator = np.random.default_rng(rand_seed) + self.random_gen: Generator = np.random.default_rng(seed) self.unique: count[int] = count() self.pqueue: list[tuple] = list() @@ -77,7 +77,7 @@ def put( """ heapq.heappush( self.pqueue, - (cost, (-depth), self.rand_gen.random(), next(self.unique), state), + (cost, (-depth), self.random_gen.random(), next(self.unique), state), ) def get( @@ -117,7 +117,7 @@ class BestFirstSearch: Member Variables: - ``rand_seed`` (int) is the seed to use when initializing Numpy random number + ``seed`` (int) is the seed to use when initializing Numpy random number generators in :class:`BestFirstPriorityQueue` instances. ``cost_func`` is a function that computes cost values from search states. @@ -200,15 +200,15 @@ def __init__( return any additional minimum-cost goal states that might exist (False). """ - self.rand_seed = optimization_settings.get_rand_seed() + self.seed = optimization_settings.get_seed self.cost_func = search_functions.cost_func self.next_state_func = search_functions.next_state_func self.goal_state_func = search_functions.goal_state_func self.upperbound_cost_func = search_functions.upperbound_cost_func self.mincost_bound_func = search_functions.mincost_bound_func self.stop_at_first_min = stop_at_first_min - self.max_backjumps = optimization_settings.get_max_backjumps() - self.pqueue = BestFirstPriorityQueue(self.rand_seed) + self.max_backjumps = optimization_settings.get_max_backjumps + self.pqueue = BestFirstPriorityQueue(self.seed) self.upperbound_cost = None self.mincost_bound = None self.min_reached = False diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 27286e2e0..572a90e1e 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -145,7 +145,7 @@ def greedy_cut_optimization( func_args = CutOptimizationFuncArgs() func_args.entangling_gates = circuit_interface.get_multiqubit_gates() func_args.search_actions = search_actions - func_args.max_gamma = optimization_settings.get_max_gamma() + func_args.max_gamma = optimization_settings.get_max_gamma func_args.qpu_width = device_constraints.get_qpu_width() start_state = DisjointSubcircuitsState( @@ -218,7 +218,7 @@ def __init__( self.func_args = CutOptimizationFuncArgs() self.func_args.entangling_gates = self.circuit.get_multiqubit_gates() self.func_args.search_actions = self.search_actions - self.func_args.max_gamma = self.settings.get_max_gamma() + self.func_args.max_gamma = self.settings.get_max_gamma self.func_args.qpu_width = self.constraints.get_qpu_width() # Perform an initial greedy best-first search to determine an upper diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index 899b9cf34..f79e835f4 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -33,7 +33,7 @@ class OptimizationSettings: ``max_backjumps`` specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - ``rand_seed`` is a seed used to provide a repeatable initialization + ``seed`` is a seed used to provide a repeatable initialization of the pesudorandom number generators used by the optimization. If None is used as the random seed, then a seed is obtained using an operating-system call to achieve an unrepeatable randomized initialization. @@ -44,7 +44,7 @@ class OptimizationSettings: max_gamma: float = 1024 max_backjumps: int = 10000 - rand_seed: int | None = None + seed: int | None = None LO: bool = True LOCC_ancillas: bool = False LOCC_no_ancillas: bool = False @@ -66,17 +66,20 @@ def __post_init__(self): if self.engine_selections is None: self.engine_selections = {"CutOptimization": "BestFirst"} + @property def get_max_gamma(self) -> float: """Return the constraint on the maxiumum allowed value of gamma.""" return self.max_gamma + @property def get_max_backjumps(self) -> int: """Return the maximum number of allowed search backjumps.""" return self.max_backjumps - def get_rand_seed(self) -> int | None: + @property + def get_seed(self) -> int | None: """Return the seed used to generate the pseudorandom numbers used in the optimizaton.""" - return self.rand_seed + return self.seed def get_engine_selection(self, stage_of_optimization: str) -> str: """Return the name of the search engine to employ.""" @@ -126,7 +129,15 @@ def get_cut_search_groups(self) -> list[None | str]: return out - @classmethod - def from_dict(cls, options: dict) -> OptimizationSettings: - """Return an instance of :class:`OptimizationSettings` initialized with the parameters passed in.""" - return cls(**options) + +@dataclass +class OptimizationParameters: + """Specify a subset of parameters that control the optimization. + + The other attributes of :class:`OptimizationSettings` are taken + to be private. + """ + + seed: int | None = OptimizationSettings().seed + max_gamma: float = OptimizationSettings().max_gamma + max_backjumps: int = OptimizationSettings().max_backjumps diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index b2c4a77fb..440a9a695 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -18,23 +18,18 @@ @dataclass class DeviceConstraints: - """Specify the characteristics (qubits per QPU and number of QPUs) of the target quantum device that must be respected.""" + """Specify the constraints (qubits per QPU and maximum number of subcircuits) that must be respected.""" - qubits_per_QPU: int - num_QPUs: int + qubits_per_qpu: int + max_subcircuits: int def __post_init__(self): """Post-init method for data class.""" - if self.qubits_per_QPU < 1 or self.num_QPUs < 1: + if self.qubits_per_qpu < 1 or self.max_subcircuits < 1: raise ValueError( "qubits_per_QPU and num_QPUs must be positive definite integers." ) def get_qpu_width(self) -> int: """Return the number of qubits supported on each individual QPU.""" - return self.qubits_per_QPU - - @classmethod - def from_dict(cls, options: dict[str, int]) -> DeviceConstraints: - """Return an instance of :class:`DeviceConstraints` initialized with the parameters passed in.""" - return cls(**options) + return self.qubits_per_qpu diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 4c82883dd..e026146b1 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -29,7 +29,10 @@ from .qpd.qpd_basis import QPDBasis from .qpd.instructions import TwoQubitQPDGate from .instructions import CutWire -from .cut_finding.optimization_settings import OptimizationSettings +from .cut_finding.optimization_settings import ( + OptimizationSettings, + OptimizationParameters, +) from .cut_finding.quantum_device_constraints import DeviceConstraints from .cut_finding.disjoint_subcircuits_state import DisjointSubcircuitsState from .cut_finding.circuit_interface import SimpleGateList @@ -271,31 +274,33 @@ def decompose_observables( def find_cuts( circuit: QuantumCircuit, - optimization: dict[str, str | int], - constraints: dict[str, int], -) -> tuple[QuantumCircuit, dict[str, Any]]: + optimization: OptimizationParameters, + constraints: DeviceConstraints, +) -> tuple[QuantumCircuit, dict[str, float]]: """ Find cut locations in a circuit, given optimization settings and QPU constraints. Args: circuit: The circuit to cut - optimization: Settings dictionary for controlling optimizer behavior. Currently, - only a best-first optimizer is supported. + optimization: Instance of :class:`.OptimizationParameters` for controlling + optimizer behavior. Currently, the optimal cuts are arrived at using + Dijkstra's best-first search algorithm. The specified parameters are: - max_gamma: Specifies a constraint on the maximum value of gamma that a solution to the optimization is allowed to have to be considered - feasible. Not that the sampling overhead is ``gamma ** 2``. + feasible. Note that the sampling overhead is ``gamma ** 2``. - max_backjumps: Specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - - rand_seed: Used to provide a repeatable initialization of the pseudorandom - number generators used by the optimization. If ``None`` is used as the - seed, then a seed is obtained using an operating system call to achieve - an unrepeatable random initialization. + - seed: Used to provide a repeatable initialization of the pseudorandom + number generators used for breaking ties in the optimization. If ``None`` + is used as the seed, then a seed is obtained using an operating system call + to achieve an unrepeatable random initialization. - constraints: Dictionary for specifying the constraints on the quantum device(s). + constraints: An instance of :class:`.DeviceConstraints` with the following + specified: - qubits_per_QPU: The maximum number of qubits each subcircuit can contain after cutting. - - num_QPUs: The maximum number of subcircuits produced after cutting + - max_subcircuits: The maximum number of subcircuits produced after cutting. Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits @@ -313,15 +318,14 @@ def find_cuts( circuit_cco = qc_to_cco_circuit(circuit) interface = SimpleGateList(circuit_cco) - opt_settings = OptimizationSettings.from_dict(optimization) - - # Hard-code the optimization type to best-first - opt_settings.set_engine_selection("CutOptimization", "BestFirst") - - constraint_settings = DeviceConstraints.from_dict(constraints) + opt_settings = OptimizationSettings( + seed=optimization.seed, + max_gamma=optimization.max_gamma, + max_backjumps=optimization.max_backjumps, + ) # Hard-code the optimizer to an LO-only optimizer - optimizer = LOCutsOptimizer(interface, opt_settings, constraint_settings) + optimizer = LOCutsOptimizer(interface, opt_settings, constraints) # Find cut locations opt_out = optimizer.optimize() diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 96d5cf64c..e11bd3b1f 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -75,13 +75,17 @@ } ], "source": [ - "from circuit_knitting.cutting import find_cuts\n", + "from circuit_knitting.cutting import (\n", + " OptimizationParameters,\n", + " DeviceConstraints,\n", + " find_cuts,\n", + ")\n", "\n", "# Specify settings for the cut-finding optimizer\n", - "optimization_settings = {\"rand_seed\": 111}\n", + "optimization_settings = OptimizationParameters(seed=111)\n", "\n", "# Specify the size and number of the QPUs available\n", - "device_constraints = {\"qubits_per_QPU\": 4, \"num_QPUs\": 2}\n", + "device_constraints = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2)\n", "\n", "cut_circuit, metadata = find_cuts(circuit, optimization_settings, device_constraints)\n", "print(\n", diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index aa6f82aed..47066dc99 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -43,7 +43,7 @@ "
" ] }, - "execution_count": 8, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -86,35 +86,39 @@ "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", - "Subcircuits: AAAB \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", - "Subcircuits: AABB \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", "\n" ] } ], "source": [ - "settings = OptimizationSettings(rand_seed=12345)\n", + "settings = OptimizationSettings(seed=12345)\n", "\n", "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", "\n", - "qubits_per_QPU = 4\n", - "num_QPUs = 2\n", + "qubits_per_qpu = 4\n", + "max_subcircuits = 2\n", "\n", "\n", - "for num_qpus in range(num_QPUs, 1, -1):\n", - " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", - " print(f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------\")\n", + "for max_subcircuits in range(max_subcircuits, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(\n", + " f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {max_subcircuits} QPUs ----------\"\n", + " )\n", "\n", - " constraint_obj = DeviceConstraints(qubits_per_QPU=qpu_qubits, num_QPUs=num_QPUs)\n", + " constraint_obj = DeviceConstraints(\n", + " qubits_per_qpu=qubits_per_qpu, max_subcircuits=max_subcircuits\n", + " )\n", "\n", " interface = SimpleGateList(circuit_ckt)\n", "\n", @@ -156,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -166,7 +170,7 @@ "
" ] }, - "execution_count": 11, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -196,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -213,37 +217,37 @@ "\n", "\n", "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", - "Subcircuits: AAAAAAB \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", - "Subcircuits: AAAABABB \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4], input=1))]\n", - "Subcircuits: AAAABBBB \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3], input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", - "Subcircuits: AABABCBCC \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", - "Subcircuits: ABCDDEF \n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAAAAA \n", "\n" ] } @@ -251,19 +255,23 @@ "source": [ "circuit_ckt_wirecut = qc_to_cco_circuit(qc_0)\n", "\n", - "settings = OptimizationSettings(rand_seed=12345)\n", + "settings = OptimizationSettings(seed=12345)\n", "\n", "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", - "qubits_per_QPU = 7\n", - "num_QPUs = 2\n", + "qubits_per_qpu = 7\n", + "max_subcircuits = 2\n", "\n", "\n", - "for num_qpus in range(num_QPUs, 1, -1):\n", - " for qpu_qubits in range(qubits_per_QPU, 1, -1):\n", - " print(f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {num_qpus} QPUs ----------\")\n", + "for max_subcircuits in range(max_subcircuits, 1, -1):\n", + " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " print(\n", + " f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {max_subcircuits} QPUs ----------\"\n", + " )\n", "\n", - " constraint_obj = DeviceConstraints(qubits_per_QPU=qpu_qubits, num_QPUs=num_QPUs)\n", + " constraint_obj = DeviceConstraints(\n", + " qubits_per_qpu=qubits_per_qpu, max_subcircuits=max_subcircuits\n", + " )\n", "\n", " interface = SimpleGateList(circuit_ckt_wirecut)\n", "\n", diff --git a/test/cutting/cut_finding/__init__.py b/test/cutting/cut_finding/__init__.py index e69de29bb..71d83fd8a 100644 --- a/test/cutting/cut_finding/__init__.py +++ b/test/cutting/cut_finding/__init__.py @@ -0,0 +1,10 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2022. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 73e54ed3f..6c1d56a13 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -55,11 +55,11 @@ def test_circuit(): def test_best_first_search(test_circuit: SimpleGateList): - settings = OptimizationSettings(rand_seed=12345) + settings = OptimizationSettings(seed=12345) settings.set_engine_selection("CutOptimization", "BestFirst") - constraint_obj = DeviceConstraints(qubits_per_QPU=4, num_QPUs=2) + constraint_obj = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2) op = CutOptimization(test_circuit, settings, constraint_obj) diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py index ebc7cf92b..360467136 100644 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ b/test/cutting/cut_finding/test_cut_finder_roundtrip.py @@ -43,7 +43,7 @@ def gate_cut_test_setup(): qc.assign_parameters([0.4] * len(qc.parameters), inplace=True) circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(rand_seed=12345) + settings = OptimizationSettings(seed=12345) settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -61,7 +61,7 @@ def wire_cut_test_setup(): qc.cx(3, 6) circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(rand_seed=12345) + settings = OptimizationSettings(seed=12345) settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -72,7 +72,7 @@ def multiqubit_test_setup(): qc.ccx(0, 1, 2) circuit_internal = qc_to_cco_circuit(qc) interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(rand_seed=12345) + settings = OptimizationSettings(seed=12345) settings.set_engine_selection("CutOptimization", "BestFirst") return interface, settings @@ -81,12 +81,12 @@ def test_no_cuts( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 4 qubits requires no cutting. - qubits_per_QPU = 4 - num_QPUs = 2 + qubits_per_qpu = 4 + max_subcircuits = 2 interface, settings = gate_cut_test_setup - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -101,12 +101,12 @@ def test_gate_cuts( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits enforces cutting. - qubits_per_QPU = 2 - num_QPUs = 2 + qubits_per_qpu = 2 + max_subcircuits = 2 interface, settings = gate_cut_test_setup - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -147,12 +147,12 @@ def test_gate_cuts( def test_wire_cuts( wire_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_QPU = 4 - num_QPUs = 2 + qubits_per_qpu = 4 + max_subcircuits = 2 interface, settings = wire_cut_test_setup - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -180,8 +180,8 @@ def test_wire_cuts( def test_select_search_engine( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_QPU = 4 - num_QPUs = 2 + qubits_per_qpu = 4 + max_subcircuits = 2 interface, settings = gate_cut_test_setup @@ -189,7 +189,7 @@ def test_select_search_engine( search_engine = settings.get_engine_selection("CutOptimization") - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -203,12 +203,12 @@ def test_multiqubit_cuts( multiqubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits requires cutting. - qubits_per_QPU = 2 - num_QPUs = 2 + qubits_per_qpu = 2 + max_subcircuits = 2 interface, settings = multiqubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -225,12 +225,12 @@ def test_multiqubit_cuts( def test_greedy_search( gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_QPU = 3 - num_QPUs = 2 + qubits_per_qpu = 3 + max_subcircuits = 2 interface, settings = gate_cut_test_setup - constraint_obj = DeviceConstraints(qubits_per_QPU, num_QPUs) + constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) # Impose a stringent cost upper bound, insist gamma <=2. cut_opt = CutOptimization(interface, settings, constraint_obj) diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index edad9dfed..b203bcb33 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -6,16 +6,19 @@ ) -@pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(1, -1), (-1, 1), (1, 0)]) -def test_device_constraints(qubits_per_QPU: int, num_QPUs: int): +@pytest.mark.parametrize("qubits_per_qpu, max_subcircuits", [(1, -1), (-1, 1), (1, 0)]) +def test_device_constraints(qubits_per_qpu: int, max_subcircuits: int): """Test device constraints for being valid data types.""" with pytest.raises(ValueError): - _ = DeviceConstraints(qubits_per_QPU, num_QPUs) + _ = DeviceConstraints(qubits_per_qpu, max_subcircuits) -@pytest.mark.parametrize("qubits_per_QPU, num_QPUs", [(2, 4), (1, 3)]) -def test_get_qpu_width(qubits_per_QPU: int, num_QPUs: int): +@pytest.mark.parametrize("qubits_per_qpu, max_subcircuits", [(2, 4), (1, 3)]) +def test_get_qpu_width(qubits_per_qpu: int, max_subcircuits: int): """Test that get_qpu_width returns number of qubits per qpu.""" - assert DeviceConstraints(qubits_per_QPU, num_QPUs).get_qpu_width() == qubits_per_QPU + assert ( + DeviceConstraints(qubits_per_qpu, max_subcircuits).get_qpu_width() + == qubits_per_qpu + ) diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index 18ab41c1e..1427c4ceb 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -27,6 +27,8 @@ partition_problem, cut_gates, find_cuts, + OptimizationParameters, + DeviceConstraints, ) from circuit_knitting.cutting.instructions import Move from circuit_knitting.cutting.qpd import ( @@ -262,9 +264,11 @@ def test_partition_problem(self): def test_find_cuts(self): with self.subTest("simple circuit"): circuit = random_circuit(7, 6, max_operands=2, seed=1242) + optimization = OptimizationParameters(seed=111) + constraints = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2) - cut_circ, metadata = find_cuts( - circuit, {"rand_seed": 111}, {"qubits_per_QPU": 4, "num_QPUs": 2} + _, metadata = find_cuts( + circuit, optimization=optimization, constraints=constraints ) cut_types = {cut[0] for cut in metadata["cuts"]} From 5f1ec957bdbc3d49c26ae0fa88b94b384db2b5ad Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 18 Mar 2024 17:30:14 -0400 Subject: [PATCH 098/128] Fix test, edit doc string. --- .../cutting/cutting_decomposition.py | 19 +++++++++---------- test/cutting/test_cutting_decomposition.py | 4 ++-- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index dba3e4360..03ae86ed5 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -277,11 +277,11 @@ def find_cuts( optimization: OptimizationParameters, constraints: DeviceConstraints, ) -> tuple[QuantumCircuit, dict[str, float]]: - """ - Find cut locations in a circuit, given optimization settings and QPU constraints. + """Find cut locations in a circuit, given optimization settings and QPU constraints. Args: - circuit: The circuit to cut + circuit: The circuit to cut. The circuit must contain only single two-qubit + gates. optimization: Instance of :class:`.OptimizationParameters` for controlling optimizer behavior. Currently, the optimal cuts are arrived at using @@ -308,13 +308,12 @@ def find_cuts( specified in ``constraints``. A metadata dictionary: - - - cuts: A list of length-2 tuples describing each cut in the output circuit. - The tuples are formatted as ``(cut_type: str, cut_id: int)``. The - cut ID is the index of the cut gate or wire in the output circuit's - ``data`` field. - - sampling_overhead: The sampling overhead incurred from cutting the specified - gates and wires. + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. Raises: ValueError: The input circuit contains a gate acting on more than 2 qubits. diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index c9c553c0d..adf6a26be 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -279,8 +279,8 @@ def test_find_cuts(self): with self.subTest("3-qubit gate"): circuit = random_circuit(3, 2, max_operands=3, seed=99) with pytest.raises(ValueError) as e_info: - cut_circ, metadata = find_cuts( - circuit, {"rand_seed": 111}, {"qubits_per_QPU": 4, "num_QPUs": 2} + _, metadata = find_cuts( + circuit, optimization=optimization, constraints=constraints ) assert e_info.value.args[0] == ( "The input circuit must contain only single and two-qubits gates. " From 9589465813074b828ccb8e0993fbe4c84996715b Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 19 Mar 2024 09:03:24 -0400 Subject: [PATCH 099/128] Correct error in tutorial --- docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 47066dc99..a0a4c979f 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -111,9 +111,9 @@ "\n", "\n", "for max_subcircuits in range(max_subcircuits, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", " print(\n", - " f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {max_subcircuits} QPUs ----------\"\n", + " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} subcircuitss ----------\"\n", " )\n", "\n", " constraint_obj = DeviceConstraints(\n", From 23ddea6795e383e2e6844c35559da592da3ed43b Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 19 Mar 2024 09:19:56 -0400 Subject: [PATCH 100/128] Correct tutorial output --- .../tutorials/LO_circuit_cut_finder.ipynb | 74 +++++++++---------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index a0a4c979f..3818a331c 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -78,24 +78,24 @@ "text": [ "\n", "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", + "---------- 4 Qubits per QPU, 2 maximum subcircuits ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", + "---------- 3 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", + "Subcircuits: AAAB \n", "\n", "\n", "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", + "---------- 2 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", + "Subcircuits: AABB \n", "\n" ] } @@ -113,7 +113,7 @@ "for max_subcircuits in range(max_subcircuits, 1, -1):\n", " for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", " print(\n", - " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} subcircuitss ----------\"\n", + " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} maximum subcircuits ----------\"\n", " )\n", "\n", " constraint_obj = DeviceConstraints(\n", @@ -160,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -170,7 +170,7 @@ "
" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -200,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -209,45 +209,45 @@ "text": [ "\n", "\n", - "---------- 7 Qubits per QPU, 2 QPUs ----------\n", + "---------- 7 Qubits per QPU, 2 maximum subcircuits ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", - "---------- 6 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", + "---------- 6 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 3.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", + "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", - "---------- 5 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", + "---------- 5 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", + "Subcircuits: AAAABABB \n", "\n", "\n", "\n", - "---------- 4 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", + "---------- 4 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 4.0 , Min_gamma_reached = True\n", + "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4], input=1))]\n", + "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", - "---------- 3 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", + "---------- 3 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 16.0 , Min_gamma_reached = True\n", + "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3], input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", + "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", - "---------- 2 Qubits per QPU, 2 QPUs ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", + "---------- 2 Qubits per QPU, 2 maximum subcircuits ----------\n", + " Gamma = 243.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", + "Subcircuits: ABCDDEF \n", "\n" ] } @@ -264,9 +264,9 @@ "\n", "\n", "for max_subcircuits in range(max_subcircuits, 1, -1):\n", - " for qpu_qubits in range(qubits_per_qpu, 1, -1):\n", + " for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", " print(\n", - " f\"\\n\\n---------- {qpu_qubits} Qubits per QPU, {max_subcircuits} QPUs ----------\"\n", + " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} maximum subcircuits ----------\"\n", " )\n", "\n", " constraint_obj = DeviceConstraints(\n", From c44f740ee005205de6992aafef0693f3b752c952 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 19 Mar 2024 16:12:02 -0400 Subject: [PATCH 101/128] Remove num_QPUs, add tests. --- .../cutting/cut_finding/cco_utils.py | 10 +- .../cut_finding/quantum_device_constraints.py | 9 +- .../cutting/cutting_decomposition.py | 1 - .../tutorials/04_automatic_cut_finding.ipynb | 4 +- .../tutorials/LO_circuit_cut_finder.ipynb | 128 +++--- .../cut_finding/test_best_first_search.py | 2 +- .../cut_finding/test_cut_finder_results.py | 389 ++++++++++++++++++ .../cut_finding/test_cut_finder_roundtrip.py | 242 ----------- .../test_quantum_device_constraints.py | 15 +- test/cutting/test_cutting_decomposition.py | 2 +- 10 files changed, 469 insertions(+), 333 deletions(-) create mode 100644 test/cutting/cut_finding/test_cut_finder_results.py delete mode 100644 test/cutting/cut_finding/test_cut_finder_roundtrip.py diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index f57a83431..bf130c7c9 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -100,10 +100,12 @@ def select_search_engine( ) -> BestFirstSearch: """Select the search algorithm to use. - In this release, the main search engine is always Dijkstra's best first search algorithm. - Note however that there is also :func:``greedy_best_first_search,`` which is used to warm start - the search algorithm. It can also provide a solution should the main search engine fail to find a - solution given the constraints on the computation it is allowed to perform. + In this release, the main search engine is always Dijkstra's + best first search algorithm. Note however that there is also + :func:``greedy_best_first_search``, which is used to warm start + the search algorithm. It can also provide a solution should the + main search engine fail to find a solution given the constraints + on the computation it is allowed to perform. """ engine = optimization_settings.get_engine_selection(stage_of_optimization) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 440a9a695..67460b838 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -18,17 +18,14 @@ @dataclass class DeviceConstraints: - """Specify the constraints (qubits per QPU and maximum number of subcircuits) that must be respected.""" + """Specify the constraints (qubits per QPU) that must be respected.""" qubits_per_qpu: int - max_subcircuits: int def __post_init__(self): """Post-init method for data class.""" - if self.qubits_per_qpu < 1 or self.max_subcircuits < 1: - raise ValueError( - "qubits_per_QPU and num_QPUs must be positive definite integers." - ) + if self.qubits_per_qpu < 1: + raise ValueError("qubits_per_QPU must be a positive definite integer.") def get_qpu_width(self) -> int: """Return the number of qubits supported on each individual QPU.""" diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 03ae86ed5..fb64d905c 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -300,7 +300,6 @@ def find_cuts( specified: - qubits_per_QPU: The maximum number of qubits each subcircuit can contain after cutting. - - max_subcircuits: The maximum number of subcircuits produced after cutting. Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index e11bd3b1f..e62513fcf 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -84,8 +84,8 @@ "# Specify settings for the cut-finding optimizer\n", "optimization_settings = OptimizationParameters(seed=111)\n", "\n", - "# Specify the size and number of the QPUs available\n", - "device_constraints = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2)\n", + "# Specify the size of the QPUs available\n", + "device_constraints = DeviceConstraints(qubits_per_qpu=4)\n", "\n", "cut_circuit, metadata = find_cuts(circuit, optimization_settings, device_constraints)\n", "print(\n", diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 3818a331c..7fc7ba10c 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -78,21 +78,21 @@ "text": [ "\n", "\n", - "---------- 4 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 4 Qubits per QPU ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", - "---------- 3 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 3 Qubits per QPU ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", "Subcircuits: AAAB \n", "\n", "\n", "\n", - "---------- 2 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 2 Qubits per QPU ----------\n", " Gamma = 9.0 , Min_gamma_reached = True\n", "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", "Subcircuits: AABB \n", @@ -107,41 +107,34 @@ "\n", "\n", "qubits_per_qpu = 4\n", - "max_subcircuits = 2\n", - "\n", "\n", - "for max_subcircuits in range(max_subcircuits, 1, -1):\n", - " for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", - " print(\n", - " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} maximum subcircuits ----------\"\n", - " )\n", "\n", - " constraint_obj = DeviceConstraints(\n", - " qubits_per_qpu=qubits_per_qpu, max_subcircuits=max_subcircuits\n", - " )\n", + "for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", + " print(f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU ----------\")\n", "\n", - " interface = SimpleGateList(circuit_ckt)\n", + " constraint_obj = DeviceConstraints(qubits_per_qpu=qubits_per_qpu)\n", + " interface = SimpleGateList(circuit_ckt)\n", "\n", - " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", + " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", "\n", - " out = op.optimize()\n", + " out = op.optimize()\n", "\n", - " print(\n", - " \" Gamma =\",\n", - " None if (out is None) else out.upper_bound_gamma(),\n", - " \", Min_gamma_reached =\",\n", - " op.minimum_reached(),\n", - " )\n", - " if out is not None:\n", - " out.print(simple=True)\n", - " else:\n", - " print(out)\n", + " print(\n", + " \" Gamma =\",\n", + " None if (out is None) else out.upper_bound_gamma(),\n", + " \", Min_gamma_reached =\",\n", + " op.minimum_reached(),\n", + " )\n", + " if out is not None:\n", + " out.print(simple=True)\n", + " else:\n", + " print(out)\n", "\n", - " print(\n", - " \"Subcircuits:\",\n", - " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", - " \"\\n\",\n", - " )" + " print(\n", + " \"Subcircuits:\",\n", + " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", + " \"\\n\",\n", + " )" ] }, { @@ -160,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -170,7 +163,7 @@ "
" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -209,45 +202,52 @@ "text": [ "\n", "\n", - "---------- 7 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 7 Qubits per QPU ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAAAAA \n", "\n", "\n", "\n", - "---------- 6 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 6 Qubits per QPU ----------\n", " Gamma = 3.0 , Min_gamma_reached = True\n", "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", "Subcircuits: AAAAAAB \n", "\n", "\n", "\n", - "---------- 5 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 5 Qubits per QPU ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", "Subcircuits: AAAABABB \n", "\n", "\n", "\n", - "---------- 4 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 4 Qubits per QPU ----------\n", " Gamma = 4.0 , Min_gamma_reached = True\n", "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4], input=1))]\n", "Subcircuits: AAAABBBB \n", "\n", "\n", "\n", - "---------- 3 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 3 Qubits per QPU ----------\n", " Gamma = 16.0 , Min_gamma_reached = True\n", "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3], input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", "Subcircuits: AABABCBCC \n", "\n", "\n", "\n", - "---------- 2 Qubits per QPU, 2 maximum subcircuits ----------\n", + "---------- 2 Qubits per QPU ----------\n", " Gamma = 243.0 , Min_gamma_reached = True\n", "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", "Subcircuits: ABCDDEF \n", + "\n", + "\n", + "\n", + "---------- 1 Qubits per QPU ----------\n", + " Gamma = 729.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", + "Subcircuits: ABCDEFG \n", "\n" ] } @@ -260,41 +260,35 @@ "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", "qubits_per_qpu = 7\n", - "max_subcircuits = 2\n", "\n", "\n", - "for max_subcircuits in range(max_subcircuits, 1, -1):\n", - " for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", - " print(\n", - " f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU, {max_subcircuits} maximum subcircuits ----------\"\n", - " )\n", + "for qubits_per_qpu in range(qubits_per_qpu, 0, -1):\n", + " print(f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU ----------\")\n", "\n", - " constraint_obj = DeviceConstraints(\n", - " qubits_per_qpu=qubits_per_qpu, max_subcircuits=max_subcircuits\n", - " )\n", + " constraint_obj = DeviceConstraints(qubits_per_qpu=qubits_per_qpu)\n", "\n", - " interface = SimpleGateList(circuit_ckt_wirecut)\n", + " interface = SimpleGateList(circuit_ckt_wirecut)\n", "\n", - " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", + " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", "\n", - " out = op.optimize()\n", + " out = op.optimize()\n", "\n", - " print(\n", - " \" Gamma =\",\n", - " None if (out is None) else out.upper_bound_gamma(),\n", - " \", Min_gamma_reached =\",\n", - " op.minimum_reached(),\n", - " )\n", - " if out is not None:\n", - " out.print(simple=True)\n", - " else:\n", - " print(out)\n", + " print(\n", + " \" Gamma =\",\n", + " None if (out is None) else out.upper_bound_gamma(),\n", + " \", Min_gamma_reached =\",\n", + " op.minimum_reached(),\n", + " )\n", + " if out is not None:\n", + " out.print(simple=True)\n", + " else:\n", + " print(out)\n", "\n", - " print(\n", - " \"Subcircuits:\",\n", - " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", - " \"\\n\",\n", - " )" + " print(\n", + " \"Subcircuits:\",\n", + " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", + " \"\\n\",\n", + " )" ] } ], diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 6c1d56a13..4388726d4 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -59,7 +59,7 @@ def test_best_first_search(test_circuit: SimpleGateList): settings.set_engine_selection("CutOptimization", "BestFirst") - constraint_obj = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2) + constraint_obj = DeviceConstraints(qubits_per_qpu=4) op = CutOptimization(test_circuit, settings, constraint_obj) diff --git a/test/cutting/cut_finding/test_cut_finder_results.py b/test/cutting/cut_finding/test_cut_finder_results.py new file mode 100644 index 000000000..0fb980166 --- /dev/null +++ b/test/cutting/cut_finding/test_cut_finder_results.py @@ -0,0 +1,389 @@ +from __future__ import annotations + +import numpy as np +from numpy import array +from pytest import fixture, raises +from qiskit import QuantumCircuit +from typing import Callable +from qiskit.circuit.library import EfficientSU2 +from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit +from circuit_knitting.cutting.cut_finding.circuit_interface import ( + SimpleGateList, +) +from circuit_knitting.cutting.cut_finding.optimization_settings import ( + OptimizationSettings, +) +from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( + DeviceConstraints, +) +from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( + get_actions_list, + OneWireCutIdentifier, + WireCutLocation, + CutIdentifier, + GateCutLocation, +) +from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import ( + LOCutsOptimizer, +) +from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization + + +@fixture +def empty_circuit(): + qc = QuantumCircuit(3) + qc.barrier([0]) + qc.barrier([1]) + qc.barrier([2]) + + +@fixture +def four_qubit_test_setup(): + qc = EfficientSU2(4, entanglement="linear", reps=2).decompose() + qc.assign_parameters([0.4] * len(qc.parameters), inplace=True) + circuit_internal = qc_to_cco_circuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(seed=12345) + settings.set_engine_selection("CutOptimization", "BestFirst") + return interface, settings + + +@fixture +def seven_qubit_test_setup(): + qc = QuantumCircuit(7) + for i in range(7): + qc.rx(np.pi / 4, i) + qc.cx(0, 3) + qc.cx(1, 3) + qc.cx(2, 3) + qc.cx(3, 4) + qc.cx(3, 5) + qc.cx(3, 6) + circuit_internal = qc_to_cco_circuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(seed=12345) + settings.set_engine_selection("CutOptimization", "BestFirst") + return interface, settings + + +@fixture +def multiqubit_gate_test_setup(): + qc = QuantumCircuit(3) + qc.ccx(0, 1, 2) + circuit_internal = qc_to_cco_circuit(qc) + interface = SimpleGateList(circuit_internal) + settings = OptimizationSettings(seed=12345) + settings.set_engine_selection("CutOptimization", "BestFirst") + return interface, settings + + +def test_no_cuts( + four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + # QPU with 4 qubits for a 4 qubit circuit results in no cutting. + qubits_per_qpu = 4 + + interface, settings = four_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize(interface, settings, constraint_obj) + + assert get_actions_list(output.actions) == [] # no cutting. + + assert interface.export_subcircuits_as_string(name_mapping="default") == "AAAA" + + +def test_four_qubit_circuit_three_qubit_qpu( + four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + # QPU with 3 qubits for a 4 qubit circuit enforces cutting. + qubits_per_qpu = 3 + + interface, settings = four_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + cut_actions_list = output.cut_actions_sublist() + + assert cut_actions_list == [ + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=17, gate_name="cx", qubits=[2, 3] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=25, gate_name="cx", qubits=[2, 3] + ), + ), + ] + best_result = optimization_pass.get_results() + + assert output.upper_bound_gamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. + + assert optimization_pass.minimum_reached() is True # matches optimal solution. + + assert ( + interface.export_subcircuits_as_string(name_mapping="default") == "AAAB" + ) # circuit separated into 2 subcircuits. + + +def test_four_qubit_circuit_two_qubit_qpu( + four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + # QPU with 2 qubits enforces cutting. + qubits_per_qpu = 2 + + interface, settings = four_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + cut_actions_list = output.cut_actions_sublist() + + assert cut_actions_list == [ + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=9, gate_name="cx", qubits=[1, 2] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=20, gate_name="cx", qubits=[1, 2] + ), + ), + ] + + best_result = optimization_pass.get_results() + + assert output.upper_bound_gamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. + + assert optimization_pass.minimum_reached() is True # matches optimal solution. + + assert ( + interface.export_subcircuits_as_string(name_mapping="default") == "AABB" + ) # circuit separated into 2 subcircuits. + + assert ( + optimization_pass.get_stats()["CutOptimization"] == array([15, 46, 15, 6]) + ).all() # matches known stats. + + +def test_seven_qubit_circuit_two_qubit_qpu( + seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + # QPU with 2 qubits enforces cutting. + qubits_per_qpu = 2 + + interface, settings = seven_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + cut_actions_list = output.cut_actions_sublist() + + assert cut_actions_list == [ + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=7, gate_name="cx", qubits=[0, 3] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=8, gate_name="cx", qubits=[1, 3] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=9, gate_name="cx", qubits=[2, 3] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=11, gate_name="cx", qubits=[3, 5] + ), + ), + CutIdentifier( + cut_action="CutTwoQubitGate", + gate_cut_location=GateCutLocation( + instruction_id=12, gate_name="cx", qubits=[3, 6] + ), + ), + ] + + best_result = optimization_pass.get_results() + + assert output.upper_bound_gamma() == best_result.gamma_UB == 243 # 5 LO cnot cuts. + + assert optimization_pass.minimum_reached() is True # matches optimal solution. + + assert ( + interface.export_subcircuits_as_string(name_mapping="default") == "ABCDDEF" + ) # circuit separated into 2 subcircuits. + + +def test_one_wire_cut( + seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + qubits_per_qpu = 4 + + interface, settings = seven_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + cut_actions_list = output.cut_actions_sublist() + + assert cut_actions_list == [ + OneWireCutIdentifier( + cut_action="CutLeftWire", + wire_cut_location=WireCutLocation( + instruction_id=10, gate_name="cx", qubits=[3, 4], input=1 + ), + ) + ] + + assert ( + interface.export_subcircuits_as_string(name_mapping="default") == "AAAABBBB" + ) # extra wires because of wire cuts + # and not qubit reuse. + + best_result = optimization_pass.get_results() + + assert output.upper_bound_gamma() == best_result.gamma_UB == 4 # One LO wire cut. + + assert optimization_pass.minimum_reached() is True # matches optimal solution + + +def test_two_wire_cuts( + seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + qubits_per_qpu = 3 + + interface, settings = seven_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + output = optimization_pass.optimize() + + cut_actions_list = output.cut_actions_sublist() + + assert cut_actions_list == [ + OneWireCutIdentifier( + cut_action="CutRightWire", + wire_cut_location=WireCutLocation( + instruction_id=9, gate_name="cx", qubits=[2, 3], input=2 + ), + ), + OneWireCutIdentifier( + cut_action="CutLeftWire", + wire_cut_location=WireCutLocation( + instruction_id=11, gate_name="cx", qubits=[3, 5], input=1 + ), + ), + ] + + assert ( + interface.export_subcircuits_as_string(name_mapping="default") == "AABABCBCC" + ) # extra wires because of wire cuts + # and no qubit reuse. In the string above, + # {A: wire 0, A:wire 1, B:wire 2, A: wire 3, + # B: first cut on wire 3, C: second cut on wire 3, + # B: wire 4, C: wire 5, C: wire 6}. + + best_result = optimization_pass.get_results() + + assert output.upper_bound_gamma() == best_result.gamma_UB == 16 # Two LO wire cuts. + + assert optimization_pass.minimum_reached() is True # matches optimal solution + + +# check if unsupported search engine is flagged. +def test_supported_search_engine( + four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + qubits_per_qpu = 4 + + interface, settings = four_qubit_test_setup + + settings.set_engine_selection("CutOptimization", "BeamSearch") + + search_engine = settings.get_engine_selection("CutOptimization") + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + with raises(ValueError) as e_info: + _ = optimization_pass.optimize() + assert e_info.value.args[0] == f"Search engine {search_engine} is not supported." + + +# The cutting of multiqubit gates is not supported at present. +def test_multiqubit_cuts( + multiqubit_gate_test_setup: Callable[ + [], tuple[SimpleGateList, OptimizationSettings] + ] +): + # QPU with 2 qubits requires cutting. + qubits_per_qpu = 2 + + interface, settings = multiqubit_gate_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) + + with raises(ValueError) as e_info: + _ = optimization_pass.optimize() + assert e_info.value.args[0] == ( + "The input circuit must contain only single and two-qubits gates. " + "Found 3-qubit gate: (ccx)." + ) + + +# Even if the input cost bounds are too stringent, greedy_cut_optimization +# is able to return a solution. +def test_greedy_search( + four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] +): + qubits_per_qpu = 3 + + interface, settings = four_qubit_test_setup + + constraint_obj = DeviceConstraints(qubits_per_qpu) + + # Impose a stringent cost upper bound, insist gamma <=2. + cut_opt = CutOptimization(interface, settings, constraint_obj) + cut_opt.update_upperbound_cost((2, 4)) + state, cost = cut_opt.optimization_pass() + + # 2 cnot cuts are still found + assert state is not None + assert cost[0] == 9 diff --git a/test/cutting/cut_finding/test_cut_finder_roundtrip.py b/test/cutting/cut_finding/test_cut_finder_roundtrip.py deleted file mode 100644 index b744e3ea5..000000000 --- a/test/cutting/cut_finding/test_cut_finder_roundtrip.py +++ /dev/null @@ -1,242 +0,0 @@ -from __future__ import annotations - -import numpy as np -from numpy import array -from pytest import fixture, raises -from qiskit import QuantumCircuit -from typing import Callable -from qiskit.circuit.library import EfficientSU2 -from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit -from circuit_knitting.cutting.cut_finding.circuit_interface import ( - SimpleGateList, -) -from circuit_knitting.cutting.cut_finding.optimization_settings import ( - OptimizationSettings, -) -from circuit_knitting.cutting.cut_finding.quantum_device_constraints import ( - DeviceConstraints, -) -from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import ( - get_actions_list, - OneWireCutIdentifier, - WireCutLocation, - CutIdentifier, - GateCutLocation, -) -from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import ( - LOCutsOptimizer, -) -from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization - - -@fixture -def empty_circuit(): - qc = QuantumCircuit(3) - qc.barrier([0]) - qc.barrier([1]) - qc.barrier([2]) - - -@fixture -def gate_cut_test_setup(): - qc = EfficientSU2(4, entanglement="linear", reps=2).decompose() - qc.assign_parameters([0.4] * len(qc.parameters), inplace=True) - circuit_internal = qc_to_cco_circuit(qc) - interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(seed=12345) - settings.set_engine_selection("CutOptimization", "BestFirst") - return interface, settings - - -@fixture -def wire_cut_test_setup(): - qc = QuantumCircuit(7) - for i in range(7): - qc.rx(np.pi / 4, i) - qc.cx(0, 3) - qc.cx(1, 3) - qc.cx(2, 3) - qc.cx(3, 4) - qc.cx(3, 5) - qc.cx(3, 6) - circuit_internal = qc_to_cco_circuit(qc) - interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(seed=12345) - settings.set_engine_selection("CutOptimization", "BestFirst") - return interface, settings - - -@fixture -def multiqubit_test_setup(): - qc = QuantumCircuit(3) - qc.ccx(0, 1, 2) - circuit_internal = qc_to_cco_circuit(qc) - interface = SimpleGateList(circuit_internal) - settings = OptimizationSettings(seed=12345) - settings.set_engine_selection("CutOptimization", "BestFirst") - return interface, settings - - -def test_no_cuts( - gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - # QPU with 4 qubits requires no cutting. - qubits_per_qpu = 4 - max_subcircuits = 2 - - interface, settings = gate_cut_test_setup - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - - output = optimization_pass.optimize(interface, settings, constraint_obj) - - assert get_actions_list(output.actions) == [] # no cutting. - - assert interface.export_subcircuits_as_string(name_mapping="default") == "AAAA" - - -def test_gate_cuts( - gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - # QPU with 2 qubits enforces cutting. - qubits_per_qpu = 2 - max_subcircuits = 2 - - interface, settings = gate_cut_test_setup - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - - output = optimization_pass.optimize() - - cut_actions_list = output.cut_actions_sublist() - - assert cut_actions_list == [ - CutIdentifier( - cut_action="CutTwoQubitGate", - gate_cut_location=GateCutLocation( - instruction_id=9, gate_name="cx", qubits=[1, 2] - ), - ), - CutIdentifier( - cut_action="CutTwoQubitGate", - gate_cut_location=GateCutLocation( - instruction_id=20, gate_name="cx", qubits=[1, 2] - ), - ), - ] - - best_result = optimization_pass.get_results() - - assert output.upper_bound_gamma() == best_result.gamma_UB == 9 # 2 LO cnot cuts. - - assert optimization_pass.minimum_reached() is True # matches optimal solution. - - assert ( - interface.export_subcircuits_as_string(name_mapping="default") == "AABB" - ) # circuit separated into 2 subcircuits. - - assert ( - optimization_pass.get_stats()["CutOptimization"] == array([15, 46, 15, 6]) - ).all() # matches known stats. - - -def test_wire_cuts( - wire_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - qubits_per_qpu = 4 - max_subcircuits = 2 - - interface, settings = wire_cut_test_setup - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - - output = optimization_pass.optimize() - - cut_actions_list = output.cut_actions_sublist() - - assert cut_actions_list == [ - OneWireCutIdentifier( - cut_action="CutLeftWire", - wire_cut_location=WireCutLocation( - instruction_id=10, gate_name="cx", qubits=[3, 4], input=1 - ), - ) - ] - - best_result = optimization_pass.get_results() - - assert output.upper_bound_gamma() == best_result.gamma_UB == 4 # One LO wire cut. - - assert optimization_pass.minimum_reached() is True # matches optimal solution - - -# check if unsupported search engine is flagged. -def test_select_search_engine( - gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - qubits_per_qpu = 4 - max_subcircuits = 2 - - interface, settings = gate_cut_test_setup - - settings.set_engine_selection("CutOptimization", "BeamSearch") - - search_engine = settings.get_engine_selection("CutOptimization") - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - - with raises(ValueError) as e_info: - _ = optimization_pass.optimize() - assert e_info.value.args[0] == f"Search engine {search_engine} is not supported." - - -# The cutting of multiqubit gates is not supported at present. -def test_multiqubit_cuts( - multiqubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - # QPU with 2 qubits requires cutting. - qubits_per_qpu = 2 - max_subcircuits = 2 - - interface, settings = multiqubit_test_setup - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) - - with raises(ValueError) as e_info: - _ = optimization_pass.optimize() - assert e_info.value.args[0] == ( - "The input circuit must contain only single and two-qubits gates. " - "Found 3-qubit gate: (ccx)." - ) - - -# Even if the input cost bounds are too stringent, greedy_cut_optimization -# is able to return a solution. -def test_greedy_search( - gate_cut_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] -): - qubits_per_qpu = 3 - max_subcircuits = 2 - - interface, settings = gate_cut_test_setup - - constraint_obj = DeviceConstraints(qubits_per_qpu, max_subcircuits) - - # Impose a stringent cost upper bound, insist gamma <=2. - cut_opt = CutOptimization(interface, settings, constraint_obj) - cut_opt.update_upperbound_cost((2, 4)) - state, cost = cut_opt.optimization_pass() - - # 2 cnot cuts are still found - assert state is not None - assert cost[0] == 9 diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index b203bcb33..a010f226b 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -6,19 +6,16 @@ ) -@pytest.mark.parametrize("qubits_per_qpu, max_subcircuits", [(1, -1), (-1, 1), (1, 0)]) -def test_device_constraints(qubits_per_qpu: int, max_subcircuits: int): +@pytest.mark.parametrize("qubits_per_qpu", [-1, 0]) +def test_device_constraints(qubits_per_qpu: int): """Test device constraints for being valid data types.""" with pytest.raises(ValueError): - _ = DeviceConstraints(qubits_per_qpu, max_subcircuits) + _ = DeviceConstraints(qubits_per_qpu) -@pytest.mark.parametrize("qubits_per_qpu, max_subcircuits", [(2, 4), (1, 3)]) -def test_get_qpu_width(qubits_per_qpu: int, max_subcircuits: int): +@pytest.mark.parametrize("qubits_per_qpu", [2, 1]) +def test_get_qpu_width(qubits_per_qpu: int): """Test that get_qpu_width returns number of qubits per qpu.""" - assert ( - DeviceConstraints(qubits_per_qpu, max_subcircuits).get_qpu_width() - == qubits_per_qpu - ) + assert DeviceConstraints(qubits_per_qpu).get_qpu_width() == qubits_per_qpu diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index adf6a26be..1072db122 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -265,7 +265,7 @@ def test_find_cuts(self): with self.subTest("simple circuit"): circuit = random_circuit(7, 6, max_operands=2, seed=1242) optimization = OptimizationParameters(seed=111) - constraints = DeviceConstraints(qubits_per_qpu=4, max_subcircuits=2) + constraints = DeviceConstraints(qubits_per_qpu=4) _, metadata = find_cuts( circuit, optimization=optimization, constraints=constraints From aa6ed3312363694568e237e74860f894e00b2d8d Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 21 Mar 2024 10:47:13 -0400 Subject: [PATCH 102/128] Edit doc string, fix type hint for backjumps. --- .../cutting/cut_finding/cut_optimization.py | 10 +++++++++- .../cutting/cut_finding/lo_cuts_optimizer.py | 10 +++++++++- .../cutting/cut_finding/optimization_settings.py | 15 +++++++++------ 3 files changed, 27 insertions(+), 8 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index fbe6a3ca6..39bf0ff0e 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -290,7 +290,15 @@ def minimum_reached(self) -> bool: return self.search_engine.minimum_reached() def get_stats(self, penultimate: bool = False) -> NDArray[np.int_]: - """Return the search-engine statistics.""" + """Return the search-engine statistics. + + This is a Numpy array containing the number of states visited + (dequeued), the number of next-states generated, the number of + next-states that are enqueued after cost pruning, and the number + of backjumps performed. Return None if no search is performed. + If the bool penultimate is set to True, return the stats that + correspond to the penultimate step in the search. + """ return self.search_engine.get_stats(penultimate=penultimate) def get_upperbound_cost(self) -> tuple[float, float]: diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index a5023c82d..5fa6bc988 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -148,7 +148,15 @@ def get_results(self) -> DisjointSubcircuitsState | None: return self.best_result def get_stats(self, penultimate=False) -> dict[str, NDArray[np.int_]]: - """Return a dictionary containing optimization results.""" + """Return a dictionary containing optimization results. + + The value is a Numpy array containing the number of states visited + (dequeued), the number of next-states generated, the number of + next-states that are enqueued after cost pruning, and the number + of backjumps performed. Return None if no search is performed. + If the bool penultimate is set to True, return the stats that + correspond to the penultimate step in the search. + """ return { "CutOptimization": self.cut_optimization.get_stats(penultimate=penultimate) } diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index f79e835f4..dd5a245f0 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -30,7 +30,7 @@ class OptimizationSettings: ``engine_selections`` is a dictionary that defines the selection of search engines for the optimization. - ``max_backjumps`` specifies a constraint on the maximum number of backjump + ``max_backjumps`` specifies any constraints on the maximum number of backjump operations that can be performed by the search algorithm. ``seed`` is a seed used to provide a repeatable initialization @@ -43,7 +43,7 @@ class OptimizationSettings: """ max_gamma: float = 1024 - max_backjumps: int = 10000 + max_backjumps: None | int = 10000 seed: int | None = None LO: bool = True LOCC_ancillas: bool = False @@ -54,7 +54,7 @@ def __post_init__(self): """Post-init method for the data class.""" if self.max_gamma < 1: raise ValueError("max_gamma must be a positive definite integer.") - if self.max_backjumps < 0: + if self.max_backjumps is not None and self.max_backjumps < 0: raise ValueError("max_backjumps must be a positive semi-definite integer.") self.gate_cut_LO = self.LO @@ -72,8 +72,11 @@ def get_max_gamma(self) -> float: return self.max_gamma @property - def get_max_backjumps(self) -> int: - """Return the maximum number of allowed search backjumps.""" + def get_max_backjumps(self) -> None | int: + """Return the maximum number of allowed search backjumps. + + `None` denotes that there is no such restriction in place. + """ return self.max_backjumps @property @@ -140,4 +143,4 @@ class OptimizationParameters: seed: int | None = OptimizationSettings().seed max_gamma: float = OptimizationSettings().max_gamma - max_backjumps: int = OptimizationSettings().max_backjumps + max_backjumps: None | int = OptimizationSettings().max_backjumps From 25a9d06ddc31d32ddc119ac36cdff74e8a48eb01 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Fri, 22 Mar 2024 19:03:55 -0500 Subject: [PATCH 103/128] Fix bug in indexing in find_cuts, and fix docstring --- .../cutting/cutting_decomposition.py | 64 +++++++++---------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index fb64d905c..711634003 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -280,39 +280,39 @@ def find_cuts( """Find cut locations in a circuit, given optimization settings and QPU constraints. Args: - circuit: The circuit to cut. The circuit must contain only single two-qubit - gates. - - optimization: Instance of :class:`.OptimizationParameters` for controlling - optimizer behavior. Currently, the optimal cuts are arrived at using - Dijkstra's best-first search algorithm. The specified parameters are: - - max_gamma: Specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered - feasible. Note that the sampling overhead is ``gamma ** 2``. - - max_backjumps: Specifies a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. - - seed: Used to provide a repeatable initialization of the pseudorandom - number generators used for breaking ties in the optimization. If ``None`` - is used as the seed, then a seed is obtained using an operating system call - to achieve an unrepeatable random initialization. - - constraints: An instance of :class:`.DeviceConstraints` with the following - specified: - - qubits_per_QPU: The maximum number of qubits each subcircuit can contain - after cutting. + circuit: The circuit to cut. The circuit must contain only single two-qubit + gates. + optimization: Options for controlling optimizer behavior. Currently, the optimal + cuts are arrived at using Dijkstra's best-first search algorithm. The specified + parameters are: + + - max_gamma: Specifies a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered + feasible. Note that the sampling overhead is ``gamma ** 2``. + - max_backjumps: Specifies a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. + - seed: Used to provide a repeatable initialization of the pseudorandom + number generators used for breaking ties in the optimization. If no seed + is provided, a seed is obtained using an operating system call + to achieve an unrepeatable random initialization. + constraints: An instance of :class:`.DeviceConstraints` with the following + specified: + + - qubits_per_QPU: The maximum number of qubits each subcircuit can contain + after cutting. Returns: - A circuit containing :class:`.BaseQPDGate` instances. The subcircuits - resulting from cutting these gates will be runnable on the devices - specified in ``constraints``. - - A metadata dictionary: - - cuts: A list of length-2 tuples describing each cut in the output circuit. - The tuples are formatted as ``(cut_type: str, cut_id: int)``. The - cut ID is the index of the cut gate or wire in the output circuit's - ``data`` field. - - sampling_overhead: The sampling overhead incurred from cutting the specified - gates and wires. + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + + A metadata dictionary: + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. Raises: ValueError: The input circuit contains a gate acting on more than 2 qubits. @@ -364,7 +364,7 @@ def find_cuts( circ_out.data.insert( inst_id + counter, CircuitInstruction( - CutWire(), [circuit.data[inst_id + counter].qubits[qubit_id]], [] + CutWire(), [circuit.data[inst_id].qubits[qubit_id]], [] ), ) counter += 1 From 6493ac530fdfd58d0cc7cebf769492670ada8a30 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Fri, 22 Mar 2024 19:11:15 -0500 Subject: [PATCH 104/128] Fix funky rendering --- circuit_knitting/cutting/cutting_decomposition.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 711634003..adf838cfe 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -291,10 +291,7 @@ def find_cuts( feasible. Note that the sampling overhead is ``gamma ** 2``. - max_backjumps: Specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - - seed: Used to provide a repeatable initialization of the pseudorandom - number generators used for breaking ties in the optimization. If no seed - is provided, a seed is obtained using an operating system call - to achieve an unrepeatable random initialization. + - seed: A seed for the pseudorandom number generator used by the optimizer constraints: An instance of :class:`.DeviceConstraints` with the following specified: From 0c5d50fc21c441c47312abf2278344a1ab1aaad3 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Fri, 22 Mar 2024 19:13:25 -0500 Subject: [PATCH 105/128] docstring --- circuit_knitting/cutting/cutting_decomposition.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index adf838cfe..e95f3372d 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -292,8 +292,7 @@ def find_cuts( - max_backjumps: Specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - seed: A seed for the pseudorandom number generator used by the optimizer - constraints: An instance of :class:`.DeviceConstraints` with the following - specified: + constraints: Options for specifying the constraints for circuit cutting - qubits_per_QPU: The maximum number of qubits each subcircuit can contain after cutting. From 149e1f58d7ad9ee597736476896e973da357f880 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 22 Mar 2024 22:23:47 -0400 Subject: [PATCH 106/128] Fix remnant of indexing bug. --- .../cutting/cut_finding/best_first_search.py | 2 +- .../cut_finding/disjoint_subcircuits_state.py | 2 +- circuit_knitting/cutting/cutting_decomposition.py | 12 +++++++----- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index af943da8b..24ed21e08 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -41,7 +41,7 @@ class BestFirstPriorityQueue: lexically-ordered costs that are to be minimized. (int) is the negative of the search depth of the - search state represented by the tuple. Thus, if several search states + search state represented by the tuple. Thus, if several search states have identical costs, priority is given to the deepest states to encourage depth-first behavior. diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index e9c93d434..6a2b28b30 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -9,7 +9,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Class needed for representing search-space states when cutting circuits.""" +"""Classes needed for representing search-space states when cutting circuits.""" from __future__ import annotations diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index fb64d905c..5471b789f 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -359,13 +359,15 @@ def find_cuts( counter = 0 for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): inst_id = action.gate_spec.instruction_id - # args[0][0] will be either 1 (control) or 2 (target) + # action.args[0][0] will be either 1 (control) or 2 (target) + print(action) qubit_id = action.args[0][0] - 1 + print(inst_id) + print(qubit_id) + print(circuit.data[inst_id + counter]) circ_out.data.insert( inst_id + counter, - CircuitInstruction( - CutWire(), [circuit.data[inst_id + counter].qubits[qubit_id]], [] - ), + CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), ) counter += 1 if action.action.get_name() == "CutBothWires": @@ -375,7 +377,7 @@ def find_cuts( circ_out.data.insert( inst_id + counter, CircuitInstruction( - CutWire(), [circuit.data[inst_id + counter].qubits[qubit_id2]], [] + CutWire(), [circuit.data[inst_id].qubits[qubit_id2]], [] ), ) counter += 1 From 0c2ceb54bf34c72c8fce067f8bc1aaaedeabab5d Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 22 Mar 2024 22:32:37 -0400 Subject: [PATCH 107/128] Fix remnant of indexing bug. --- circuit_knitting/cutting/cutting_decomposition.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index f20831921..1ef0e1d43 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -356,17 +356,11 @@ def find_cuts( for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): inst_id = action.gate_spec.instruction_id # action.args[0][0] will be either 1 (control) or 2 (target) - print(action) qubit_id = action.args[0][0] - 1 - print(inst_id) - print(qubit_id) - print(circuit.data[inst_id + counter]) circ_out.data.insert( inst_id + counter, CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), - CircuitInstruction( - CutWire(), [circuit.data[inst_id].qubits[qubit_id]], [] - ), + CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), ) counter += 1 if action.action.get_name() == "CutBothWires": From 33052254dc71f9dc4ea369edce988c509d027c89 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 22 Mar 2024 22:37:41 -0400 Subject: [PATCH 108/128] Remove typo in cutting_optimization, update doc string. --- circuit_knitting/cutting/cutting_decomposition.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 1ef0e1d43..989db8d9e 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -294,9 +294,6 @@ def find_cuts( - seed: A seed for the pseudorandom number generator used by the optimizer constraints: Options for specifying the constraints for circuit cutting - - qubits_per_QPU: The maximum number of qubits each subcircuit can contain - after cutting. - Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits resulting from cutting these gates will be runnable on the devices @@ -360,7 +357,6 @@ def find_cuts( circ_out.data.insert( inst_id + counter, CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), - CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), ) counter += 1 if action.action.get_name() == "CutBothWires": From 22f99ee6e38a4ba42e187416b6ff7f7f0013897b Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Sat, 23 Mar 2024 18:31:48 -0500 Subject: [PATCH 109/128] Use new opt settings class --- circuit_knitting/cutting/__init__.py | 11 +++++++++++ circuit_knitting/cutting/cut_finding/__init__.py | 3 +++ 2 files changed, 14 insertions(+) diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index 323de1d8c..1249af0d2 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -61,6 +61,17 @@ qpd.decompose_qpd_instructions qpd.qpdbasis_from_instruction +Automatic Cut Finding +===================== + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + :template: autosummary/class_no_inherited_members.rst + + cut_finding.OptimizationSettings + cut_finding.DeviceConstraints + CutQC ===== diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index 3589d3bff..ae120c340 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -8,3 +8,6 @@ # that they have been altered from the originals. """Main automated cut finding functionality.""" + +from .optimization_settings import OptimizationParameters +from .quantum_device_constraints import DeviceConstraints From ca597a4f975831abe2f206557f805aacc2cf50c1 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Sat, 23 Mar 2024 18:34:14 -0500 Subject: [PATCH 110/128] Update to new class in cutting pkg --- circuit_knitting/cutting/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index 1249af0d2..adfe632c6 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -69,7 +69,7 @@ :nosignatures: :template: autosummary/class_no_inherited_members.rst - cut_finding.OptimizationSettings + cut_finding.OptimizationParameters cut_finding.DeviceConstraints CutQC From de8a2732d548f6a5eae50928f7b69ad69c5862cf Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Sat, 23 Mar 2024 20:19:01 -0400 Subject: [PATCH 111/128] Fix style, docstring. --- circuit_knitting/cutting/cut_finding/__init__.py | 2 ++ circuit_knitting/cutting/cutting_decomposition.py | 6 ++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/__init__.py b/circuit_knitting/cutting/cut_finding/__init__.py index ae120c340..038e85f72 100644 --- a/circuit_knitting/cutting/cut_finding/__init__.py +++ b/circuit_knitting/cutting/cut_finding/__init__.py @@ -11,3 +11,5 @@ from .optimization_settings import OptimizationParameters from .quantum_device_constraints import DeviceConstraints + +__all__ = ["DeviceConstraints", "OptimizationParameters"] diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 989db8d9e..8c8d91975 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -291,9 +291,11 @@ def find_cuts( feasible. Note that the sampling overhead is ``gamma ** 2``. - max_backjumps: Specifies a constraint on the maximum number of backjump operations that can be performed by the search algorithm. - - seed: A seed for the pseudorandom number generator used by the optimizer - constraints: Options for specifying the constraints for circuit cutting + - seed: A seed for the pseudorandom number generator used by the optimizer. + constraints: Options for specifying the constraints for circuit cutting: + - qubits_per_qpu: The maximum number of qubits per qpu, which here + is the same as the maximum number of number of qubits per subcircuit. Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits resulting from cutting these gates will be runnable on the devices From ad62b384e4eda9e1f42e8dc84b456cfd1d7f0fb4 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 09:40:49 -0500 Subject: [PATCH 112/128] release note --- .../notes/automatic-cut-finding-696556915e347138.yaml | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 releasenotes/notes/automatic-cut-finding-696556915e347138.yaml diff --git a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml new file mode 100644 index 000000000..bde1f2cc2 --- /dev/null +++ b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml @@ -0,0 +1,9 @@ +--- +features: + - | + Added a function, :func:`circuit_knitting.cutting.find_cuts`, for automatically + identifying locations to place gate and wire cuts such that the circuit is + separable and runnable, given some QPU constraints. The optimizer will + try to choose cut schemes which minimize the sampling overhead, but for larger + circuits, the number of cuts needed to separate the circuit will naturally + grow larger, leading to exponentially higher sampling overheads. From cc8788e1ca584c5735291cb27fd3ba99ad7a319f Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 25 Mar 2024 11:54:01 -0400 Subject: [PATCH 113/128] Edit release notes, clean up tutorial From 1e497c4ff1c2fbaebd9aaf4c017c132d09c299d5 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 25 Mar 2024 12:10:02 -0400 Subject: [PATCH 114/128] Change to qubits per subcircuit everywhere --- .../cut_finding/quantum_device_constraints.py | 10 +++-- .../cutting/cutting_decomposition.py | 3 +- .../tutorials/04_automatic_cut_finding.ipynb | 4 +- .../tutorials/LO_circuit_cut_finder.ipynb | 42 +++++++++---------- .../cut_finding/test_best_first_search.py | 2 +- .../cut_finding/test_cut_finder_results.py | 36 ++++++++-------- .../test_quantum_device_constraints.py | 15 ++++--- test/cutting/test_cutting_decomposition.py | 2 +- 8 files changed, 59 insertions(+), 55 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 67460b838..20b08485e 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -20,13 +20,15 @@ class DeviceConstraints: """Specify the constraints (qubits per QPU) that must be respected.""" - qubits_per_qpu: int + qubits_per_subcircuit: int def __post_init__(self): """Post-init method for data class.""" - if self.qubits_per_qpu < 1: - raise ValueError("qubits_per_QPU must be a positive definite integer.") + if self.qubits_per_subcircuit < 1: + raise ValueError( + "qubits_per_subcircuit must be a positive definite integer." + ) def get_qpu_width(self) -> int: """Return the number of qubits supported on each individual QPU.""" - return self.qubits_per_qpu + return self.qubits_per_subcircuit diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 8c8d91975..38ddc11fe 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -294,8 +294,7 @@ def find_cuts( - seed: A seed for the pseudorandom number generator used by the optimizer. constraints: Options for specifying the constraints for circuit cutting: - - qubits_per_qpu: The maximum number of qubits per qpu, which here - is the same as the maximum number of number of qubits per subcircuit. + - qubits_per_subcircuit: The maximum number of qubits per subcircuit. Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits resulting from cutting these gates will be runnable on the devices diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index e62513fcf..10cb1a6a1 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -45,7 +45,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Find cut locations, given two QPUs with four qubits each. This circuit can be separated in two by making a single wire cut and cutting one `CRZGate`" + "#### Find cut locations, given a maximum of 4 qubits per subcircuit. This circuit can be separated in two by making a single wire cut and cutting one `CRZGate`" ] }, { @@ -85,7 +85,7 @@ "optimization_settings = OptimizationParameters(seed=111)\n", "\n", "# Specify the size of the QPUs available\n", - "device_constraints = DeviceConstraints(qubits_per_qpu=4)\n", + "device_constraints = DeviceConstraints(qubits_per_subcircuit=4)\n", "\n", "cut_circuit, metadata = find_cuts(circuit, optimization_settings, device_constraints)\n", "print(\n", diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 7fc7ba10c..426a3c14d 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -78,24 +78,24 @@ "text": [ "\n", "\n", - "---------- 4 Qubits per QPU ----------\n", + "---------- 4 Qubits per subcircuit ----------\n", " Gamma = 1.0 , Min_gamma_reached = True\n", "[]\n", "Subcircuits: AAAA \n", "\n", "\n", "\n", - "---------- 3 Qubits per QPU ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", - "Subcircuits: AAAB \n", + "---------- 4 Qubits per subcircuit ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", "\n", "\n", "\n", - "---------- 2 Qubits per QPU ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", - "Subcircuits: AABB \n", + "---------- 4 Qubits per subcircuit ----------\n", + " Gamma = 1.0 , Min_gamma_reached = True\n", + "[]\n", + "Subcircuits: AAAA \n", "\n" ] } @@ -106,13 +106,13 @@ "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", "\n", - "qubits_per_qpu = 4\n", + "qubits_per_subcircuit = 4\n", "\n", "\n", - "for qubits_per_qpu in range(qubits_per_qpu, 1, -1):\n", - " print(f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU ----------\")\n", + "for qubits_per_subcircuit in range(qubits_per_subcircuit, 1, -1):\n", + " print(f\"\\n\\n---------- {qubits_per_subcircuit} Qubits per subcircuit ----------\")\n", "\n", - " constraint_obj = DeviceConstraints(qubits_per_qpu=qubits_per_qpu)\n", + " constraint_obj = DeviceConstraints(qubits_per_subcircuit=qubits_per_subcircuit)\n", " interface = SimpleGateList(circuit_ckt)\n", "\n", " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -163,7 +163,7 @@ "
" ] }, - "execution_count": 4, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -259,13 +259,13 @@ "\n", "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", "\n", - "qubits_per_qpu = 7\n", + "qubits_per_subcircuit = 7\n", "\n", "\n", - "for qubits_per_qpu in range(qubits_per_qpu, 0, -1):\n", - " print(f\"\\n\\n---------- {qubits_per_qpu} Qubits per QPU ----------\")\n", + "for qubits_per_subcircuit in range(qubits_per_subcircuit, 0, -1):\n", + " print(f\"\\n\\n---------- {qubits_per_subcircuit} Qubits per QPU ----------\")\n", "\n", - " constraint_obj = DeviceConstraints(qubits_per_qpu=qubits_per_qpu)\n", + " constraint_obj = DeviceConstraints(qubits_per_subcircuit=qubits_per_subcircuit)\n", "\n", " interface = SimpleGateList(circuit_ckt_wirecut)\n", "\n", diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py index 4388726d4..342e92843 100644 --- a/test/cutting/cut_finding/test_best_first_search.py +++ b/test/cutting/cut_finding/test_best_first_search.py @@ -59,7 +59,7 @@ def test_best_first_search(test_circuit: SimpleGateList): settings.set_engine_selection("CutOptimization", "BestFirst") - constraint_obj = DeviceConstraints(qubits_per_qpu=4) + constraint_obj = DeviceConstraints(qubits_per_subcircuit=4) op = CutOptimization(test_circuit, settings, constraint_obj) diff --git a/test/cutting/cut_finding/test_cut_finder_results.py b/test/cutting/cut_finding/test_cut_finder_results.py index 0fb980166..62382a318 100644 --- a/test/cutting/cut_finding/test_cut_finder_results.py +++ b/test/cutting/cut_finding/test_cut_finder_results.py @@ -81,11 +81,11 @@ def test_no_cuts( four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 4 qubits for a 4 qubit circuit results in no cutting. - qubits_per_qpu = 4 + qubits_per_subcircuit = 4 interface, settings = four_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -100,11 +100,11 @@ def test_four_qubit_circuit_three_qubit_qpu( four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 3 qubits for a 4 qubit circuit enforces cutting. - qubits_per_qpu = 3 + qubits_per_subcircuit = 3 interface, settings = four_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -141,11 +141,11 @@ def test_four_qubit_circuit_two_qubit_qpu( four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits enforces cutting. - qubits_per_qpu = 2 + qubits_per_subcircuit = 2 interface, settings = four_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -187,11 +187,11 @@ def test_seven_qubit_circuit_two_qubit_qpu( seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): # QPU with 2 qubits enforces cutting. - qubits_per_qpu = 2 + qubits_per_subcircuit = 2 interface, settings = seven_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -246,11 +246,11 @@ def test_seven_qubit_circuit_two_qubit_qpu( def test_one_wire_cut( seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_qpu = 4 + qubits_per_subcircuit = 4 interface, settings = seven_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -282,11 +282,11 @@ def test_one_wire_cut( def test_two_wire_cuts( seven_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_qpu = 3 + qubits_per_subcircuit = 3 interface, settings = seven_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -328,7 +328,7 @@ def test_two_wire_cuts( def test_supported_search_engine( four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_qpu = 4 + qubits_per_subcircuit = 4 interface, settings = four_qubit_test_setup @@ -336,7 +336,7 @@ def test_supported_search_engine( search_engine = settings.get_engine_selection("CutOptimization") - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -352,11 +352,11 @@ def test_multiqubit_cuts( ] ): # QPU with 2 qubits requires cutting. - qubits_per_qpu = 2 + qubits_per_subcircuit = 2 interface, settings = multiqubit_gate_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj) @@ -373,11 +373,11 @@ def test_multiqubit_cuts( def test_greedy_search( four_qubit_test_setup: Callable[[], tuple[SimpleGateList, OptimizationSettings]] ): - qubits_per_qpu = 3 + qubits_per_subcircuit = 3 interface, settings = four_qubit_test_setup - constraint_obj = DeviceConstraints(qubits_per_qpu) + constraint_obj = DeviceConstraints(qubits_per_subcircuit) # Impose a stringent cost upper bound, insist gamma <=2. cut_opt = CutOptimization(interface, settings, constraint_obj) diff --git a/test/cutting/cut_finding/test_quantum_device_constraints.py b/test/cutting/cut_finding/test_quantum_device_constraints.py index a010f226b..59fd6a536 100644 --- a/test/cutting/cut_finding/test_quantum_device_constraints.py +++ b/test/cutting/cut_finding/test_quantum_device_constraints.py @@ -6,16 +6,19 @@ ) -@pytest.mark.parametrize("qubits_per_qpu", [-1, 0]) -def test_device_constraints(qubits_per_qpu: int): +@pytest.mark.parametrize("qubits_per_subcircuit", [-1, 0]) +def test_device_constraints(qubits_per_subcircuit: int): """Test device constraints for being valid data types.""" with pytest.raises(ValueError): - _ = DeviceConstraints(qubits_per_qpu) + _ = DeviceConstraints(qubits_per_subcircuit) -@pytest.mark.parametrize("qubits_per_qpu", [2, 1]) -def test_get_qpu_width(qubits_per_qpu: int): +@pytest.mark.parametrize("qubits_per_subcircuit", [2, 1]) +def test_get_qpu_width(qubits_per_subcircuit: int): """Test that get_qpu_width returns number of qubits per qpu.""" - assert DeviceConstraints(qubits_per_qpu).get_qpu_width() == qubits_per_qpu + assert ( + DeviceConstraints(qubits_per_subcircuit).get_qpu_width() + == qubits_per_subcircuit + ) diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index 1072db122..8b03b1e79 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -265,7 +265,7 @@ def test_find_cuts(self): with self.subTest("simple circuit"): circuit = random_circuit(7, 6, max_operands=2, seed=1242) optimization = OptimizationParameters(seed=111) - constraints = DeviceConstraints(qubits_per_qpu=4) + constraints = DeviceConstraints(qubits_per_subcircuit=4) _, metadata = find_cuts( circuit, optimization=optimization, constraints=constraints From 5a501a6e33d037071295e0b1a875ffcb17499626 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Mon, 25 Mar 2024 12:36:07 -0400 Subject: [PATCH 115/128] Expand release note --- ...automatic-cut-finding-696556915e347138.yaml | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml index bde1f2cc2..c59e22add 100644 --- a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml +++ b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml @@ -1,9 +1,15 @@ --- features: - | - Added a function, :func:`circuit_knitting.cutting.find_cuts`, for automatically - identifying locations to place gate and wire cuts such that the circuit is - separable and runnable, given some QPU constraints. The optimizer will - try to choose cut schemes which minimize the sampling overhead, but for larger - circuits, the number of cuts needed to separate the circuit will naturally - grow larger, leading to exponentially higher sampling overheads. + Added a cut-finder function, :func:`circuit_knitting.cutting.find_cuts`, for automatically + identifying locations to place LO gate and wire cuts such that the circuit is + separable and runnable, given the maximum number of qubits per subcircuit. + The cut-finder will search for cut schemes which minimize the sampling overhead. + Note, however, that for larger circuits, the number of cuts needed to separate the + circuit will naturally grow larger, leading to an exponentially increasing sampling overhead. + For instances of wire cuts, the cut-finder assumes no qubit reuse. Therefore, for each wire + cut, a new wire is added to the circuit. In addition, the cut-finder requires that every gate + in an input circuit be at most a two qubit gate. The search algorithm used by the cut-finder + to identify cut locations is Dijkstra's best first search algorithm which is guaranteed to find + solutions with the lowest sampling overhead, provided any user-specified value for the maximum number + of allowed backjumps or for the maximum sampling overhead does not prematurely stop the search. \ No newline at end of file From c832fc54c4bdf05855f7e90568a209e0ca51cef2 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 18:47:16 -0500 Subject: [PATCH 116/128] Create find_cuts module --- circuit_knitting/cutting/__init__.py | 2 +- .../cutting/cutting_decomposition.py | 124 +-------------- circuit_knitting/cutting/find_cuts.py | 142 ++++++++++++++++++ test/cutting/test_cutting_decomposition.py | 32 +--- test/cutting/test_find_cuts.py | 52 +++++++ 5 files changed, 197 insertions(+), 155 deletions(-) create mode 100644 circuit_knitting/cutting/find_cuts.py create mode 100644 test/cutting/test_find_cuts.py diff --git a/circuit_knitting/cutting/__init__.py b/circuit_knitting/cutting/__init__.py index adfe632c6..579719b1e 100644 --- a/circuit_knitting/cutting/__init__.py +++ b/circuit_knitting/cutting/__init__.py @@ -93,8 +93,8 @@ partition_problem, cut_gates, PartitionedCuttingProblem, - find_cuts, ) +from .find_cuts import find_cuts from .cutting_experiments import generate_cutting_experiments from .cutting_reconstruction import reconstruct_expectation_values from .wire_cutting_transforms import cut_wires, expand_observables diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 38ddc11fe..8a7881589 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -13,9 +13,9 @@ from __future__ import annotations +from typing import NamedTuple from collections import defaultdict from collections.abc import Sequence, Hashable -from typing import NamedTuple, cast, Any from qiskit.circuit import ( QuantumCircuit, @@ -28,16 +28,6 @@ from ..utils.transforms import separate_circuit, _partition_labels_from_circuit from .qpd.qpd_basis import QPDBasis from .qpd.instructions import TwoQubitQPDGate -from .instructions import CutWire -from .cut_finding.optimization_settings import ( - OptimizationSettings, - OptimizationParameters, -) -from .cut_finding.quantum_device_constraints import DeviceConstraints -from .cut_finding.disjoint_subcircuits_state import DisjointSubcircuitsState -from .cut_finding.circuit_interface import SimpleGateList -from .cut_finding.lo_cuts_optimizer import LOCutsOptimizer -from .cut_finding.cco_utils import qc_to_cco_circuit class PartitionedCuttingProblem(NamedTuple): @@ -270,115 +260,3 @@ def decompose_observables( } return subobservables_by_subsystem - - -def find_cuts( - circuit: QuantumCircuit, - optimization: OptimizationParameters, - constraints: DeviceConstraints, -) -> tuple[QuantumCircuit, dict[str, float]]: - """Find cut locations in a circuit, given optimization settings and QPU constraints. - - Args: - circuit: The circuit to cut. The circuit must contain only single two-qubit - gates. - optimization: Options for controlling optimizer behavior. Currently, the optimal - cuts are arrived at using Dijkstra's best-first search algorithm. The specified - parameters are: - - - max_gamma: Specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered - feasible. Note that the sampling overhead is ``gamma ** 2``. - - max_backjumps: Specifies a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. - - seed: A seed for the pseudorandom number generator used by the optimizer. - - constraints: Options for specifying the constraints for circuit cutting: - - qubits_per_subcircuit: The maximum number of qubits per subcircuit. - Returns: - A circuit containing :class:`.BaseQPDGate` instances. The subcircuits - resulting from cutting these gates will be runnable on the devices - specified in ``constraints``. - - A metadata dictionary: - - cuts: A list of length-2 tuples describing each cut in the output circuit. - The tuples are formatted as ``(cut_type: str, cut_id: int)``. The - cut ID is the index of the cut gate or wire in the output circuit's - ``data`` field. - - sampling_overhead: The sampling overhead incurred from cutting the specified - gates and wires. - - Raises: - ValueError: The input circuit contains a gate acting on more than 2 qubits. - """ - circuit_cco = qc_to_cco_circuit(circuit) - interface = SimpleGateList(circuit_cco) - - opt_settings = OptimizationSettings( - seed=optimization.seed, - max_gamma=optimization.max_gamma, - max_backjumps=optimization.max_backjumps, - ) - - # Hard-code the optimizer to an LO-only optimizer - optimizer = LOCutsOptimizer(interface, opt_settings, constraints) - - # Find cut locations - opt_out = optimizer.optimize() - - wire_cut_actions = [] - gate_ids = [] - - opt_out = cast(DisjointSubcircuitsState, opt_out) - opt_out.actions = cast(list, opt_out.actions) - for action in opt_out.actions: - if action.action.get_name() == "CutTwoQubitGate": - gate_ids.append(action.gate_spec.instruction_id) - else: - # The cut-finding optimizer currently only supports 4 cutting - # actions: {CutTwoQubitGate + these 3 wire cut types} - assert action.action.get_name() in ( - "CutLeftWire", - "CutRightWire", - "CutBothWires", - ) - wire_cut_actions.append(action) - - # First, replace all gates to cut with BaseQPDGate instances. - # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. - # This may not hold in the future as we stop treating gate cuts individually. - circ_out = cut_gates(circuit, gate_ids)[0] - - # Insert all the wire cuts - counter = 0 - for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): - inst_id = action.gate_spec.instruction_id - # action.args[0][0] will be either 1 (control) or 2 (target) - qubit_id = action.args[0][0] - 1 - circ_out.data.insert( - inst_id + counter, - CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), - ) - counter += 1 - if action.action.get_name() == "CutBothWires": - # There should be two wires specified in the action in this case - assert len(action.args) == 2 - qubit_id2 = action.args[1][0] - 1 - circ_out.data.insert( - inst_id + counter, - CircuitInstruction( - CutWire(), [circuit.data[inst_id].qubits[qubit_id2]], [] - ), - ) - counter += 1 - - # Return metadata describing the cut scheme - metadata: dict[str, Any] = {"cuts": []} - for i, inst in enumerate(circ_out.data): - if inst.operation.name == "qpd_2q": - metadata["cuts"].append(("Gate Cut", i)) - elif inst.operation.name == "cut_wire": - metadata["cuts"].append(("Wire Cut", i)) - metadata["sampling_overhead"] = opt_out.upper_bound_gamma() ** 2 - - return circ_out, metadata diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py new file mode 100644 index 000000000..21c1b8f93 --- /dev/null +++ b/circuit_knitting/cutting/find_cuts.py @@ -0,0 +1,142 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Function for automatically finding locations for gate and wire cuts.""" + +from __future__ import annotations + +from typing import cast, Any + +from qiskit.circuit import QuantumCircuit, CircuitInstruction + +from .instructions import CutWire +from .cutting_decomposition import cut_gates +from .cut_finding.optimization_settings import ( + OptimizationSettings, + OptimizationParameters, +) +from .cut_finding.quantum_device_constraints import DeviceConstraints +from .cut_finding.disjoint_subcircuits_state import DisjointSubcircuitsState +from .cut_finding.circuit_interface import SimpleGateList +from .cut_finding.lo_cuts_optimizer import LOCutsOptimizer +from .cut_finding.cco_utils import qc_to_cco_circuit + + +def find_cuts( + circuit: QuantumCircuit, + optimization: OptimizationParameters, + constraints: DeviceConstraints, +) -> tuple[QuantumCircuit, dict[str, float]]: + """Find cut locations in a circuit, given optimization settings and QPU constraints. + + Args: + circuit: The circuit to cut. The circuit must contain only single two-qubit + gates. + optimization: Options for controlling optimizer behavior. Currently, the optimal + cuts are arrived at using Dijkstra's best-first search algorithm. The specified + parameters are: + + - max_gamma: Specifies a constraint on the maximum value of gamma that a + solution to the optimization is allowed to have to be considered + feasible. Note that the sampling overhead is ``gamma ** 2``. + - max_backjumps: Specifies a constraint on the maximum number of backjump + operations that can be performed by the search algorithm. + - seed: A seed for the pseudorandom number generator used by the optimizer. + + constraints: Options for specifying the constraints for circuit cutting: + - qubits_per_subcircuit: The maximum number of qubits per subcircuit. + Returns: + A circuit containing :class:`.BaseQPDGate` instances. The subcircuits + resulting from cutting these gates will be runnable on the devices + specified in ``constraints``. + + A metadata dictionary: + - cuts: A list of length-2 tuples describing each cut in the output circuit. + The tuples are formatted as ``(cut_type: str, cut_id: int)``. The + cut ID is the index of the cut gate or wire in the output circuit's + ``data`` field. + - sampling_overhead: The sampling overhead incurred from cutting the specified + gates and wires. + + Raises: + ValueError: The input circuit contains a gate acting on more than 2 qubits. + """ + circuit_cco = qc_to_cco_circuit(circuit) + interface = SimpleGateList(circuit_cco) + + opt_settings = OptimizationSettings( + seed=optimization.seed, + max_gamma=optimization.max_gamma, + max_backjumps=optimization.max_backjumps, + ) + + # Hard-code the optimizer to an LO-only optimizer + optimizer = LOCutsOptimizer(interface, opt_settings, constraints) + + # Find cut locations + opt_out = optimizer.optimize() + + wire_cut_actions = [] + gate_ids = [] + + opt_out = cast(DisjointSubcircuitsState, opt_out) + opt_out.actions = cast(list, opt_out.actions) + for action in opt_out.actions: + if action.action.get_name() == "CutTwoQubitGate": + gate_ids.append(action.gate_spec.instruction_id) + else: + # The cut-finding optimizer currently only supports 4 cutting + # actions: {CutTwoQubitGate + these 3 wire cut types} + assert action.action.get_name() in ( + "CutLeftWire", + "CutRightWire", + "CutBothWires", + ) + wire_cut_actions.append(action) + + # First, replace all gates to cut with BaseQPDGate instances. + # This assumes each gate to cut is replaced 1-to-1 with a QPD gate. + # This may not hold in the future as we stop treating gate cuts individually. + circ_out = cut_gates(circuit, gate_ids)[0] + + # Insert all the wire cuts + counter = 0 + for action in sorted(wire_cut_actions, key=lambda a: a[1][0]): + inst_id = action.gate_spec.instruction_id + # action.args[0][0] will be either 1 (control) or 2 (target) + qubit_id = action.args[0][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), + ) + counter += 1 + if action.action.get_name() == "CutBothWires": + # There should be two wires specified in the action in this case + assert len(action.args) == 2 + qubit_id2 = action.args[1][0] - 1 + circ_out.data.insert( + inst_id + counter, + CircuitInstruction( + CutWire(), [circuit.data[inst_id].qubits[qubit_id2]], [] + ), + ) + counter += 1 + + # Return metadata describing the cut scheme + metadata: dict[str, Any] = {"cuts": []} + for i, inst in enumerate(circ_out.data): + if inst.operation.name == "qpd_2q": + metadata["cuts"].append(("Gate Cut", i)) + elif inst.operation.name == "cut_wire": + metadata["cuts"].append(("Wire Cut", i)) + metadata["sampling_overhead"] = opt_out.upper_bound_gamma() ** 2 + + return circ_out, metadata diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index 8b03b1e79..2595f1cca 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -9,7 +9,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Tests for cutting_decomposition package.""" +"""Tests for cutting_decomposition module.""" import unittest @@ -19,16 +19,12 @@ from qiskit.circuit import CircuitInstruction, Barrier, Clbit from qiskit.circuit.library import EfficientSU2, RXXGate from qiskit.circuit.library.standard_gates import CXGate -from qiskit.circuit.random import random_circuit from qiskit.quantum_info import PauliList from circuit_knitting.cutting import ( partition_circuit_qubits, partition_problem, cut_gates, - find_cuts, - OptimizationParameters, - DeviceConstraints, ) from circuit_knitting.cutting.instructions import Move from circuit_knitting.cutting.qpd import ( @@ -261,32 +257,6 @@ def test_partition_problem(self): assert subcircuit[0].num_qubits == 3 assert subcircuit[1].num_qubits == 1 - def test_find_cuts(self): - with self.subTest("simple circuit"): - circuit = random_circuit(7, 6, max_operands=2, seed=1242) - optimization = OptimizationParameters(seed=111) - constraints = DeviceConstraints(qubits_per_subcircuit=4) - - _, metadata = find_cuts( - circuit, optimization=optimization, constraints=constraints - ) - cut_types = {cut[0] for cut in metadata["cuts"]} - - assert len(metadata["cuts"]) == 2 - assert {"Wire Cut", "Gate Cut"} == cut_types - assert np.isclose(127.06026169, metadata["sampling_overhead"], atol=1e-8) - - with self.subTest("3-qubit gate"): - circuit = random_circuit(3, 2, max_operands=3, seed=99) - with pytest.raises(ValueError) as e_info: - _, metadata = find_cuts( - circuit, optimization=optimization, constraints=constraints - ) - assert e_info.value.args[0] == ( - "The input circuit must contain only single and two-qubits gates. " - "Found 3-qubit gate: (cswap)." - ) - def test_cut_gates(self): with self.subTest("simple circuit"): compare_qc = QuantumCircuit(2) diff --git a/test/cutting/test_find_cuts.py b/test/cutting/test_find_cuts.py new file mode 100644 index 000000000..b78d93ac8 --- /dev/null +++ b/test/cutting/test_find_cuts.py @@ -0,0 +1,52 @@ +# This code is a Qiskit project. + +# (C) Copyright IBM 2024. + +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for find_cuts module.""" + +import unittest + +import pytest +import numpy as np +from qiskit.circuit.random import random_circuit + +from circuit_knitting.cutting import ( + find_cuts, + OptimizationParameters, + DeviceConstraints, +) + + +class TestCuttingDecomposition(unittest.TestCase): + def test_find_cuts(self): + with self.subTest("simple circuit"): + circuit = random_circuit(7, 6, max_operands=2, seed=1242) + optimization = OptimizationParameters(seed=111) + constraints = DeviceConstraints(qubits_per_subcircuit=4) + + _, metadata = find_cuts( + circuit, optimization=optimization, constraints=constraints + ) + cut_types = {cut[0] for cut in metadata["cuts"]} + + assert len(metadata["cuts"]) == 2 + assert {"Wire Cut", "Gate Cut"} == cut_types + assert np.isclose(127.06026169, metadata["sampling_overhead"], atol=1e-8) + + with self.subTest("3-qubit gate"): + circuit = random_circuit(3, 2, max_operands=3, seed=99) + with pytest.raises(ValueError) as e_info: + _, metadata = find_cuts( + circuit, optimization=optimization, constraints=constraints + ) + assert e_info.value.args[0] == ( + "The input circuit must contain only single and two-qubits gates. " + "Found 3-qubit gate: (cswap)." + ) From 0cdf7dfae8b8d0e5b74874ce248a73c13ba7d121 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 18:52:40 -0500 Subject: [PATCH 117/128] Ignore CutBothWires for coverage --- circuit_knitting/cutting/find_cuts.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index 21c1b8f93..a87507464 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -118,6 +118,7 @@ def find_cuts( CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), ) counter += 1 + # pragma: no cover if action.action.get_name() == "CutBothWires": # There should be two wires specified in the action in this case assert len(action.args) == 2 @@ -129,6 +130,7 @@ def find_cuts( ), ) counter += 1 + # pragma: no cover end # Return metadata describing the cut scheme metadata: dict[str, Any] = {"cuts": []} From 2d9f884f9bb915cd8488cb6c08b1ff36f3908071 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 19:09:08 -0500 Subject: [PATCH 118/128] Fix coverage --- circuit_knitting/cutting/find_cuts.py | 5 ++--- test/cutting/cut_finding/__init__.py | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index a87507464..f64784029 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -118,8 +118,8 @@ def find_cuts( CircuitInstruction(CutWire(), [circuit.data[inst_id].qubits[qubit_id]], []), ) counter += 1 - # pragma: no cover - if action.action.get_name() == "CutBothWires": + + if action.action.get_name() == "CutBothWires": # pragma: no cover # There should be two wires specified in the action in this case assert len(action.args) == 2 qubit_id2 = action.args[1][0] - 1 @@ -130,7 +130,6 @@ def find_cuts( ), ) counter += 1 - # pragma: no cover end # Return metadata describing the cut scheme metadata: dict[str, Any] = {"cuts": []} diff --git a/test/cutting/cut_finding/__init__.py b/test/cutting/cut_finding/__init__.py index 71d83fd8a..75efffef4 100644 --- a/test/cutting/cut_finding/__init__.py +++ b/test/cutting/cut_finding/__init__.py @@ -1,6 +1,6 @@ # This code is a Qiskit project. -# (C) Copyright IBM 2022. +# (C) Copyright IBM 2024. # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory From 363d9015ed211f82e1c3a6edff280cf507ccb8a5 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 19:12:08 -0500 Subject: [PATCH 119/128] black --- circuit_knitting/cutting/find_cuts.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index f64784029..c6473639f 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -119,7 +119,7 @@ def find_cuts( ) counter += 1 - if action.action.get_name() == "CutBothWires": # pragma: no cover + if action.action.get_name() == "CutBothWires": # pragma: no cover # There should be two wires specified in the action in this case assert len(action.args) == 2 qubit_id2 = action.args[1][0] - 1 From 4f563d19c1278bd125823230d33d3cc3ec0bb4a8 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 19:23:14 -0500 Subject: [PATCH 120/128] Clean up docstring --- circuit_knitting/cutting/find_cuts.py | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index c6473639f..8a073f657 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -35,24 +35,14 @@ def find_cuts( optimization: OptimizationParameters, constraints: DeviceConstraints, ) -> tuple[QuantumCircuit, dict[str, float]]: - """Find cut locations in a circuit, given optimization settings and QPU constraints. + """Find cut locations in a circuit, given optimization settings and cutting constraints. Args: circuit: The circuit to cut. The circuit must contain only single two-qubit gates. optimization: Options for controlling optimizer behavior. Currently, the optimal - cuts are arrived at using Dijkstra's best-first search algorithm. The specified - parameters are: - - - max_gamma: Specifies a constraint on the maximum value of gamma that a - solution to the optimization is allowed to have to be considered - feasible. Note that the sampling overhead is ``gamma ** 2``. - - max_backjumps: Specifies a constraint on the maximum number of backjump - operations that can be performed by the search algorithm. - - seed: A seed for the pseudorandom number generator used by the optimizer. - - constraints: Options for specifying the constraints for circuit cutting: - - qubits_per_subcircuit: The maximum number of qubits per subcircuit. + cuts are arrived at using Dijkstra's best-first search algorithm. + constraints: Constraints on how to cut the circuit Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits resulting from cutting these gates will be runnable on the devices From a0a5b8e3b8950cf15471dc125b4736c1c2c6c335 Mon Sep 17 00:00:00 2001 From: Caleb Johnson Date: Mon, 25 Mar 2024 19:30:51 -0500 Subject: [PATCH 121/128] Improve docstring --- circuit_knitting/cutting/find_cuts.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index 8a073f657..80b8fcbec 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -38,15 +38,15 @@ def find_cuts( """Find cut locations in a circuit, given optimization settings and cutting constraints. Args: - circuit: The circuit to cut. The circuit must contain only single two-qubit - gates. + circuit: The circuit to cut. The input circuit may not contain gates acting + on more than two qubits. optimization: Options for controlling optimizer behavior. Currently, the optimal - cuts are arrived at using Dijkstra's best-first search algorithm. - constraints: Constraints on how to cut the circuit + cuts are chosen using Dijkstra's best-first search algorithm. + constraints: Constraints on how the circuit may be partitioned Returns: A circuit containing :class:`.BaseQPDGate` instances. The subcircuits - resulting from cutting these gates will be runnable on the devices - specified in ``constraints``. + resulting from cutting these gates will be runnable on the devices meeting + the ``constraints``. A metadata dictionary: - cuts: A list of length-2 tuples describing each cut in the output circuit. From 62ad8323f6a77e4bc0ae6d05a1cf2eb5687351db Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 26 Mar 2024 05:47:41 -0400 Subject: [PATCH 122/128] Upeate release notes --- .../cut_finding/disjoint_subcircuits_state.py | 3 +-- .../tutorials/LO_circuit_cut_finder.ipynb | 24 +++++++++---------- ...utomatic-cut-finding-696556915e347138.yaml | 5 +++- 3 files changed, 17 insertions(+), 15 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 6a2b28b30..8dd059af7 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -451,8 +451,7 @@ def set_next_level(self, state: DisjointSubcircuitsState) -> None: def export_cuts(self, circuit_interface: SimpleGateList): """Export LO cuts into the input circuit_interface for each of the cutting decisions made.""" - # This wire map assumes no reuse of measured qubits that - # result from wire cuts + # This wire map assumes no reuse of qubits assert self.num_wires is not None wire_map = np.arange(self.num_wires) diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb index 426a3c14d..91c4a3411 100644 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -85,17 +85,17 @@ "\n", "\n", "\n", - "---------- 4 Qubits per subcircuit ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", + "---------- 3 Qubits per subcircuit ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", + "Subcircuits: AAAB \n", "\n", "\n", "\n", - "---------- 4 Qubits per subcircuit ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", + "---------- 2 Qubits per subcircuit ----------\n", + " Gamma = 9.0 , Min_gamma_reached = True\n", + "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", + "Subcircuits: AABB \n", "\n" ] } @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -163,7 +163,7 @@ "
" ] }, - "execution_count": 10, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [ { diff --git a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml index c59e22add..c6448c784 100644 --- a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml +++ b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml @@ -12,4 +12,7 @@ features: in an input circuit be at most a two qubit gate. The search algorithm used by the cut-finder to identify cut locations is Dijkstra's best first search algorithm which is guaranteed to find solutions with the lowest sampling overhead, provided any user-specified value for the maximum number - of allowed backjumps or for the maximum sampling overhead does not prematurely stop the search. \ No newline at end of file + of allowed backjumps or for the maximum sampling overhead does not prematurely stop the search. If + the user wishes to time-restrict the search when running the cut-finder on large circuits, they can + specify a maximum sampling overhead and/or a maximum number of allowed backjumps, in which case the + cut-finder will return a valid albeit suboptimal cut scheme. \ No newline at end of file From 3cf4c9b4c020f46eb5795ff7df23cade6f3d5a8d Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Tue, 26 Mar 2024 05:58:52 -0400 Subject: [PATCH 123/128] Remove extraneous tutorial --- .../tutorials/LO_circuit_cut_finder.ipynb | 316 ------------------ 1 file changed, 316 deletions(-) delete mode 100644 docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb diff --git a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb b/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb deleted file mode 100644 index 91c4a3411..000000000 --- a/docs/circuit_cutting/tutorials/LO_circuit_cut_finder.ipynb +++ /dev/null @@ -1,316 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from circuit_knitting.cutting.cut_finding.circuit_interface import SimpleGateList\n", - "from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import LOCutsOptimizer\n", - "from circuit_knitting.cutting.cut_finding.optimization_settings import (\n", - " OptimizationSettings,\n", - ")\n", - "from circuit_knitting.cutting.cut_finding.quantum_device_constraints import (\n", - " DeviceConstraints,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cut finding for efficient SU(2) Circuit with linear entanglement" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize the circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import EfficientSU2\n", - "from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit\n", - "\n", - "qc = EfficientSU2(4, entanglement=\"linear\", reps=2).decompose()\n", - "qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)\n", - "\n", - "circuit_ckt = qc_to_cco_circuit(qc)\n", - "\n", - "qc.draw(\"mpl\", scale=0.8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Perform cut finding" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 4 Qubits per subcircuit ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAA \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per subcircuit ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=17, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=25, gate_name='cx', qubits=[2, 3]))]\n", - "Subcircuits: AAAB \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per subcircuit ----------\n", - " Gamma = 9.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[1, 2])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=20, gate_name='cx', qubits=[1, 2]))]\n", - "Subcircuits: AABB \n", - "\n" - ] - } - ], - "source": [ - "settings = OptimizationSettings(seed=12345)\n", - "\n", - "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", - "\n", - "\n", - "qubits_per_subcircuit = 4\n", - "\n", - "\n", - "for qubits_per_subcircuit in range(qubits_per_subcircuit, 1, -1):\n", - " print(f\"\\n\\n---------- {qubits_per_subcircuit} Qubits per subcircuit ----------\")\n", - "\n", - " constraint_obj = DeviceConstraints(qubits_per_subcircuit=qubits_per_subcircuit)\n", - " interface = SimpleGateList(circuit_ckt)\n", - "\n", - " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", - "\n", - " out = op.optimize()\n", - "\n", - " print(\n", - " \" Gamma =\",\n", - " None if (out is None) else out.upper_bound_gamma(),\n", - " \", Min_gamma_reached =\",\n", - " op.minimum_reached(),\n", - " )\n", - " if out is not None:\n", - " out.print(simple=True)\n", - " else:\n", - " print(out)\n", - "\n", - " print(\n", - " \"Subcircuits:\",\n", - " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", - " \"\\n\",\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cut finding for 7 qubit circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize the circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "qc_0 = QuantumCircuit(7)\n", - "for i in range(7):\n", - " qc_0.rx(np.pi / 4, i)\n", - "qc_0.cx(0, 3)\n", - "qc_0.cx(1, 3)\n", - "qc_0.cx(2, 3)\n", - "qc_0.cx(3, 4)\n", - "qc_0.cx(3, 5)\n", - "qc_0.cx(3, 6)\n", - "\n", - "qc_0.draw(\"mpl\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Perform cut finding" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------- 7 Qubits per QPU ----------\n", - " Gamma = 1.0 , Min_gamma_reached = True\n", - "[]\n", - "Subcircuits: AAAAAAA \n", - "\n", - "\n", - "\n", - "---------- 6 Qubits per QPU ----------\n", - " Gamma = 3.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", - "Subcircuits: AAAAAAB \n", - "\n", - "\n", - "\n", - "---------- 5 Qubits per QPU ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", - "Subcircuits: AAAABABB \n", - "\n", - "\n", - "\n", - "---------- 4 Qubits per QPU ----------\n", - " Gamma = 4.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4], input=1))]\n", - "Subcircuits: AAAABBBB \n", - "\n", - "\n", - "\n", - "---------- 3 Qubits per QPU ----------\n", - " Gamma = 16.0 , Min_gamma_reached = True\n", - "[OneWireCutIdentifier(cut_action='CutRightWire', wire_cut_location=WireCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3], input=2)), OneWireCutIdentifier(cut_action='CutLeftWire', wire_cut_location=WireCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5], input=1))]\n", - "Subcircuits: AABABCBCC \n", - "\n", - "\n", - "\n", - "---------- 2 Qubits per QPU ----------\n", - " Gamma = 243.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", - "Subcircuits: ABCDDEF \n", - "\n", - "\n", - "\n", - "---------- 1 Qubits per QPU ----------\n", - " Gamma = 729.0 , Min_gamma_reached = True\n", - "[CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=7, gate_name='cx', qubits=[0, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=8, gate_name='cx', qubits=[1, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=9, gate_name='cx', qubits=[2, 3])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=10, gate_name='cx', qubits=[3, 4])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=11, gate_name='cx', qubits=[3, 5])), CutIdentifier(cut_action='CutTwoQubitGate', gate_cut_location=GateCutLocation(instruction_id=12, gate_name='cx', qubits=[3, 6]))]\n", - "Subcircuits: ABCDEFG \n", - "\n" - ] - } - ], - "source": [ - "circuit_ckt_wirecut = qc_to_cco_circuit(qc_0)\n", - "\n", - "settings = OptimizationSettings(seed=12345)\n", - "\n", - "settings.set_engine_selection(\"CutOptimization\", \"BestFirst\")\n", - "\n", - "qubits_per_subcircuit = 7\n", - "\n", - "\n", - "for qubits_per_subcircuit in range(qubits_per_subcircuit, 0, -1):\n", - " print(f\"\\n\\n---------- {qubits_per_subcircuit} Qubits per QPU ----------\")\n", - "\n", - " constraint_obj = DeviceConstraints(qubits_per_subcircuit=qubits_per_subcircuit)\n", - "\n", - " interface = SimpleGateList(circuit_ckt_wirecut)\n", - "\n", - " op = LOCutsOptimizer(interface, settings, constraint_obj)\n", - "\n", - " out = op.optimize()\n", - "\n", - " print(\n", - " \" Gamma =\",\n", - " None if (out is None) else out.upper_bound_gamma(),\n", - " \", Min_gamma_reached =\",\n", - " op.minimum_reached(),\n", - " )\n", - " if out is not None:\n", - " out.print(simple=True)\n", - " else:\n", - " print(out)\n", - "\n", - " print(\n", - " \"Subcircuits:\",\n", - " interface.export_subcircuits_as_string(name_mapping=\"default\"),\n", - " \"\\n\",\n", - " )" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "cco", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From f91fac09f6bceef223943d53d68e3d3f60e24b70 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 27 Mar 2024 12:57:19 -0400 Subject: [PATCH 124/128] Add test, edit docstrings. --- .../cutting/cut_finding/best_first_search.py | 2 +- .../cutting/cut_finding/circuit_interface.py | 11 +++++----- .../cutting/cut_finding/cut_optimization.py | 18 +++++++---------- .../cutting/cut_finding/cutting_actions.py | 12 +++++------ .../cut_finding/disjoint_subcircuits_state.py | 1 - .../cutting/cut_finding/lo_cuts_optimizer.py | 4 ++-- .../cut_finding/optimization_settings.py | 6 +++--- .../cut_finding/quantum_device_constraints.py | 4 ++-- .../cut_finding/search_space_generator.py | 10 +++++----- circuit_knitting/cutting/find_cuts.py | 2 +- .../tutorials/04_automatic_cut_finding.ipynb | 6 +++--- test/cutting/test_find_cuts.py | 20 +++++++++++++++++++ 12 files changed, 56 insertions(+), 40 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py index 24ed21e08..856dd093a 100644 --- a/circuit_knitting/cutting/cut_finding/best_first_search.py +++ b/circuit_knitting/cutting/cut_finding/best_first_search.py @@ -139,7 +139,7 @@ class BestFirstSearch: an upper bound to the optimal cost given a goal_state as input. The upper bound is used to prune next-states from the search in subsequent calls :meth:`BestFirstSearch.optimization_pass`. - If upperbound_cost_funcis None, the cost of the ``goal_state`` as + If ``upperbound_cost_func`` is None, the cost of the ``goal_state`` as determined by cost_func is used asan upper bound to the optimal cost. Input arguments to :meth:`BestFirstSearch.optimization_pass` are also passed to the ``upperbound_cost_func``. diff --git a/circuit_knitting/cutting/cut_finding/circuit_interface.py b/circuit_knitting/cutting/cut_finding/circuit_interface.py index 1a6cbefd2..42caf68f6 100644 --- a/circuit_knitting/cutting/cut_finding/circuit_interface.py +++ b/circuit_knitting/cutting/cut_finding/circuit_interface.py @@ -291,7 +291,7 @@ def export_cut_circuit( If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then :meth:``default_wire_name_mapping()`` defines the name mapping. + then :meth:`default_wire_name_mapping` defines the name mapping. """ wire_map = self.make_wire_mapping(name_mapping) out = copy.deepcopy(self.new_circuit) @@ -310,7 +310,7 @@ def export_output_wires( If None is provided as the name_mapping, then the original qubit names are used with additional names of form ("cut", ) introduced as needed to represent cut wires. If "default" is used as the mapping - then :meth:``SimpleGateList.default_wire_name_mapping()`` defines the name mapping. + then :meth:``SimpleGateList.default_wire_name_mapping`` defines the name mapping. """ wire_map = self.make_wire_mapping(name_mapping) out = dict() @@ -344,8 +344,9 @@ def make_wire_mapping( ) -> Sequence[int | tuple[str, int]]: """Return a wire-mapping list given an input specification of a name mapping. - If ``None ``is provided as the input name_mapping, then the original qubit names are mapped to themselves. - If "default" is used as the ``name_mapping``, then :meth:``default_wire_name_mapping`` is used to define the name mapping. + If ``None ``is provided as the input name_mapping, then the original qubit names + are mapped to themselves. If "default" is used as the ``name_mapping``, + then :meth:``default_wire_name_mapping`` is used to define the name mapping. """ if name_mapping is None: name_mapping = dict() @@ -364,7 +365,7 @@ def make_wire_mapping( return wire_mapping def default_wire_name_mapping(self) -> dict[Hashable, int]: - """Return a dictionary that maps wire names to default numeric output qubit names when exporting a cut circuit. + """Return dictionary that maps wire names to default numeric output qubit names when exporting a cut circuit. Cut wires are assigned numeric IDs that are adjacent to the numeric ID of the wire prior to cutting so that Move operators are then applied against adjacent qubits. This is ensured by :meth:`SimpleGateList.sort_order`. diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 39bf0ff0e..7493cce7b 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -46,9 +46,9 @@ def cut_optimization_cost_func( ) -> tuple[float, int]: """Return the cost function. - The particular cost function chosen here aims to minimize the classical - overhead, gamma, while also (secondarily) giving preference to circuit - partitionings that balance the sizes of the resulting partitions, by + The particular cost function chosen here aims to minimize the (square root) + of the classical overhead, :math:`gamma`, while also (secondarily) giving preference + to circuit partitionings that balance the sizes of the resulting partitions, by minimizing the maximum width across subcircuits. """ # pylint: disable=unused-argument @@ -58,7 +58,7 @@ def cut_optimization_cost_func( def cut_optimization_upper_bound_cost_func( goal_state, func_args: CutOptimizationFuncArgs ) -> tuple[float, float]: - """Return the value of gamma computed assuming all LO cuts.""" + """Return the value of :math:`gamma` computed assuming all LO cuts.""" # pylint: disable=unused-argument return (goal_state.upper_bound_gamma(), np.inf) @@ -118,8 +118,8 @@ def cut_optimization_goal_state_func( return state.get_search_level() >= len(func_args.entangling_gates) -### Global variable that holds the search-space functions for generating -### the cut optimization search space. +# Global variable that holds the search-space functions for generating +# the cut optimization search space. cut_optimization_search_funcs = SearchFunctions( cost_func=cut_optimization_cost_func, upperbound_cost_func=cut_optimization_upper_bound_cost_func, @@ -155,9 +155,6 @@ def greedy_cut_optimization( return greedy_best_first_search(start_state, search_space_funcs, func_args) -################################################################################ - - class CutOptimization: """Implement cut optimization whereby qubits are not reused. @@ -231,7 +228,6 @@ def __init__( search_space_funcs=self.search_funcs, search_actions=self.search_actions, ) - ################################################################################ # Use the upper bound for the optimal gamma to determine the maximum # number of wire cuts that can be performed. @@ -243,7 +239,7 @@ def __init__( # The elif block below covers a rare edge case # which would need a clever circuit to get tested. - # Excluding from test coverage for now. + # Excluded from test coverage for now. elif self.func_args.max_gamma is not None: # pragma: no cover mwc = max_wire_cuts_gamma(self.func_args.max_gamma) max_wire_cuts = min(max_wire_cuts, mwc) diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py index f2c8451c9..954136969 100644 --- a/circuit_knitting/cutting/cut_finding/cutting_actions.py +++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py @@ -107,7 +107,7 @@ def next_state_primitive( return [new_state] -### Add ActionApplyGate to the global variable ``disjoint_subcircuit_actions`` +# Add ActionApplyGate to the global variable ``disjoint_subcircuit_actions`` disjoint_subcircuit_actions.define_action(ActionApplyGate()) @@ -200,7 +200,7 @@ def export_cuts( circuit_interface.insert_gate_cut(gate_spec.instruction_id, "LO") -### Add ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions +# Add ActionCutTwoQubitGate to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutTwoQubitGate()) @@ -230,7 +230,7 @@ def next_state_primitive( "In the current version, only the cutting of two qubit gates is supported." ) - # If the wire-cut limit would be exceeded, return the empty list + # If the wire-cut limit would be exceeded, return the empty list. if not state.can_add_wires(1): return list() @@ -272,7 +272,7 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Add ActionCutLeftWire to the global variable disjoint_subcircuit_actions +# Add ActionCutLeftWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutLeftWire()) @@ -358,7 +358,7 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Add ActionCutRightWire to the global variable disjoint_subcircuit_actions +# Add ActionCutRightWire to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutRightWire()) @@ -432,5 +432,5 @@ def export_cuts( insert_all_lo_wire_cuts(circuit_interface, wire_map, gate_spec, cut_args) -### Add ActionCutBothWires to the global variable disjoint_subcircuit_actions +# Add ActionCutBothWires to the global variable disjoint_subcircuit_actions disjoint_subcircuit_actions.define_action(ActionCutBothWires()) diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py index 8dd059af7..39e319cc0 100644 --- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py +++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py @@ -67,7 +67,6 @@ class CutIdentifier(NamedTuple): gate_cut_location: GateCutLocation -# Used for identifying CutLeftWire and CutRightWire actions. class OneWireCutIdentifier(NamedTuple): """Named tuple for specification of location of :class:`CutLeftWire` or :class:`CutRightWire` instances.""" diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py index 5fa6bc988..6b403b203 100644 --- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py +++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py @@ -28,7 +28,7 @@ from .circuit_interface import SimpleGateList -### Functions for generating the cut optimization search space +# Functions for generating the cut optimization search space cut_optimization_search_funcs = SearchFunctions( cost_func=cut_optimization_upper_bound_cost_func, # Valid choice only for LO cuts. upperbound_cost_func=cut_optimization_upper_bound_cost_func, @@ -42,7 +42,7 @@ class LOCutsOptimizer: """Optimize circuit cuts for the case in which only LO decompositions are employed. The ``search_engine_config`` dictionary that configures the optimization - algorithms must be specified in the constructor. For flexibility, the + algorithms must be specified in the constructor. For flexibility, the circuit_interface, optimization_settings, and device_constraints can be specified either in the constructor or in :meth:`LOCutsOptimizer.optimize`. In the latter case, the values provided overwrite the previous values. diff --git a/circuit_knitting/cutting/cut_finding/optimization_settings.py b/circuit_knitting/cutting/cut_finding/optimization_settings.py index dd5a245f0..d8ca5fef7 100644 --- a/circuit_knitting/cutting/cut_finding/optimization_settings.py +++ b/circuit_knitting/cutting/cut_finding/optimization_settings.py @@ -24,8 +24,8 @@ class OptimizationSettings: ``max_gamma`` specifies a constraint on the maximum value of gamma that a solution is allowed to have to be considered feasible. If a solution exists but the associated gamma exceeds ``max_gamma``, :func:`.greedy_best_first_search`, - which is used to warm start, the search engine will still attempt to return a - solution. + which is used to warm start the search engine will still return a valid albeit + typically suboptimal solution. ``engine_selections`` is a dictionary that defines the selection of search engines for the optimization. @@ -135,7 +135,7 @@ def get_cut_search_groups(self) -> list[None | str]: @dataclass class OptimizationParameters: - """Specify a subset of parameters that control the optimization. + """Specify parameters that control the optimization. The other attributes of :class:`OptimizationSettings` are taken to be private. diff --git a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py index 20b08485e..e2ee677f7 100644 --- a/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py +++ b/circuit_knitting/cutting/cut_finding/quantum_device_constraints.py @@ -18,7 +18,7 @@ @dataclass class DeviceConstraints: - """Specify the constraints (qubits per QPU) that must be respected.""" + """Specify the constraints (qubits per subcircuit) that must be respected.""" qubits_per_subcircuit: int @@ -30,5 +30,5 @@ def __post_init__(self): ) def get_qpu_width(self) -> int: - """Return the number of qubits supported on each individual QPU.""" + """Return the number of qubits per subcircuit.""" return self.qubits_per_subcircuit diff --git a/circuit_knitting/cutting/cut_finding/search_space_generator.py b/circuit_knitting/cutting/cut_finding/search_space_generator.py index 5f4bd0a52..ad5056a78 100644 --- a/circuit_knitting/cutting/cut_finding/search_space_generator.py +++ b/circuit_knitting/cutting/cut_finding/search_space_generator.py @@ -46,7 +46,7 @@ def __init__(self): def copy( self, list_of_groups: list[DisjointSearchAction | None] | None = None ) -> ActionNames: - """Return a copy of :class:`ActionNames` containing only those actions whose group affiliations intersect with ``list_of_groups``. + """Return copy of :class:`ActionNames` with actions whose group affiliations intersect with ``list_of_groups``. The default is to return a copy containing all actions. """ @@ -59,7 +59,7 @@ def copy( return new_container def define_action(self, action_object: DisjointSearchAction) -> None: - """Insert the specified ``action_object`` into the look-up dictionaries using the name of the action and its group names.""" + """Insert specified ``action_object`` into look-up dictionaries using associated name of action and group names.""" assert ( action_object.get_name() not in self.action_dict ), f"Action {action_object.get_name()} is already defined" @@ -121,8 +121,8 @@ class SearchFunctions: """Contain functions needed to generate and explore a search space. In addition to the required input arguments, the function - signatures are assumed to also allow additional input arguments that are - needed to perform the corresponding computations. + signatures are assumed to also allow additional input arguments + that are needed to perform the corresponding computations. Member Variables: @@ -132,7 +132,7 @@ class SearchFunctions: per Python semantics. ``next_state_func``: a function that returns a list - of next states generated from the input state. An :class:`ActionNames` + of next states generated from the input state. A :class:`ActionNames` instance should be incorporated into the additional input arguments in order to generate next-states. diff --git a/circuit_knitting/cutting/find_cuts.py b/circuit_knitting/cutting/find_cuts.py index 80b8fcbec..ac99715ab 100644 --- a/circuit_knitting/cutting/find_cuts.py +++ b/circuit_knitting/cutting/find_cuts.py @@ -35,7 +35,7 @@ def find_cuts( optimization: OptimizationParameters, constraints: DeviceConstraints, ) -> tuple[QuantumCircuit, dict[str, float]]: - """Find cut locations in a circuit, given optimization settings and cutting constraints. + """Find cut locations in a circuit, given optimization parameters and cutting constraints. Args: circuit: The circuit to cut. The input circuit may not contain gates acting diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 10cb1a6a1..551c158f2 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -58,8 +58,8 @@ "output_type": "stream", "text": [ "Found solution using 2 cuts with a sampling overhead of 127.06026169907257.\n", - "Wire Cut at index 19\n", - "Gate Cut at index 28\n" + "Wire Cut at circuit instruction index 19\n", + "Gate Cut at circuit instruction index 28\n" ] }, { @@ -93,7 +93,7 @@ " f'overhead of {metadata[\"sampling_overhead\"]}.'\n", ")\n", "for cut in metadata[\"cuts\"]:\n", - " print(f\"{cut[0]} at index {cut[1]}\")\n", + " print(f\"{cut[0]} at circuit instruction index {cut[1]}\")\n", "cut_circuit.draw(\"mpl\", scale=0.8, fold=-1)" ] }, diff --git a/test/cutting/test_find_cuts.py b/test/cutting/test_find_cuts.py index b78d93ac8..dfacd424b 100644 --- a/test/cutting/test_find_cuts.py +++ b/test/cutting/test_find_cuts.py @@ -15,6 +15,7 @@ import pytest import numpy as np +from qiskit import QuantumCircuit from qiskit.circuit.random import random_circuit from circuit_knitting.cutting import ( @@ -50,3 +51,22 @@ def test_find_cuts(self): "The input circuit must contain only single and two-qubits gates. " "Found 3-qubit gate: (cswap)." ) + with self.subTest( + "right-wire-cut" + ): # tests resolution of https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/issues/508 + + circuit = QuantumCircuit(5) + circuit.cx(0, 3) + circuit.cx(1, 3) + circuit.cx(2, 3) + circuit.h(4) + circuit.cx(3, 4) + constraints = DeviceConstraints(qubits_per_subcircuit=3) + _, metadata = find_cuts( + circuit, optimization=optimization, constraints=constraints + ) + cut_types = {cut[0] for cut in metadata["cuts"]} + + assert len(metadata["cuts"]) == 1 + assert {"Wire Cut"} == cut_types + assert metadata["sampling_overhead"] == 16 From 4b7353594a346d4458689fb9c5a27a96b058c804 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 27 Mar 2024 14:13:11 -0400 Subject: [PATCH 125/128] Fix docstring typo --- circuit_knitting/cutting/cut_finding/cco_utils.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index bf130c7c9..dd11c0a9b 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -30,9 +30,9 @@ def qc_to_cco_circuit(circuit: QuantumCircuit) -> list[str | CircuitElement]: """Convert a :class:`qiskit.QuantumCircuit` instance into a circuit list that is compatible with the :class:`SimpleGateList`. - To conform with the uniformity of the design, single and multiqubit (that is, gates acting on more than two - qubits) are assigned :math:`gamma=None`. In the converted list, a barrier across the entire circuit is - represented by the string "barrier." Everything else is represented by an instance of :class:`CircuitElement`. + To conform with the uniformity of the design, single qubit gates are assigned :math:`gamma=None`. + In the converted list, a barrier across the entire circuit is represented by the string "barrier." + Everything else is represented by an instance of :class:`CircuitElement`. Args: circuit: an instance of :class:`qiskit.QuantumCircuit` . From e1d666072fc0d5371b624dd98c60342fdc525bb8 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Wed, 27 Mar 2024 14:14:07 -0400 Subject: [PATCH 126/128] Docstring --- circuit_knitting/cutting/cutting_decomposition.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 8a7881589..2d6b612bd 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -13,9 +13,10 @@ from __future__ import annotations -from typing import NamedTuple + from collections import defaultdict from collections.abc import Sequence, Hashable +from typing import NamedTuple from qiskit.circuit import ( QuantumCircuit, From f64ca8a37aae7f645f2af31031b0b611e1921f3a Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Thu, 28 Mar 2024 13:57:50 -0400 Subject: [PATCH 127/128] Import test circuit from qasm, edit docstrings and release notes. --- .../cutting/cut_finding/cco_utils.py | 13 ++++---- .../cutting/cut_finding/cut_optimization.py | 8 ++++- .../tutorials/04_automatic_cut_finding.ipynb | 2 ++ ...utomatic-cut-finding-696556915e347138.yaml | 2 +- test/cutting/test_find_cuts.py | 14 ++++++-- .../qasm_circuits/circuit_find_cuts_test.qasm | 33 +++++++++++++++++++ 6 files changed, 60 insertions(+), 12 deletions(-) create mode 100644 test/qasm_circuits/circuit_find_cuts_test.qasm diff --git a/circuit_knitting/cutting/cut_finding/cco_utils.py b/circuit_knitting/cutting/cut_finding/cco_utils.py index dd11c0a9b..a1defea6e 100644 --- a/circuit_knitting/cutting/cut_finding/cco_utils.py +++ b/circuit_knitting/cutting/cut_finding/cco_utils.py @@ -151,11 +151,10 @@ def greedy_best_first_search( default=(None, None, None), ) - if best[-1] is not None: - return greedy_best_first_search(best[-1], search_space_funcs, *args) - - # The else block below covers a rare edge case - # which needs a clever circuit to get tested. - # Excluding from test coverage for now. - else: # pragma: no cover + if best[-1] is None: # pragma: no cover + # This covers a rare edge case. + # We have so far found no circuit that triggers it. + # Excluding from test coverage for now. return None + + return greedy_best_first_search(best[-1], search_space_funcs, *args) diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py index 7493cce7b..f4593765c 100644 --- a/circuit_knitting/cutting/cut_finding/cut_optimization.py +++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py @@ -282,7 +282,13 @@ def optimization_pass(self) -> tuple[DisjointSubcircuitsState, float]: return state, cost def minimum_reached(self) -> bool: - """Return True if the optimization reached a global minimum.""" + """Return True if the optimization reached a global minimum. + + Note that this bool being False could mean that the lowest + possible value for :math:`gamma` was actually returned but + that it was just was not proven to be the lowest attainable + value. + """ return self.search_engine.minimum_reached() def get_stats(self, penultimate: bool = False) -> NDArray[np.int_]: diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb index 551c158f2..c2c6b420b 100644 --- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb +++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb @@ -38,6 +38,8 @@ "\n", "circuit = random_circuit(7, 6, max_operands=2, seed=1242)\n", "observables = PauliList([\"ZIIIIII\", \"IIIZIII\", \"IIIIIIZ\"])\n", + "\n", + "\n", "circuit.draw(\"mpl\", scale=0.8)" ] }, diff --git a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml index c6448c784..4c2d9e24d 100644 --- a/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml +++ b/releasenotes/notes/automatic-cut-finding-696556915e347138.yaml @@ -3,7 +3,7 @@ features: - | Added a cut-finder function, :func:`circuit_knitting.cutting.find_cuts`, for automatically identifying locations to place LO gate and wire cuts such that the circuit is - separable and runnable, given the maximum number of qubits per subcircuit. + separable and runnable, given the maximum number of qubits per subcircuit as a parameter. The cut-finder will search for cut schemes which minimize the sampling overhead. Note, however, that for larger circuits, the number of cuts needed to separate the circuit will naturally grow larger, leading to an exponentially increasing sampling overhead. diff --git a/test/cutting/test_find_cuts.py b/test/cutting/test_find_cuts.py index dfacd424b..fbd10185a 100644 --- a/test/cutting/test_find_cuts.py +++ b/test/cutting/test_find_cuts.py @@ -14,9 +14,9 @@ import unittest import pytest +import os import numpy as np from qiskit import QuantumCircuit -from qiskit.circuit.random import random_circuit from circuit_knitting.cutting import ( find_cuts, @@ -28,7 +28,12 @@ class TestCuttingDecomposition(unittest.TestCase): def test_find_cuts(self): with self.subTest("simple circuit"): - circuit = random_circuit(7, 6, max_operands=2, seed=1242) + path_to_circuit = os.path.join( + os.path.dirname(__file__), + "..", + "qasm_circuits/circuit_find_cuts_test.qasm", + ) + circuit = QuantumCircuit.from_qasm_file(path_to_circuit) optimization = OptimizationParameters(seed=111) constraints = DeviceConstraints(qubits_per_subcircuit=4) @@ -42,7 +47,10 @@ def test_find_cuts(self): assert np.isclose(127.06026169, metadata["sampling_overhead"], atol=1e-8) with self.subTest("3-qubit gate"): - circuit = random_circuit(3, 2, max_operands=3, seed=99) + circuit = QuantumCircuit(3) + circuit.cswap(2, 1, 0) + circuit.crx(3.57, 1, 0) + circuit.z(2) with pytest.raises(ValueError) as e_info: _, metadata = find_cuts( circuit, optimization=optimization, constraints=constraints diff --git a/test/qasm_circuits/circuit_find_cuts_test.qasm b/test/qasm_circuits/circuit_find_cuts_test.qasm new file mode 100644 index 000000000..abb068cf7 --- /dev/null +++ b/test/qasm_circuits/circuit_find_cuts_test.qasm @@ -0,0 +1,33 @@ +OPENQASM 2.0; +include "qelib1.inc"; +gate cs q0,q1 { p(pi/4) q0; cx q0,q1; p(-pi/4) q1; cx q0,q1; p(pi/4) q1; } +gate xx_plus_yy(param0,param1) q0,q1 { rz(param1) q0; rz(-pi/2) q1; sx q1; rz(pi/2) q1; s q0; cx q1,q0; ry(-0.5*param0) q1; ry(-0.5*param0) q0; cx q1,q0; sdg q0; rz(-pi/2) q1; sxdg q1; rz(pi/2) q1; rz(-1.0*param1) q0; } +qreg q[7]; +cx q[5],q[1]; +s q[2]; +cry(0.994790505908928) q[3],q[0]; +s q[6]; +tdg q[4]; +rx(4.10500232906996) q[1]; +cs q[6],q[0]; +tdg q[5]; +crz(5.2153760273282765) q[2],q[3]; +u(1.112299858268304,1.6595916488339455,0.24493830877532133) q[4]; +rxx(2.1198120285972495) q[3],q[2]; +crz(2.4061417016452324) q[0],q[6]; +x q[4]; +rzz(1.9716621086763826) q[5],q[1]; +crz(5.2153760273282765) q[2],q[3]; +y q[4]; +crx(3.198881406558974) q[3],q[0]; +cry(3.202305038084089) q[6],q[2]; +u3(4.00909515543405,6.204927202978128,0.6874813024472429) q[2]; +cry(2.6729139484709887) q[4],q[6]; +crz(3.6178866522329547) q[3],q[0]; +y q[5]; +ry(4.442659482762476) q[1]; +y q[0]; +u1(5.440368763968557) q[2]; +sdg q[1]; +cx q[6],q[5]; +crz(2.2818175923666106) q[4],q[3]; From 68b9c1cea37e54bb9f92ae0e85f02a927a111ef9 Mon Sep 17 00:00:00 2001 From: Ibrahim Date: Fri, 29 Mar 2024 10:39:33 -0400 Subject: [PATCH 128/128] Correct path to test circuit --- circuit_knitting/cutting/cutting_decomposition.py | 1 - test/cutting/test_find_cuts.py | 3 ++- tox.ini | 1 - 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 2d6b612bd..8c6de775b 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -13,7 +13,6 @@ from __future__ import annotations - from collections import defaultdict from collections.abc import Sequence, Hashable from typing import NamedTuple diff --git a/test/cutting/test_find_cuts.py b/test/cutting/test_find_cuts.py index fbd10185a..8798f2afb 100644 --- a/test/cutting/test_find_cuts.py +++ b/test/cutting/test_find_cuts.py @@ -31,7 +31,8 @@ def test_find_cuts(self): path_to_circuit = os.path.join( os.path.dirname(__file__), "..", - "qasm_circuits/circuit_find_cuts_test.qasm", + "qasm_circuits", + "circuit_find_cuts_test.qasm", ) circuit = QuantumCircuit.from_qasm_file(path_to_circuit) optimization = OptimizationParameters(seed=111) diff --git a/tox.ini b/tox.ini index 6ff98d9db..d9c84a716 100644 --- a/tox.ini +++ b/tox.ini @@ -27,7 +27,6 @@ commands = ruff check circuit_knitting/ docs/ test/ tools/ nbqa ruff docs/ autoflake --check --quiet --recursive circuit_knitting/ docs/ test/ tools/ - black --diff circuit_knitting/ docs/ test/ tools/ black --check circuit_knitting/ docs/ test/ tools/ pydocstyle circuit_knitting/ mypy circuit_knitting/