Update plugin by removing analytic argument for device creation

.github/workflows/tests.yml

@@ -74,10 +74,10 @@ jobs:
 
       - name: Run tests
         run: |
-          pl-device-test --device=qiskit.basicaer --tb=short --skip-ops --analytic=False --shots=20000 --device-kwargs backend=qasm_simulator
-          pl-device-test --device=qiskit.aer --tb=short --skip-ops --analytic=False --shots=20000 --device-kwargs backend=qasm_simulator
-          pl-device-test --device=qiskit.aer --tb=short --skip-ops --analytic=True --device-kwargs backend=statevector_simulator
-          pl-device-test --device=qiskit.aer --tb=short --skip-ops --analytic=True --device-kwargs backend=unitary_simulator
+          pl-device-test --device=qiskit.basicaer --tb=short --skip-ops --shots=20000 --device-kwargs backend=qasm_simulator
+          pl-device-test --device=qiskit.aer --tb=short --skip-ops --shots=20000 --device-kwargs backend=qasm_simulator
+          pl-device-test --device=qiskit.aer --tb=short --skip-ops --shots=None --device-kwargs backend=statevector_simulator
+          pl-device-test --device=qiskit.aer --tb=short --skip-ops --shots=None --device-kwargs backend=unitary_simulator
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v1

pennylane_qiskit/aer.py

@@ -38,16 +38,14 @@ class AerDevice(QiskitDevice):
             or iterable that contains unique labels for the subsystems as numbers (i.e., ``[-1, 0, 2]``)
             or strings (``['ancilla', 'q1', 'q2']``).
         backend (str): the desired backend
-        shots (int): number of circuit evaluations/random samples used
-            to estimate expectation values and variances of observables
+        shots (int or None): number of circuit evaluations/random samples used
+            to estimate expectation values and variances of observables. For statevector backends,
+            setting to None computes the expectation values and variances analytically.
 
     Keyword Args:
         name (str): The name of the circuit. Default ``'circuit'``.
         compile_backend (BaseBackend): The backend used for compilation. If you wish
             to simulate a device compliant circuit, you can specify a backend here.
-        analytic (bool): For statevector backends, determines if the
-            expectation values and variances are to be computed analytically.
-            Default value is ``False``.
         noise_model (NoiseModel): NoiseModel Object from ``qiskit.providers.aer.noise``
     """
 

pennylane_qiskit/basic_aer.py

@@ -38,16 +38,14 @@ class BasicAerDevice(QiskitDevice):
             or iterable that contains unique labels for the subsystems as numbers (i.e., ``[-1, 0, 2]``)
             or strings (``['ancilla', 'q1', 'q2']``).
         backend (str): the desired backend
-        shots (int): number of circuit evaluations/random samples used
-            to estimate expectation values and variances of observables
+        shots (int or None): number of circuit evaluations/random samples used
+            to estimate expectation values and variances of observables. For statevector backends,
+            setting to None computes the expectation values and variances analytically.
 
     Keyword Args:
         name (str): The name of the circuit. Default ``'circuit'``.
         compile_backend (BaseBackend): The backend used for compilation. If you wish
             to simulate a device compliant circuit, you can specify a backend here.
-        analytic (bool): For statevector backends, determines if the
-            expectation values and variances are to be computed analytically.
-            Default value is ``False``.
     """
 
     short_name = "qiskit.basicaer"

pennylane_qiskit/qiskit_device.py

@@ -75,20 +75,18 @@ class QiskitDevice(QubitDevice, abc.ABC):
             or strings (``['ancilla', 'q1', 'q2']``).
         provider (Provider): The Qiskit simulation provider
         backend (str): the desired backend
-        shots (int): Number of circuit evaluations/random samples used
-            to estimate expectation values of observables.
+        shots (int or None): number of circuit evaluations/random samples used
+            to estimate expectation values and variances of observables. For statevector backends,
+            setting to None computes the expectation values and variances analytically.
 
     Keyword Args:
         name (str): The name of the circuit. Default ``'circuit'``.
         compile_backend (BaseBackend): The backend used for compilation. If you wish
             to simulate a device compliant circuit, you can specify a backend here.
