Merge remote-tracking branch 'base/main' into add_reset

Author: peachnuts

bqskit/compiler/compile.py

@@ -1014,7 +1014,7 @@ def build_multi_qudit_retarget_workflow(
                     ),
                     RestoreModelConnevtivityPass(),
                 ],
-                AutoRebase2QuditGatePass(3, 5),
+                AutoRebase2QuditGatePass(3, 5, synthesis_epsilon),
             ),
             ScanningGateRemovalPass(
                 success_threshold=synthesis_epsilon,

bqskit/ext/qiskit/translate.py

@@ -5,13 +5,14 @@
 if TYPE_CHECKING:
     from qiskit import QuantumCircuit
 
+from qiskit import qasm2
 from bqskit.ir.circuit import Circuit
 from bqskit.ir.lang.qasm2 import OPENQASM2Language
 
 
 def qiskit_to_bqskit(qc: QuantumCircuit) -> Circuit:
     """Convert Qiskit's QuantumCircuit `qc` to a BQSKit Circuit."""
-    circuit = OPENQASM2Language().decode(qc.qasm())
+    circuit = OPENQASM2Language().decode(qasm2.dumps(qc))
     # circuit.renumber_qudits(list(reversed(range(circuit.num_qudits))))
     return circuit
     # TODO: support gates not captured by qasm

bqskit/ir/gates/composed/controlled.py

@@ -286,6 +286,33 @@ def __init__(
             ctrl_U = np.kron(self.ctrl, U) + self.ihalf
             self._utry = UnitaryMatrix(ctrl_U, self.radixes)
 
+    @property
+    def qasm_name(self) -> str:
+        """
+        Override default `Gate.qasm_name` method.
+
+        If the core gate is a standard gate, this function will output
+        qasm in the form 'c+<gate_qasm>'. Otherwise an error will be raised.
+
+        Raises:
+            ValueError: If the core gate is non-standard in OpenQASM 2.0.
+        """
+        _core_gate = self.gate.qasm_name
+        if self.num_controls <= 2:
+            _controls = 'c' * self.num_controls
+        else:
+            _controls = f'c{self.num_controls}'
+        qasm_name = _controls + _core_gate
+        supported_gates = ('cu1', 'cu2', 'cu3', 'cswap', 'c3x', 'c4x')
+        if qasm_name not in supported_gates:
+            raise ValueError(
+                f'Controlled gate {_core_gate} with {self.num_controls} '
+                'controls is not a standard OpenQASM 2.0 identifier. '
+                'To encode this gate, try decomposing it into gates with'
+                'standard identifiers.',
+            )
+        return qasm_name
+
     def get_unitary(self, params: RealVector = []) -> UnitaryMatrix:
         """Return the unitary for this gate, see :class:`Unitary` for more."""
         if hasattr(self, '_utry'):

bqskit/passes/retarget/auto.py

@@ -9,6 +9,7 @@
 from bqskit.ir.opt.cost.functions import HilbertSchmidtResidualsGenerator
 from bqskit.ir.opt.cost.generator import CostFunctionGenerator
 from bqskit.passes.retarget.two import Rebase2QuditGatePass
+from bqskit.qis.unitary import UnitaryMatrix
 from bqskit.runtime import get_runtime
 from bqskit.utils.typing import is_integer
 from bqskit.utils.typing import is_real_number
@@ -112,6 +113,13 @@ async def run(self, circuit: Circuit, data: PassData) -> None:
 
         target = self.get_target(circuit, data)
 
+        if isinstance(target, UnitaryMatrix):
+            identity = UnitaryMatrix.identity(target.dim, target.radixes)
+            if target.get_distance_from(identity) < self.success_threshold:
+                _logger.debug('Target is identity, returning empty circuit.')
+                circuit.clear()
+                return
+
         for g in old_gates:
             # Track retries to check for no progress
             num_retries = 0

bqskit/passes/retarget/two.py

@@ -13,6 +13,7 @@
 from bqskit.ir.opt.cost.functions import HilbertSchmidtResidualsGenerator
 from bqskit.ir.opt.cost.generator import CostFunctionGenerator
 from bqskit.ir.point import CircuitPoint as Point
+from bqskit.qis.unitary import UnitaryMatrix
 from bqskit.runtime import get_runtime
 from bqskit.utils.typing import is_integer
 from bqskit.utils.typing import is_real_number
@@ -164,6 +165,13 @@ async def run(self, circuit: Circuit, data: PassData) -> None:
 
         target = self.get_target(circuit, data)
 
+        if isinstance(target, UnitaryMatrix):
+            identity = UnitaryMatrix.identity(target.dim, target.radixes)
+            if target.get_distance_from(identity) < self.success_threshold:
+                _logger.debug('Target is identity, returning empty circuit.')
+                circuit.clear()
+                return
+
         for g in self.gates:
             # Track retries to check for no progress
             num_retries = 0
@@ -188,6 +196,7 @@ async def run(self, circuit: Circuit, data: PassData) -> None:
                     circuit.point(g),
                     self.gates,
                 )
+
                 circuits_with_new_gate = []
                 for circ in self.circs:
                     circuit_copy = circuit.copy()

bqskit/passes/search/generators/seed.py

@@ -27,6 +27,7 @@ def __init__(
         seed: Circuit | Sequence[Circuit],
         forward_generator: LayerGenerator = SimpleLayerGenerator(),
         num_removed: int = 1,
+        hash_on_1q_gate: bool = False,
     ) -> None:
         """
         Construct a SeedLayerGenerator.
@@ -43,6 +44,13 @@ def __init__(
                 backwards traversal of the synthesis tree will be done.
                 (Default: 1)
 
+            hash_on_1q_gate (bool): If True, 1 qubit gates that appear
+                in circuit templates will be used in circuit hash
+                calculations. Otherwise only multi-qubit gates will be
+                used. Setting this value to False can help stability
+                when using more complex LayerGenerators for the
+                forward_generator. (Default: False)
+
         Raises:
             ValueError: If 'num_removed' is negative.
         """
@@ -57,6 +65,11 @@ def __init__(
                 'Expected integer for num_removed, '
                 f'got {type(num_removed)}.',
             )
+        if not isinstance(hash_on_1q_gate, bool):
+            raise TypeError(
+                'Expected bool for hash_on_1q_gate, '
+                f'got {type(hash_on_1q_gate)}.',
+            )
 
         if num_removed < 0:
             raise ValueError(
@@ -83,6 +96,7 @@ def __init__(
         self.seeds = list(cast(Sequence[Circuit], seed))
         self.forward_generator = forward_generator
         self.num_removed = num_removed
+        self.hash_on_1q_gate = hash_on_1q_gate
 
     def gen_initial_layer(
         self,
@@ -122,7 +136,7 @@ def gen_successors(self, circuit: Circuit, data: PassData) -> list[Circuit]:
 
         # If circuit is empty Circuit, successors are the seeds
         if circuit.is_empty:
-            circ_hash = self.hash_structure(circuit)
+            circ_hash = self.hash_structure(circuit, self.hash_on_1q_gate)
             # Do not return seeds if empty circuit already visited
             if circ_hash in data['seed_seen_before']:
                 return []
@@ -134,7 +148,8 @@ def gen_successors(self, circuit: Circuit, data: PassData) -> list[Circuit]:
                 if circuit.radixes == seed.radixes
             ]
             for seed in usable_seeds:
-                data['seed_seen_before'].add(self.hash_structure(seed))
+                h = self.hash_structure(seed, self.hash_on_1q_gate)
+                data['seed_seen_before'].add(h)
 
             if len(usable_seeds) == 0:
                 _logger.warning(
@@ -157,17 +172,28 @@ def gen_successors(self, circuit: Circuit, data: PassData) -> list[Circuit]:
         # Filter out successors that have already been visited
         filtered_successors = []
         for s in successors:
-            h = self.hash_structure(s)
+            h = self.hash_structure(s, self.hash_on_1q_gate)
             if h not in data['seed_seen_before']:
                 data['seed_seen_before'].add(h)
                 filtered_successors.append(s)
 
         return filtered_successors
 
     @staticmethod
-    def hash_structure(circuit: Circuit) -> int:
+    def hash_structure(circuit: Circuit, hash_on_1q_gate: bool = True) -> int:
+        """
+        Compute a hash of the Circuit's structure.
+
+        Args:
+            circuit (Circuit): Circuit to be hashed.
+
+            hash_on_1q_gate (bool): Whether or not to include 1 qubit
+                gates in the hash computation. (Default: True)
+        """
         hashes = []
         for cycle, op in circuit.operations_with_cycles():
+            if not hash_on_1q_gate and op.num_qudits <= 1:
+                continue
             hashes.append(hash((cycle, str(op))))
             if len(hashes) > 100:
                 hashes = [sum(hashes)]

bqskit/runtime/__init__.py

@@ -162,6 +162,46 @@ def cancel(self, future: RuntimeFuture) -> None:
         """
         ...
 
+    def get_cache(self) -> dict[str, Any]:
+        """
+        Retrieve worker's local cache.
+
+        In situations where a large or non-easily serializable object is
+        needed during the execution of a custom pass, `get_cache` can be used
+        to load and store data. Objects placed in cache are transient. Objects
+        can be placed in cache to reduce reloading, but should not be expected
+        to remain in cache forever.
+
+        For example, say some CustomPassA needs a SomeBigScaryObject. Within
+        its run() method, the object is constructed, then placed into cache.
+        A later pass, CustomPassB, also needs to use SomeBigScaryObject. It
+        checks that the object has been loaded by CustomPassA, then uses it.
+
+        ```
+            # Load helper method
+            def load_or_retrieve_big_scary_object(file):
+                worker_cache = get_runtime().get_cache()
+                if 'big_scary_object' not in worker_cache:
+                    # Expensive io operation...
+                    big_scary_object = load_big_scary_object(file)
+                    worker_cache['big_scary_object'] = big_scary_object
+                big_scary_object = worker_cache['big_scary_object']
+                return big_scary_object
+
+            # In CustomPassA's .run() definition...
+            # CustomPassA performs the load.
+            big_scary_object = load_or_retrieve_big_scary_object(file)
+            big_scary_object.use(...)
+
+            # In CustomPassB's .run() definition...
+            # CustomPassB saves time by retrieving big_scary_object from
+            # cache after CustomPassA has loaded it.
+            big_scary_object = load_or_retrieve_big_scary_object(file)
+            unpicklable_object.use(...)
+        ```
+        """
+        ...
+
     async def next(self, future: RuntimeFuture) -> list[tuple[int, Any]]:
         """
         Wait for and return the next batch of results from a map task.

bqskit/runtime/worker.py

@@ -205,6 +205,9 @@ def __init__(self, id: int, conn: Connection) -> None:
         self._mailbox_counter = 0
         """This count ensures every mailbox has a unique id."""
 
+        self._cache: dict[str, Any] = {}
+        """Local worker cache."""
+
         # Send out every emitted log message upstream
         old_factory = logging.getLogRecordFactory()
 
@@ -563,6 +566,20 @@ def cancel(self, future: RuntimeFuture) -> None:
         msgs = [(RuntimeMessage.CANCEL, addr) for addr in addrs]
         self._outgoing.extend(msgs)
 
+    def get_cache(self) -> dict[str, Any]:
+        """
+        Retrieve worker's local cache.
+
+        Returns:
+            (dict[str, Any]): The worker's local cache. This cache can be
+                used to store large or unserializable objects within a
+                worker process' memory. Passes on the same worker that use
+                the same object can load the object from this cache. If
+                there are multiple workers, those workers will load their
+                own copies of the object into their own cache.
+        """
+        return self._cache
+
     async def next(self, future: RuntimeFuture) -> list[tuple[int, Any]]:
         """
         Wait for and return the next batch of results from a map task.

tests/compiler/compile/test_corner_cases.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from bqskit.compiler.compile import compile
+from bqskit.compiler.compiler import Compiler
+from bqskit.ir.lang.qasm2 import OPENQASM2Language
+
+
+def test_cry_identity_corner_case(compiler: Compiler) -> None:
+    qasm = """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[5];
+        creg meas[5];
+        cry(0) q[0],q[2];
+        cry(0) q[1],q[2];
+    """
+    circuit = OPENQASM2Language().decode(qasm)
+    _ = compile(circuit, optimization_level=1, seed=10)
+    # Should finish

tests/ext/test_qiskit.py

@@ -44,21 +44,21 @@ def bqskit_circuit(self) -> Circuit:
     @pytest.fixture
     def qiskit_circuit(self) -> QuantumCircuit:
         circuit = QuantumCircuit(3)
-        circuit.cnot(0, 1)
+        circuit.cx(0, 1)
         circuit.u(1, 2, 3, 0)
         circuit.u(1, 2, 3, 1)
         circuit.u(1, 2, 3, 2)
-        circuit.cnot(0, 1)
-        circuit.cnot(0, 2)
-        circuit.cnot(0, 2)
+        circuit.cx(0, 1)
+        circuit.cx(0, 2)
+        circuit.cx(0, 2)
         circuit.u(1, 2.4, 3, 0)
         circuit.u(1, 2.2, 3, 1)
         circuit.u(1, 2.1, 3, 2)
         circuit.u(1, 2.1, 3, 2)
-        circuit.cnot(0, 2)
-        circuit.cnot(0, 2)
-        circuit.cnot(0, 1)
-        circuit.cnot(0, 2)
+        circuit.cx(0, 2)
+        circuit.cx(0, 2)
+        circuit.cx(0, 1)
+        circuit.cx(0, 2)
         circuit.u(1, 2.4, 3, 0)
         circuit.u(1, 2.2, 3, 1)
         circuit.u(1, 2.1, 3, 2)