Merge pull request #55 from BQSKit/dev

0.4.0

Author: edyounis

.github/workflows/pre-commit.yml

@@ -12,7 +12,7 @@ jobs:
     - uses: actions/checkout@v1
     - uses: actions/setup-python@v1
       with:
-        python-version: '3.9'
+        python-version: '3.10'
     - name: set PY
       run: echo "name=PY::$(python -c 'import hashlib, sys;print(hashlib.sha256(sys.version.encode()+sys.executable.encode()).hexdigest())')" >> $GITHUB_ENV
     - uses: actions/cache@v1

.github/workflows/tox.yml

@@ -9,7 +9,7 @@ jobs:
   tox:
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9']
+        python-version: ['3.7', '3.8', '3.9', '3.10']
         os: [macOS-latest, windows-latest, ubuntu-latest]
 
     runs-on: ${{ matrix.os }}

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.0.1
+    rev: v4.1.0
     hooks:
     -   id: trailing-whitespace
     -   id: end-of-file-fixer
@@ -30,36 +30,36 @@ repos:
             - --wrap-summaries=80
             - --wrap-descriptions=80
 -   repo: https://github.com/pre-commit/mirrors-autopep8
-    rev: v1.5.7
+    rev: v1.6.0
     hooks:
     -   id: autopep8
         args:
             - --in-place
             - -a
             - --max-line-length=80
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v2.29.0
+    rev: v2.31.0
     hooks:
     -   id: pyupgrade
         args:
             - --py36-plus
             - --keep-percent-format
 -   repo: https://github.com/asottile/reorder_python_imports
-    rev: v2.6.0
+    rev: v2.7.1
     hooks:
     -   id: reorder-python-imports
         args:
             - --add-import
             - from __future__ import annotations
             - --py3-plus
 -   repo: https://github.com/asottile/add-trailing-comma
-    rev: v2.1.0
+    rev: v2.2.1
     hooks:
     -   id: add-trailing-comma
         args:
             - --py36-plus
 -   repo: https://github.com/asottile/setup-cfg-fmt
-    rev: v1.18.0
+    rev: v1.20.0
     hooks:
     -   id: setup-cfg-fmt
 - repo: https://github.com/myint/autoflake
@@ -68,11 +68,11 @@ repos:
     - id: autoflake
       args:
         - --in-place
--   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.910-1
-    hooks:
-    - id: mypy
-      additional_dependencies: ["numpy>=1.20,<1.21"]
+# -   repo: https://github.com/pre-commit/mirrors-mypy
+#     rev: v0.931
+#     hooks:
+#     - id: mypy
+#       additional_dependencies: ["numpy>=1.21"]
 -   repo: https://gitlab.com/pycqa/flake8
     rev: 3.9.2
     hooks:

bqskit/compiler/compiler.py

@@ -38,6 +38,9 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
             All arguments are passed directly to Dask. You can use
             these to connect to and configure a Dask cluster.
         """
+        if 'silence_logs' not in kwargs:
+            kwargs['silence_logs'] = logging.getLogger('bqskit').level
+
         self.client = Client(*args, **kwargs)
         self.tasks: dict[uuid.UUID, Future] = {}
         _logger.info('Started compiler process.')
@@ -60,12 +63,12 @@ def close(self) -> None:
             self.client.close()
             self.tasks = {}
             _logger.info('Stopped compiler process.')
-        except AttributeError:
+        except (AttributeError, TypeError):
             pass
 
     def submit(self, task: CompilationTask) -> None:
         """Submit a CompilationTask to the Compiler."""
-        executor = Executor(task)
+        executor = self.client.scatter(Executor(task))
         future = self.client.submit(Executor.run, executor, pure=False)
         self.tasks[task.task_id] = future
         _logger.info('Submitted task: %s' % task.task_id)
@@ -76,7 +79,7 @@ def status(self, task: CompilationTask) -> str:
 
     def result(self, task: CompilationTask) -> Circuit:
         """Block until the CompilationTask is finished, return its result."""
-        circ = self.tasks[task.task_id].result()
+        circ = self.tasks[task.task_id].result()[0]
         return circ
 
     def cancel(self, task: CompilationTask) -> None:
@@ -90,3 +93,9 @@ def compile(self, task: CompilationTask) -> Circuit:
         self.submit(task)
         result = self.result(task)
         return result
+
+    def analyze(self, task: CompilationTask, key: str) -> Any:
+        """Gather the value associated with `key` in the task's data."""
+        if task.task_id not in self.tasks:
+            self.submit(task)
+        return self.tasks[task.task_id].result()[1][key]

bqskit/compiler/executor.py

@@ -31,10 +31,10 @@ def __init__(self, task: CompilationTask) -> None:
         self.data: dict[str, Any] = {'executor': self}
         self.done = False
 
-    def run(self) -> Circuit:
+    def run(self) -> tuple[Circuit, dict[str, Any]]:
         """Execute the task."""
         with threadpool_limits(limits=1):
             for pass_obj in self.passes:
                 pass_obj.run(self.circuit, self.data)
         self.done = True
-        return self.circuit
+        return self.circuit, self.data

bqskit/compiler/machine.py

@@ -94,7 +94,7 @@ def get_locations(self, block_size: int) -> list[CircuitLocation]:
             )
 
         if block_size <= 0:
-            raise ValueError('Nonpositive block_size; got {block_size}.')
+            raise ValueError(f'Nonpositive block_size; got {block_size}.')
 
         locations: set[CircuitLocation] = set()
 

bqskit/compiler/task.py

@@ -7,16 +7,17 @@
 
 from bqskit.compiler.basepass import BasePass
 from bqskit.ir.circuit import Circuit