-        analytic (bool): For statevector backends, determines if the
-            expectation values and variances are to be computed analytically.
-            Default value is ``False``.
     """
     name = "Qiskit PennyLane plugin"
     pennylane_requires = ">=0.12.0"
-    version = "0.14.0"
+    version = "0.15.0"
     plugin_version = __version__
     author = "Xanadu"
 
@@ -113,16 +111,12 @@ def __init__(self, wires, provider, backend, shots=1024, **kwargs):
         super().__init__(wires=wires, shots=shots)
 
         # Keep track if the user specified analytic to be True
-        user_specified_analytic = "analytic" in kwargs and kwargs["analytic"]
-        self.analytic = kwargs.pop("analytic", False)
+        if shots is None and backend not in self._state_backends:
 
-        if self.analytic and backend not in self._state_backends:
+            # Raise a warning if the analytic attribute was set to True
+            warnings.warn(self.hw_analytic_warning_message.format(backend), UserWarning)
 
-            if user_specified_analytic:
-                # Raise a warning if the analytic attribute was set to True
-                warnings.warn(self.hw_analytic_warning_message.format(backend), UserWarning)
-
-            self.analytic = False
+            self.shots = 1024
 
         self._backend = None
 

requirements.txt

@@ -1,5 +1,5 @@
 qiskit>=0.23.4
-pennylane>=0.14.0
+git+https://github.com/PennyLaneAI/pennylane.git
 numpy
 networkx>=2.2;python_version>'3.5'
 networkx>=2.2,<2.4;python_version=='3.5'

tests/conftest.py

@@ -26,8 +26,8 @@
 
 
 @pytest.fixture
-def tol(analytic):
-    if analytic:
+def tol(shots):
+    if not shots:
         return {"atol": 0.01, "rtol": 0}
 
     return {"atol": 0.05, "rtol": 0.1}
@@ -42,16 +42,19 @@ def _init_state(n):
 
     return _init_state
 
+
 @pytest.fixture
 def skip_unitary(backend):
     if backend == "unitary_simulator":
         pytest.skip("This test does not support the unitary simulator backend.")
 
+
 @pytest.fixture
 def run_only_for_unitary(backend):
     if backend != "unitary_simulator":
         pytest.skip("This test only supports the unitary simulator.")
 
+
 @pytest.fixture(params=state_backends + hw_backends)
 def backend(request):
     return request.param
@@ -68,22 +71,22 @@ def hardware_backend(request):
 
 
 @pytest.fixture(params=[AerDevice, BasicAerDevice])
-def device(request, backend, shots, analytic):
-    if backend not in state_backends and analytic == True:
+def device(request, backend, shots):
+    if backend not in state_backends and shots is None:
         pytest.skip("Hardware simulators do not support analytic mode")
 
     def _device(n, device_options=None):
         if device_options is None:
             device_options = {}
-        return request.param(wires=n, backend=backend, shots=shots, analytic=analytic, **device_options)
+        return request.param(wires=n, backend=backend, shots=shots, **device_options)
 
     return _device
 
 
 @pytest.fixture(params=[AerDevice, BasicAerDevice])
-def state_vector_device(request, statevector_backend, shots, analytic):
+def state_vector_device(request, statevector_backend, shots):
     def _device(n):
-        return request.param(wires=n, backend=statevector_backend, shots=shots, analytic=analytic)
+        return request.param(wires=n, backend=statevector_backend, shots=shots)
 
     return _device
 
@@ -94,20 +97,20 @@ def mock_device(monkeypatch):
 
     with monkeypatch.context() as m:
         dev = qml.Device
-        m.setattr(dev, '__abstractmethods__', frozenset())
+        m.setattr(dev, "__abstractmethods__", frozenset())
         yield qml.Device()
 
 
 @pytest.fixture(scope="function")
 def recorder():
-    return qml._queuing.OperationRecorder()
+    return qml.tape.OperationRecorder()
 
 
 @pytest.fixture(scope="function")
 def qubit_device_single_wire():
-    return qml.device('default.qubit', wires=1)
+    return qml.device("default.qubit", wires=1)
 
 
 @pytest.fixture(scope="function")
 def qubit_device_2_wires():
-    return qml.device('default.qubit', wires=2)
+    return qml.device("default.qubit", wires=2)

tests/test_apply.py

@@ -42,25 +42,18 @@
 )
 
 
-single_qubit_operations = [
-    qml.PauliX,
-    qml.PauliY,
-    qml.PauliZ,
-    qml.Hadamard,
-    qml.S,
-    qml.T
-]
+single_qubit_operations = [qml.PauliX, qml.PauliY, qml.PauliZ, qml.Hadamard, qml.S, qml.T]
 
 single_qubit_operations_param = [qml.PhaseShift, qml.RX, qml.RY, qml.RZ]
 two_qubit = [qml.CNOT, qml.SWAP, qml.CZ]
 two_qubit_param = [qml.CRZ]
 three_qubit = [qml.Toffoli, qml.CSWAP]
 
-@pytest.mark.parametrize("analytic", [True])
-@pytest.mark.parametrize("shots", [8192])
+
+@pytest.mark.parametrize("shots", [None])
 @pytest.mark.usefixtures("skip_unitary")
 class TestAnalyticApply:
-    """Test application of PennyLane operations with analytic attribute set to True."""
+    """Test application of PennyLane operations with analytic calculation."""
 
     def test_qubit_state_vector(self, init_state, device, tol):
         """Test that the QubitStateVector operation produces the expected
@@ -149,8 +142,8 @@ def test_three_qubit_operations_no_parameters(self, init_state, device, operatio
         expected = np.abs(applied_operation.matrix @ state) ** 2
         assert np.allclose(res, expected, **tol)
 
-@pytest.mark.parametrize("analytic", [True])
-@pytest.mark.parametrize("shots", [8192])
+
+@pytest.mark.parametrize("shots", [None])
 @pytest.mark.usefixtures("run_only_for_unitary")
 class TestStateApplyUnitarySimulator:
     """Test application of PennyLane operations to the unitary simulator."""
@@ -161,14 +154,17 @@ def test_invalid_qubit(self, init_state, device):
         dev = device(1)
         state = init_state(1)
 
-        with pytest.raises(qml.DeviceError, match="The QubitStateVector operation is not supported on the unitary simulator backend"):
+        with pytest.raises(
+            qml.DeviceError,
+            match="The QubitStateVector operation is not supported on the unitary simulator backend",
+        ):
             dev.apply([qml.QubitStateVector(state, wires=[0])])
 
+
 @pytest.mark.parametrize("shots", [8192])
-@pytest.mark.parametrize("analytic", [False])
 @pytest.mark.usefixtures("skip_unitary")
 class TestNonAnalyticApply:
-    """Test application of PennyLane operations with the analytic attribute set to False."""
+    """Test application of PennyLane operations with non-analytic calculation."""
 
     def test_qubit_state_vector(self, init_state, device, tol):
         """Test that the QubitStateVector operation produces the expected
@@ -302,4 +298,3 @@ def test_three_qubit_no_parameters(self, init_state, device, operation, tol):
         res = np.fromiter(dev.probability(), dtype=np.float64)
         expected = np.abs(applied_operation.matrix @ state) ** 2
         assert np.allclose(res, expected, **tol)
-