Release/0.35.0 (#71)

Author: cqc-alec

.pylintrc

@@ -22,15 +22,13 @@ enable=
     line-too-long,
     lost-exception,
     missing-kwoa,
-    mixed-indentation,
     mixed-line-endings,
     not-callable,
     no-value-for-parameter,
     nonexistent-operator,
     not-in-loop,
     pointless-statement,
     redefined-builtin,
-    relative-import,
     return-arg-in-generator,
     return-in-init,
     return-outside-function,

_metadata.py

@@ -1,2 +1,2 @@
-__extension_version__ = "0.34.0"
+__extension_version__ = "0.35.0"
 __extension_name__ = "pytket-qiskit"

docs/changelog.rst

@@ -1,6 +1,15 @@
 Changelog
 ~~~~~~~~~
 
+0.35.0 (February 2023)
+----------------------
+
+* Automatically use IBMQ token if saved in pytket config and not saved in qiskit
+  config.
+* Update qiskit version to 0.40.
+* Update code to remove some deprecation warnings.
+* Work around https://github.com/Qiskit/qiskit-terra/issues/7865.
+
 0.34.0 (January 2023)
 ---------------------
 

docs/intro.txt

@@ -42,6 +42,17 @@ If you are a member of an IBM hub then you can add this information to ``set_ibm
 
     set_ibmq_config(ibmq_api_token=ibm_token, hub='your hub', group='your group', project='your project')
 
+Alternatively you can use the following qiskit commands to save your credentials
+locally without saving the token in pytket config:
+
+::
+
+    from qiskit import IBMQ
+    from qiskit_ibm_runtime import QiskitRuntimeService
+
+    IBMQ.save_account(token=ibm_token)
+    QiskitRuntimeService.save_account(channel="ibm_quantum", token=ibm_token)
+
 To see which devices you can access you can use the ``available_devices`` method on the ``IBMQBackend`` or ``IBMQEmulatorBackend``. Note that it is possible to pass ``hub``, ``group`` and ``project`` parameters to this method. This allows you to see which devices are accessible through your IBM hub.
 
 ::

pytket/extensions/qiskit/backends/aer.py

@@ -32,14 +32,11 @@
 
 import numpy as np
 
-from qiskit import Aer  # type: ignore
-from qiskit.providers.aer.library import (  # type: ignore # pylint: disable=unused-import
-    save_expectation_value,
-)
 from qiskit.providers.aer.noise import NoiseModel  # type: ignore
 from qiskit.quantum_info.operators import Pauli as qk_Pauli  # type: ignore
-from qiskit.quantum_info.operators.symplectic.pauli_table import PauliTable  # type: ignore
 from qiskit.quantum_info.operators.symplectic.sparse_pauli_op import SparsePauliOp  # type: ignore
+from qiskit_aer import Aer  # type: ignore
+from qiskit_aer.library import save_expectation_value  # type: ignore # pylint: disable=unused-import
 
 from pytket.backends import Backend, CircuitNotRunError, CircuitStatus, ResultHandle
 from pytket.backends.backendinfo import BackendInfo
@@ -695,14 +692,12 @@ def _sparse_to_zx_tup(
 def _qubitpauliop_to_sparsepauliop(
     operator: QubitPauliOperator, n_qubits: int
 ) -> SparsePauliOp:
-    n_ops = len(operator._dict)
-    table_array = np.zeros((n_ops, 2 * n_qubits), dtype=np.bool_)
-    coeffs = np.zeros(n_ops, dtype=np.float64)
-
-    for i, (term, coeff) in enumerate(operator._dict.items()):
-        coeffs[i] = coeff
-        z, x = _sparse_to_zx_tup(term, n_qubits)
-        table_array[i, :n_qubits] = x
-        table_array[i, n_qubits:] = z
+    strings, coeffs = [], []
+    for term, coeff in operator._dict.items():
+        termmap = term.map
+        strings.append(
+            "".join(termmap.get(Qubit(i), Pauli.I).name for i in range(n_qubits))
+        )
+        coeffs.append(coeff)
 
-    return SparsePauliOp(PauliTable(table_array), coeffs)
+    return SparsePauliOp(strings, coeffs)

pytket/extensions/qiskit/backends/ibm.py

@@ -17,6 +17,7 @@
 from ast import literal_eval
 from collections import Counter
 import json
+from time import sleep
 from typing import (
     cast,
     List,
@@ -33,7 +34,12 @@
 import qiskit  # type: ignore
 from qiskit import IBMQ
 from qiskit.primitives import SamplerResult  # type: ignore
-from qiskit.tools.monitor import job_monitor  # type: ignore
+
+
+# RuntimeJob has no queue_position attribute, which is referenced
+# via job_monitor see-> https://github.com/CQCL/pytket-qiskit/issues/48
+# therefore we can't use job_monitor until fixed
+# from qiskit.tools.monitor import job_monitor  # type: ignore
 from qiskit.result.distributions import QuasiDistribution  # type: ignore
 from qiskit_ibm_runtime import (  # type: ignore
     QiskitRuntimeService,
@@ -113,6 +119,23 @@ def __init__(self) -> None:
         )
 
 
+def _save_ibmq_auth(qiskit_config: Optional[QiskitConfig]) -> None:
+    token = None
+    if qiskit_config is not None:
+        token = qiskit_config.ibmq_api_token
+    if not IBMQ.active_account():
+        if IBMQ.stored_account():
+            IBMQ.load_account()
+        else:
+            if token is not None:
+                IBMQ.save_account(token)
+            else:
+                raise NoIBMQAccountError()
+    if not QiskitRuntimeService.saved_accounts():
+        if token is not None:
+            QiskitRuntimeService.save_account(channel="ibm_quantum", token=token)
+
+
 class IBMQBackend(Backend):
     _supports_shots = False
     _supports_counts = True
@@ -189,17 +212,7 @@ def _get_provider(
         project: Optional[str],
         qiskit_config: Optional[QiskitConfig],
     ) -> "AccountProvider":
-        if not IBMQ.active_account():
-            if IBMQ.stored_account():
-                IBMQ.load_account()
-            else:
-                if (
-                    qiskit_config is not None
-                    and qiskit_config.ibmq_api_token is not None
-                ):
-                    IBMQ.save_account(qiskit_config.ibmq_api_token)
-                else:
-                    raise NoIBMQAccountError()
+        _save_ibmq_auth(qiskit_config)
         provider_kwargs: Dict[str, Optional[str]] = {}
         if hub:
             provider_kwargs["hub"] = hub
@@ -251,19 +264,39 @@ def _get_backend_info(cls, backend: "_QiskIBMQBackend") -> BackendInfo:
         filtered_characterisation = {
             k: v for k, v in characterisation.items() if k in characterisation_keys
         }
+        # see below for references for config definitions
+        # quantum-computing.ibm.com/services/resources/docs/resources/manage/systems/:
+        # midcircuit-measurement/
+        # dynamic-circuits/feature-table
         supports_mid_measure = config.simulator or config.multi_meas_enabled
-        supports_fast_feedforward = False
+        supports_fast_feedforward = (
+            hasattr(config, "supported_features")
+            and "qasm3" in config.supported_features
+        )
+
         # simulator i.e. "ibmq_qasm_simulator" does not have `supported_instructions`
         # attribute
+        supports_reset = (
+            hasattr(config, "supported_instructions")
+            and "reset" in config.supported_instructions
+        )
         gate_set = _tk_gate_set(backend)
         backend_info = BackendInfo(
             cls.__name__,
             backend.name(),
             __extension_version__,
             arch,
-            gate_set,
+            gate_set.union(
+                {
+                    OpType.RangePredicate,
+                    OpType.Conditional,
+                }
+            )
+            if supports_fast_feedforward
+            else gate_set,
             supports_midcircuit_measurement=supports_mid_measure,
             supports_fast_feedforward=supports_fast_feedforward,
+            supports_reset=supports_reset,
             all_node_gate_errors=characterisation["NodeErrors"],
             all_edge_gate_errors=characterisation["EdgeErrors"],
             all_readout_errors=characterisation["ReadoutErrors"],
@@ -382,6 +415,7 @@ def process_circuits(
         Supported kwargs: `postprocess`.
         """
         circuits = list(circuits)
+
         n_shots_list = Backend._get_n_shots_as_list(
             n_shots,
             len(circuits),
@@ -428,7 +462,10 @@ def process_circuits(
                     options.transpilation.skip_transpilation = True
                     options.execution.shots = n_shots
                     sampler = Sampler(session=self._session, options=options)
-                    job = sampler.run(circuits=qcs)
+                    job = sampler.run(
+                        circuits=qcs,
+                        dynamic=self.backend_info.supports_fast_feedforward,
+                    )
                     job_id = job.job_id
                     for i, ind in enumerate(indices_chunk):
                         handle_list[ind] = ResultHandle(
@@ -484,9 +521,16 @@ def get_result(self, handle: ResultHandle, **kwargs: KwargTypes) -> BackendResul
                 except Exception as e:
                     warn(f"Unable to retrieve job {jobid}: {e}")
                     raise CircuitNotRunError(handle)
-
+                # RuntimeJob has no queue_position attribute, which is referenced
+                # via job_monitor see-> https://github.com/CQCL/pytket-qiskit/issues/48
+                # therefore we can't use job_monitor until fixed
                 if self._monitor and job:
-                    job_monitor(job)
+                    #     job_monitor(job)
+                    status = job.status()
+                    while status.name not in ["DONE", "CANCELLED", "ERROR"]:
+                        status = job.status()
+                        print("Job status is", status.name)
+                        sleep(10)
 
                 res = job.result(timeout=kwargs.get("timeout", None))
             for circ_index, (r, d) in enumerate(zip(res.quasi_dists, res.metadata)):

setup.py

@@ -45,8 +45,9 @@
     include_package_data=True,
     install_requires=[
         "pytket ~= 1.11",
-        "qiskit ~= 0.39.0",
-        "qiskit_ibm_runtime ~= 0.8.0",
+        "qiskit ~= 0.40.0",
+        "qiskit-ibm-runtime ~= 0.8.0",
+        "qiskit-aer ~= 0.11.2",
     ],
     classifiers=[
         "Environment :: Console",

tests/backend_test.py

@@ -939,11 +939,24 @@ def test_ibmq_mid_measure(manila_backend: IBMQBackend) -> None:
     b = manila_backend
     ps = b.default_compilation_pass(0)
     ps.apply(c)
-    # c = b.get_compiled_circuit(c)
     assert not NoMidMeasurePredicate().verify(c)
     assert b.valid_circuit(c)
 
 
+@pytest.mark.skipif(skip_remote_tests, reason=REASON)
+def test_ibmq_conditional(manila_backend: IBMQBackend) -> None:
+    c = Circuit(3, 2).H(1).CX(1, 2).Measure(0, 0).Measure(1, 1)
+    c.add_barrier([0, 1, 2])
+    ar = c.add_c_register("a", 1)
+    c.CX(1, 0).H(0).X(2, condition=reg_eq(ar, 0)).Measure(Qubit(2), ar[0])
+
+    b = manila_backend
+    assert b.backend_info.supports_fast_feedforward
+    compiled = b.get_compiled_circuit(c)
+    assert not NoMidMeasurePredicate().verify(compiled)
+    assert b.valid_circuit(compiled)
+
+
 @pytest.mark.skipif(skip_remote_tests, reason=REASON)
 def test_compile_x(manila_backend: IBMQBackend) -> None:
     # TKET-1028

tests/qiskit_backend_test.py

@@ -22,11 +22,11 @@
 from qiskit.providers.ibmq import AccountProvider  # type: ignore
 from qiskit.opflow import CircuitStateFn, CircuitSampler  # type: ignore
 from qiskit.providers import JobStatus  # type: ignore
-from qiskit.providers.aer import Aer  # type: ignore
 from qiskit.utils import QuantumInstance  # type: ignore
 from qiskit.algorithms import Grover, AmplificationProblem  # type: ignore
 from qiskit.transpiler.exceptions import TranspilerError  # type: ignore
 from qiskit.transpiler.passes import Unroller  # type: ignore
+from qiskit_aer import Aer  # type: ignore
 
 from pytket.extensions.qiskit import (
     AerBackend,

tests/qiskit_convert_test.py

@@ -23,7 +23,6 @@
     QuantumRegister,
     ClassicalRegister,
     execute,
-    Aer,
     IBMQ,
 )
 from qiskit.opflow import PauliOp, PauliSumOp, PauliTrotterEvolution, Suzuki  # type: ignore
@@ -33,6 +32,7 @@
 from qiskit.circuit.library import RYGate, MCMT  # type: ignore
 import qiskit.circuit.library.standard_gates as qiskit_gates  # type: ignore
 from qiskit.circuit import Parameter  # type: ignore
+from qiskit_aer import Aer  # type: ignore
 from pytket.circuit import (  # type: ignore
     Circuit,
     CircBox,