Adapt hardware devices to process custom wires (#59)

* delete superfluous conversion

* rewrite wire handling of fixed-size devices

* sneak in software device docstring update

pennylane_forest/numpy_wavefunction.py

@@ -34,7 +34,9 @@ class NumpyWavefunctionDevice(ForestDevice):
     r"""NumpyWavefunction simulator device for PennyLane.
 
     Args:
-        wires (int): the number of qubits to initialize the device in
+        wires (int or Iterable[Number, str]]): Number of subsystems represented by the device,
+            or iterable that contains unique labels for the subsystems as numbers (i.e., ``[-1, 0, 2]``)
+            or strings (``['ancilla', 'q1', 'q2']``).
         shots (int): Number of circuit evaluations/random samples used
             to estimate expectation values of observables.
     """

pennylane_forest/qpu.py

@@ -46,6 +46,11 @@ class QPUDevice(QVMDevice):
         device (str): the name of the device to initialise.
         shots (int): number of circuit evaluations/random samples used
             to estimate expectation values of observables.
+         wires (Iterable[Number, str]): Iterable that contains unique labels for the
+            qubits as numbers or strings (i.e., ``['q1', ..., 'qN']``).
+            The number of labels must match the number of qubits accessible on the backend.
+            If not provided, qubits are addressed as consecutive integers ``[0, 1, ...]``, and their number
+            is inferred from the backend.
         active_reset (bool): whether to actively reset qubits instead of waiting for
             for qubits to decay to the ground state naturally.
             Setting this to ``True`` results in a significantly faster expectation value
@@ -83,6 +88,7 @@ def __init__(
         device,
         *,
         shots=1000,
+        wires=None,
         active_reset=True,
         load_qc=True,
         readout_error=None,
@@ -132,9 +138,6 @@ def __init__(
 
         timeout = kwargs.pop("timeout", None)
 
-        if "wires" in kwargs:
-            raise ValueError("QPU device does not support a wires parameter.")
-
         if shots <= 0:
             raise ValueError("Number of shots must be a positive integer.")
 
@@ -149,9 +152,26 @@ def __init__(
             if timeout is not None:
                 self.qc.compiler.client.timeout = timeout
 
-        num_wires = len(self.qc.qubits())
+        self.num_wires = len(self.qc.qubits())
+
+        if wires is None:
+            # infer the number of modes from the device specs
+            # and use consecutive integer wire labels
+            wires = range(self.num_wires)
+
+        if isinstance(wires, int):
+            raise ValueError(
+                "Device has a fixed number of {} qubits. The wires argument can only be used "
+                "to specify an iterable of wire labels.".format(self.num_wires)
+            )
+
+        if self.num_wires != len(wires):
+            raise ValueError(
+                "Device has a fixed number of {} qubits and "
+                "cannot be created with {} wires.".format(self.num_wires, len(wires))
+            )
 
-        super(QVMDevice, self).__init__(num_wires, shots, **kwargs)
+        super(QVMDevice, self).__init__(wires, shots, **kwargs)
 
         self.active_reset = active_reset
         self.symmetrize_readout = symmetrize_readout

pennylane_forest/qvm.py

@@ -53,6 +53,11 @@ class QVMDevice(ForestDevice):
 
         shots (int): number of circuit evaluations/random samples used
             to estimate expectation values of observables.
+        wires (Iterable[Number, str]): Iterable that contains unique labels for the
+            qubits as numbers or strings (i.e., ``['q1', ..., 'qN']``).
+            The number of labels must match the number of qubits accessible on the backend.
+            If not provided, qubits are addressed as consecutive integers [0, 1, ...], and their number
+            is inferred from the backend.
         noisy (bool): set to ``True`` to add noise models to your QVM.
 
     Keyword args:
@@ -73,13 +78,11 @@ class QVMDevice(ForestDevice):
     short_name = "forest.qvm"
     observables = {"PauliX", "PauliY", "PauliZ", "Identity", "Hadamard", "Hermitian"}
 
-    def __init__(self, device, *, shots=1000, noisy=False, **kwargs):
+    def __init__(self, device, *, wires=None, shots=1000, noisy=False, **kwargs):
 
         if shots <= 0:
             raise ValueError("Number of shots must be a positive integer.")
 
-        # ignore any 'wires' keyword argument passed to the device
-        kwargs.pop("wires", None)
         analytic = kwargs.get("analytic", False)
         timeout = kwargs.pop("timeout", None)
 
@@ -116,9 +119,26 @@ def __init__(self, device, *, shots=1000, noisy=False, **kwargs):
         elif isinstance(device, str):
             self.qc = get_qc(device, as_qvm=True, noisy=noisy, connection=self.connection)
 
-        num_wires = len(self.qc.qubits())
+        self.num_wires = len(self.qc.qubits())
 
-        super().__init__(num_wires, shots, analytic=analytic, **kwargs)
+        if wires is None:
+            # infer the number of modes from the device specs
+            # and use consecutive integer wire labels
+            wires = range(self.num_wires)
+
+        if isinstance(wires, int):
+            raise ValueError(
+                "Device has a fixed number of {} qubits. The wires argument can only be used "
+                "to specify an iterable of wire labels.".format(self.num_wires)
+            )
+
+        if self.num_wires != len(wires):
+            raise ValueError(
+                "Device has a fixed number of {} qubits and "
+                "cannot be created with {} wires.".format(self.num_wires, len(wires))
+            )
+
+        super().__init__(wires, shots, analytic=analytic, **kwargs)
 
         if timeout is not None:
             self.qc.compiler.client.timeout = timeout

pennylane_forest/wavefunction.py

@@ -52,7 +52,9 @@ class WavefunctionDevice(ForestDevice):
     r"""Wavefunction simulator device for PennyLane.
 
     Args:
-        wires (int): the number of qubits to initialize the device in
+        wires (int or Iterable[Number, str]]): Number of subsystems represented by the device,
+            or iterable that contains unique labels for the subsystems as numbers (i.e., ``[-1, 0, 2]``)
+            or strings (``['ancilla', 'q1', 'q2']``).
         shots (int): Number of circuit evaluations/random samples used
             to estimate expectation values of observables.
 

tests/test_qpu.py

@@ -10,6 +10,7 @@
 import pennylane as qml
 from pennylane import numpy as np
 from pennylane.operation import Tensor
+from pennylane.wires import Wires
 import pennylane_forest as plf
 from conftest import BaseTest, QVM_SHOTS
 
@@ -44,9 +45,6 @@ def test_qpu_args(self):
         """Test that the QPU plugin requires correct arguments"""
         device = np.random.choice(TEST_QPU_LATTICES)
 
-        with pytest.raises(ValueError, match="QPU device does not support a wires parameter"):
-            qml.device("forest.qpu", device=device, wires=2)
-
         with pytest.raises(TypeError, match="missing 1 required positional argument"):
             qml.device("forest.qpu")
 
@@ -56,6 +54,18 @@ def test_qpu_args(self):
         with pytest.raises(ValueError, match="Readout error cannot be set on the physical QPU"):
             qml.device("forest.qpu", device=device, load_qc=True, readout_error=[0.9, 0.75])
 
+        dev_no_wires = qml.device("forest.qpu", device=device, shots=5, load_qc=False)
+        assert dev_no_wires.wires == Wires(range(4))
+
+        with pytest.raises(ValueError, match="Device has a fixed number of"):
+            qml.device("forest.qpu", device=device, shots=5, wires=100, load_qc=False)
+
+        dev_iterable_wires = qml.device("forest.qpu", device=device, shots=5, wires=range(4), load_qc=False)
+        assert dev_iterable_wires.wires == Wires(range(4))
+
+        with pytest.raises(ValueError, match="Device has a fixed number of"):
+            qml.device("forest.qpu", device=device, shots=5, wires=range(100), load_qc=False)
+
     @flaky(max_runs=5, min_passes=3)
     @pytest.mark.parametrize(
         "obs", [qml.PauliX(0), qml.PauliZ(0), qml.PauliY(0), qml.Hadamard(0), qml.Identity(0)]

tests/test_qvm.py

@@ -13,6 +13,7 @@
 from pennylane.operation import Tensor
 from pennylane.circuit_graph import CircuitGraph
 from pennylane.variable import Variable
+from pennylane.wires import Wires
 
 from pyquil.quil import Pragma, Program
 from pyquil.api._quantum_computer import QuantumComputer
@@ -465,6 +466,21 @@ def test_sample_values_hermitian_multi_qubit(self, qvm, tol):
         ) / 32
         assert np.allclose(np.mean(s1), expected, atol=0.1, rtol=0)
 
+    def test_wires_argument(self):
+        """Test that the wires argument gets processed correctly."""
+
+        dev_no_wires = plf.QVMDevice(device="2q-qvm", shots=5)
+        assert dev_no_wires.wires == Wires(range(2))
+
+        with pytest.raises(ValueError, match="Device has a fixed number of"):
+            plf.QVMDevice(device="2q-qvm", shots=5, wires=1000)
+
+        dev_iterable_wires = plf.QVMDevice(device="2q-qvm", shots=5, wires=range(2))
+        assert dev_iterable_wires.wires == Wires(range(2))
+
+        with pytest.raises(ValueError, match="Device has a fixed number of"):
+            plf.QVMDevice(device="2q-qvm", shots=5, wires=range(1000))
+
     @pytest.mark.parametrize("shots", list(range(0, -10, -1)))
     def test_raise_error_if_shots_is_not_positive(self, shots):
         """Test that instantiating a QVMDevice if the number of shots is not a postivie