Plugin page update

CHANGELOG.md

@@ -24,6 +24,10 @@
 
 ### Documentation 📝
 
+* The Pennylane-Qiskit plugin page has been updated to reflect the changes in both the plugin's 
+capabilities and Qiskit.
+  [#563](https://github.com/PennyLaneAI/pennylane-qiskit/pull/563)
+
 ### Bug fixes 🐛
 
 ### Contributors ✍️

README.rst

@@ -68,21 +68,11 @@ To test that the PennyLane-Qiskit plugin is working correctly you can run
 
 in the source folder.
 
-.. note::
-
-    Tests on the `IBMQ device <https://pennylaneqiskit.readthedocs.io/en/latest/devices/ibmq.html>`_ can
-    only be run if a ``ibmqx_token`` for the
-    `IBM Q experience <https://quantum-computing.ibm.com/>`_ is
-    configured in the `PennyLane configuration file
-    <https://pennylane.readthedocs.io/en/latest/introduction/configuration.html>`_, if the token is
-    exported in your environment under the name ``IBMQX_TOKEN``, or if you have previously saved your
-    account credentials using the
-    `new IBMProvider <https://qiskit.org/ecosystem/ibm-provider/stubs/qiskit_ibm_provider.IBMProvider.html>`_
-
-    If this is the case, running ``make test`` also executes tests on the ``ibmq`` device.
-    By default, tests on the ``ibmq`` device run with ``ibmq_qasm_simulator`` backend. At
-    the time of writing this means that the test are "free".
-    Please verify that this is also the case for your account.
+.. warning::
+
+    When installing the Pennylane-Qiskit plugin, we recommend starting with a clean environment.
+    This is especially pertinent when upgrading from a pre-1.0 version of Qiskit, as described
+    in `Qiskit's migration guide <https://docs.quantum.ibm.com/api/migration-guides/qiskit-1.0-installation>`_. 
 
 .. installation-end-inclusion-marker-do-not-remove
 

doc/devices/aer.rst

@@ -27,24 +27,19 @@ parameters would look like:
         qml.CNOT(wires=[0, 1])
         return qml.expval(qml.PauliZ(wires=1))
 
-You can then execute the circuit like any other function to get the quantum mechanical expectation value.
+You can then execute the circuit like any other function to get the expectation value of a Pauli 
+operator.
 
 .. code-block:: python
 
     circuit(0.2, 0.1, 0.3)
 
-Backends
-~~~~~~~~
+Backend Methods and Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The default backend is the ``AerSimulator``. However, multiple other backends are also available.
 To get a current overview what backends are available you can query
 
-.. code-block:: python
-
-    dev.capabilities()['backend']
-
-or, alternatively,
-
 .. code-block:: python
 
     from qiskit_aer import Aer
@@ -58,18 +53,28 @@ You can change a ``'qiskit.aer'`` device's backend with the ``backend`` argument
 
 .. code-block:: python
 
-    dev = qml.device('qiskit.aer', wires=2, backend='aer_simulator_statevector')
+    from qiskit_aer import UnitarySimulator
+    dev = qml.device('qiskit.aer', wires=2, backend=UnitarySimulator())
 
-Backend Methods and Options
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.. note::
+
+    Occassionally, you may see others pass in a string as a backend. For example:
+
+    .. code-block:: python
+
+        dev = qml.device('qiskit.aer', wires=2, backend='unitary_simulator')
+
+    At the time of writing, this is still functional for the Aer devices. However, this will soon be 
+    deprecated and may not function as intended. To ensure accurate results, we recommend passing in 
+    a backend instance.
 
-This ``AerSimulator`` backend has several available methods, which
+The ``AerSimulator`` backend has several available methods, which
 can be passed via the ``method`` keyword argument. For example
 ``'automatic'``, ``'statevector'``, and ``'unitary'``.
 
 .. code-block:: python
 
-    dev = qml.device("qiskit.aer", wires=2, method="automatic")
+    dev = qml.device("qiskit.aer", wires=2, backend=AerSimulator(), method="automatic")
 
 Each of these methods can take different *run options*, for example to specify the numerical
 precision of the simulation.
@@ -81,7 +86,7 @@ The options are set via additional keyword arguments:
     dev = qml.device(
         'qiskit.aer',
         wires=2,
-        backend='unitary_simulator',
+        backend=AerSimulator(),
         validation_threshold=1e-6
     )
 
@@ -96,9 +101,9 @@ documentation <https://qiskit.org/ecosystem/aer/stubs/qiskit_aer.AerSimulator.ht
 Noise models
 ~~~~~~~~~~~~
 
-One great feature of the ``'qiskit.aer'`` device is the ability to simulate noise. There are different noise models,
-which you can instantiate and apply to the device as follows
-(adapting `this <https://qiskit.org/documentation/apidoc/aer_noise.html>`_ qiskit tutorial):
+One great feature of the ``'qiskit.aer'`` device is the ability to simulate noise. There are 
+different noise models, which you can instantiate and apply to the device as follows (adapted 
+from a `Qiskit tutorial <https://qiskit.github.io/qiskit-aer/tutorials/4_custom_gate_noise.html>`_.):
 
 .. code-block:: python
 
@@ -136,4 +141,4 @@ which you can instantiate and apply to the device as follows
     print(circuit(0.2, 0.1, 0.3))
 
 Please refer to the Qiskit documentation for more information on
-`noise models <https://qiskit.org/documentation/tutorials/simulators/3_building_noise_models.html>`_.
+`noise models <https://qiskit.github.io/qiskit-aer/tutorials/3_building_noise_models.html>`_.

doc/devices/basicsim.rst

@@ -19,6 +19,5 @@ This device uses the Qiskit ``BasicSimulator`` backend from the
 
     The `Qiskit Aer <https://qiskit.github.io/qiskit-aer/>`_ device
     provides a fast simulator that is also capable of simulating
-    noise. It is available as :ref:`"qiskit.aer" <aer device page>`, but the backend must be
-    installed separately with ``pip install qiskit-aer``.
+    noise. It is available as :ref:`"qiskit.aer" <aer device page>`.
 

doc/devices/remote.rst

@@ -4,17 +4,117 @@ The Remote device
 The ``'qiskit.remote'`` device is a generic adapter to use any Qiskit backend as interface
 for a PennyLane device.
 
-This device is useful when retrieving backends from providers with complex search options in
-their ``get_backend()`` method, or for setting options on a backend prior to wrapping it as
-PennyLane device.
+To access IBM backends, we recommend using `Qiskit Runtime <https://docs.quantum.ibm.com/api/migration-guides/qiskit-runtime-from-ibm-provider>`_.
 
 .. code-block:: python
 
-    import pennylane as qml
+    from qiskit_ibm_runtime import QiskitRuntimeService
 
-    def configured_backend():
-        backend = SomeProvider.get_backend(...)
-	backend.options.update_options(...)
-	return backend
+    QiskitRuntimeService.save_account(channel="ibm_quantum", token="<YOUR_IBMQ_TOKEN>")
 
-    dev = qml.device('qiskit.remote', wires=2, backend=configured_backend())
+    # To access saved credentials for the IBM quantum channel and select an instance
+    service = QiskitRuntimeService(channel="ibm_quantum", instance="my_hub/my_group/my_project")
+    backend = service.least_busy(operational=True, simulator=False, min_num_qubits=<num_qubits>)
+
+    dev = qml.device('qiskit.remote', wires=<num_qubits>, backend=backend)
+
+
+.. note:: 
+
+    Certain third-party backends may be using the deprecated ``Provider`` interface, in which case
+    you can get the backend instance from providers with complex search options using their 
+    ``get_backend()`` method. For example:
+
+    .. code-block:: python
+
+        import pennylane as qml
+
+        def configured_backend():
+            backend = SomeProvider.get_backend(...)
+        backend.options.update_options(...) # Set backend options this way
+        return backend
+
+        dev = qml.device('qiskit.remote', wires=2, backend=configured_backend())
+
+After installing the plugin, this device can be used just like any other PennyLane device for defining and evaluating QNodes.
+For example, a simple quantum function that returns the expectation value of a measurement and depends on
+three classical input parameters can be decorated with ``qml.qnode`` as usual to construct a ``QNode``:
+
+.. code-block:: python
+
+    @qml.qnode(dev)
+    def circuit(x, y, z):
+        qml.RZ(z, wires=[0])
+        qml.RY(y, wires=[0])
+        qml.RX(x, wires=[0])
+        qml.CNOT(wires=[0, 1])
+        return qml.expval(qml.PauliZ(wires=1))
+
+You can then execute the above quantum circuit to get the expectation value of a Pauli operator.
+
+.. code-block:: python
+
+    circuit(0.2, 0.1, 0.3)
+
+The ``'qiskit.remote'`` device also supports the use of `local simulators <https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/fake_provider>`_ such as ``FakeManila``.
+
+.. code-block:: python
+
+    from qiskit_ibm_runtime.fake_provider import FakeManilaV2
+    backend = FakeManilaV2()
+
+    # You could use an Aer simulator instead by using the following code:
+    # from qiskit_aer import AerSimulator
+    # backend = AerSimulator()
+
+    dev = qml.device('qiskit.remote', wires=5, backend=backend)
+
+Device options
+~~~~~~~~~~~~~~
+
+The ``'qiskit.remote'`` device uses the `EstimatorV2 <https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/qiskit_ibm_runtime.EstimatorV2/>`_
+and the `SamplerV2 <https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/qiskit_ibm_runtime.SamplerV2>`_  runtime primitives to execute
+the measurements. To set options for `transpilation <https://docs.quantum.ibm.com/run/configure-runtime-compilation>`_
+or `runtime <https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/options>`_, simply pass the keyword arguments into the device.
+
+.. code-block:: python
+
+    dev = qml.device(
+        "qiskit.remote", 
+        wires=5, 
+        backend=backend, 
+        resilience_level=1, 
+        optimization_level=1, 
+        seed_transpiler=42
+    )
+    # to change options, re-initialize the device
+    dev = qml.device(
+        "qiskit.remote", 
+        wires=5, 
+        backend=backend, 
+        resilience_level=1, 
+        optimization_level=2, 
+        seed_transpiler=24
+    )
+
+This device is not compatible with analytic mode, so an error will be raised if ``shots=0`` or ``shots=None``.
+The default value of the shots argument is ``1024``. You can set the number of shots on device initialization using the 
+``shots`` keyword, or you can choose the number of shots on circuit execution.
+
+.. code-block:: python
+
+    dev = qml.device("qiskit.remote", wires=5, backend=backend, shots=4096)
+
+    @qml.qnode(dev)
+    def circuit(x, y, z):
+        qml.RZ(z, wires=[0])
+        qml.RY(y, wires=[0])
+        qml.RX(x, wires=[0])
+        qml.CNOT(wires=[0, 1])
+        return qml.expval(qml.PauliZ(wires=1))
+
+    # Runs with 4096 shots
+    circuit(0.2, 0.1, 0.3)
+
+    # Runs with 10000 shots
+    circuit(0.2, 0.1, 0.3, shots=10000)

doc/index.rst

@@ -8,7 +8,7 @@ PennyLane-Qiskit Plugin
   :end-before: header-end-inclusion-marker-do-not-remove
 
 
-Once the PennyLane-Qiskit plugin is installed, the the Qiskit devices
+Once the PennyLane-Qiskit plugin is installed, the Qiskit devices
 can be accessed straightaway in PennyLane, without the need to import new packages.
 
 Devices
@@ -48,17 +48,39 @@ For example, the ``'qiskit.aer'`` device with two wires is called like this:
 Backends
 ~~~~~~~~
 
-Qiskit devices have different **backends**, which define which actual simulator or hardware is used by the
-device. Different simulator backends are optimized for different types of circuits. A backend can be defined as
-follows:
+Qiskit devices have different **backends**, which define the actual simulator or hardware 
+used by the device. A backend instance should be initalized and passed to the device.
+
+Different simulator backends are optimized for different purposes. To change what backend is used, 
+a simulator backend can be defined as follows:
+
+.. code-block:: python
+
+    from qiskit_aer import UnitarySimulator
+
+    dev = qml.device('qiskit.aer', wires=<num_qubits>, backend=UnitarySimulator())
+
+.. note::
+
+    For ``'qiskit.aer'``, PennyLane chooses the ``aer_simulator`` as the default backend if no 
+    backend is specified. For more details on the ``aer_simulator``, including available backend 
+    options, see `Qiskit Aer Simulator documentation <https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerSimulator.html#qiskit_aer.AerSimulator.run>`_.
+
+To access a real device, we can use the ``'qiskit.remote'`` device. A real hardware backend can 
+be defined as follows:
 
 .. code-block:: python
 
-    dev = qml.device('qiskit.aer', wires=2, backend='unitary_simulator')
+    from qiskit_ibm_runtime import QiskitRuntimeService
+
+    QiskitRuntimeService.save_account(channel="ibm_quantum", token="<IQP_TOKEN>")
+
+    # To access saved credentials for the IBM quantum channel and select an instance
+    service = QiskitRuntimeService(channel="ibm_quantum", instance="my_hub/my_group/my_project")
+    backend = service.least_busy(operational=True, simulator=False, min_num_qubits=<num_qubits>)
 
-PennyLane chooses the ``aer_simulator`` as the default backend if no backend is specified.
-For more details on the ``aer_simulator``, including available backend options, see
-`Qiskit Aer Simulator documentation <https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerSimulator.html#qiskit_aer.AerSimulator.run>`_.
+    # passing a string in backend would result in an error
+    dev = qml.device('qiskit.remote', wires=<num_qubits>, backend=backend)
 
 Tutorials
 ~~~~~~~~~