-from bqskit.ir.gates.constant.cx import CNOTGate
+from bqskit.ir.gates import CircuitGate
+from bqskit.ir.gates import CNOTGate
+from bqskit.ir.operation import Operation
 from bqskit.passes.control import ForEachBlockPass
 from bqskit.passes.control.predicates.count import GateCountPredicate
 from bqskit.passes.control.whileloop import WhileLoopPass
 from bqskit.passes.partitioning.cluster import ClusteringPartitioner
 from bqskit.passes.partitioning.quick import QuickPartitioner
 from bqskit.passes.processing import ScanningGateRemovalPass
-from bqskit.passes.processing import WindowOptimizationPass
 from bqskit.passes.synthesis import QFASTDecompositionPass
-from bqskit.passes.synthesis.leap import OptimizedLEAPPass
+from bqskit.passes.synthesis.leap import LEAPSynthesisPass
 from bqskit.passes.util import UnfoldPass
 from bqskit.qis.unitary.unitarymatrix import UnitaryLike
 
@@ -57,15 +58,19 @@ def synthesize(utry: UnitaryLike) -> CompilationTask:
             _logger.warning('Synthesis input size is very large.')
 
         inner_seq = [
-            OptimizedLEAPPass(),
-            WindowOptimizationPass(),
+            LEAPSynthesisPass(),
             ScanningGateRemovalPass(),
         ]
 
         passes: list[BasePass] = []
         if num_qudits >= 5:
             passes.append(QFASTDecompositionPass())
-            passes.append(ForEachBlockPass(inner_seq))
+            passes.append(
+                ForEachBlockPass(
+                    inner_seq,
+                    replace_filter=less_2q_gates,
+                ),
+            )
             passes.append(UnfoldPass())
         else:
             passes.extend(inner_seq)
@@ -81,23 +86,32 @@ def optimize(circuit: Circuit) -> CompilationTask:
             return CompilationTask.synthesize(circuit.get_unitary())
 
         inner_seq = [
-            OptimizedLEAPPass(),
+            LEAPSynthesisPass(),
             ScanningGateRemovalPass(),
         ]
 
         passes: list[BasePass] = []
         passes.append(QuickPartitioner(3))
-        passes.append(ForEachBlockPass(inner_seq))
+        passes.append(ForEachBlockPass(inner_seq, replace_filter=less_2q_gates))
         passes.append(UnfoldPass())
 
         iterative_reopt = WhileLoopPass(
             GateCountPredicate(CNOTGate()),
             [
                 ClusteringPartitioner(3, 4),
-                ForEachBlockPass(inner_seq),
+                ForEachBlockPass(inner_seq, replace_filter=less_2q_gates),
                 UnfoldPass(),
             ],
         )
 
         passes.append(iterative_reopt)
         return CompilationTask(circuit, passes)
+
+
+def less_2q_gates(circuit: Circuit, op: Operation) -> bool:
+    """Replace `circuit' with `op` if has less 2 qubit gates."""
+    if not isinstance(op, CircuitGate):
+        return True
+    og_num_2q_gate = len([op for op in op._circuit if op.num_qudits >= 2])
+    new_num_2q_gate = len([op for op in circuit if op.num_qudits >= 2])
+    return new_num_2q_gate > og_num_2q_gate

bqskit/exec/__init__.py

@@ -0,0 +1,47 @@
+"""
+=============================================================
+Circuit Execution Module (:mod:`bqskit.exec`)
+=============================================================
+
+.. currentmodule:: bqskit.exec
+
+BQSKit supports a variety of ways to execute circuits through
+CircuitRunner.
+
+.. rubric:: Core Classes
+
+.. autosummary::
+    :toctree: autogen
+    :recursive:
+
+    CircuitRunner
+    RunnerResults
+
+.. rubric:: CircuitRunners
+
+.. autosummary::
+    :toctree: autogen
+    :recursive:
+
+    QuestRunner
+    IBMQRunner
+    SimulationRunner
+"""
+from __future__ import annotations
+
+__all__ = [
+    'CircuitRunner',
+    'RunnerResults',
+    'QuestRunner',
+    'SimulationRunner',
+]
+
+from bqskit.exec.results import RunnerResults
+from bqskit.exec.runner import CircuitRunner
+try:
+    from bqskit.exec.runners.ibmq import IBMQRunner
+    __all__ += ['IBMQRunner']
+except ImportError:
+    pass
+from bqskit.exec.runners.quest import QuestRunner
+from bqskit.exec.runners.sim import SimulationRunner

bqskit/exec/results.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy as np
+import numpy.typing as npt
+
+
+class RunnerResults:
+    """The result of running a Circuit through a CircuitRunner."""
+
+    def __init__(
+        self,
+        num_qudits: int,
+        radixes: Sequence[int],
+        probs: Sequence[float],
+    ) -> None:
+        """Construct a RunnerResults object."""
+        self.num_qudits = num_qudits
+        self.radixes = radixes
+        self.probs = np.array(probs)
+
+    def get_counts(self, shots: int) -> npt.NDArray[np.int64]:
+        return np.asarray(np.multiply(shots, self.probs), np.int64)
+
+    def __str__(self) -> str:
+        pass

bqskit/exec/runner.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from abc import ABC
+from abc import abstractmethod
+
+from bqskit.exec.results import RunnerResults
+from bqskit.ir.circuit import Circuit
+
+
+class CircuitRunner(ABC):
+    """A CircuitRunner is responsible for executing a quantum circuit."""
+
+    @abstractmethod
+    def run(self, circuit: Circuit) -> RunnerResults:
+        """
+        Execute the circuit and return results.
+
+        Args:
+            circuit (Circuit): The circuit to run.
+
+        Returns:
+            (RunnerResults): The results from executing this circuit.
+        """