V0.23.0 notes

.pylintrc

@@ -15,7 +15,7 @@ ignored-modules=numpy,scipy,autograd,toml,appdir,autograd,autograd.numpy,autogra
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamically set). This supports can work
 # with qualified names.
-ignored-classes=numpy,scipy,autograd,toml,appdir,autograd,autograd.numpy,autograd.numpy.linalg,semantic_version,torch,tensorflow,tensorflow.contrib,tensorflow.contrib.eager,LazyLoader,networkx,networkx.dag,math,pennylane.numpy,pennylane.numpy.random,pennylane.numpy.linalg,pennylane.operation,retworkx
+ignored-classes=numpy,scipy,autograd,toml,appdir,autograd,autograd.numpy,autograd.numpy.linalg,semantic_version,torch,tensorflow,tensorflow.contrib,tensorflow.contrib.eager,LazyLoader,networkx,networkx.dag,math,pennylane.numpy,pennylane.numpy.random,pennylane.numpy.linalg,pennylane.operation,retworkx,kahypar
 
 [MESSAGES CONTROL]
 

doc/releases/changelog-0.22.2.md

@@ -1,6 +1,6 @@
 :orphan:
 
-# Release 0.22.2 (current release)
+# Release 0.22.2
 
 <h3>Bug fixes</h3>
 

pennylane/_version.py

@@ -16,4 +16,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.23.0-dev"
+__version__ = "0.23.0"

pennylane/interfaces/jax.py

@@ -52,9 +52,11 @@ def get_jax_interface_name(tapes):
 
             # Unwrap the observable from a MeasurementProcess
             op = op.obs if hasattr(op, "obs") else op
-            for param in op.data:
-                if qml.math.is_abstract(param):
-                    return "jax-jit"
+            if op is not None:
+                # Some MeasurementProcess objects have obs=None
+                for param in op.data:
+                    if qml.math.is_abstract(param):
+                        return "jax-jit"
 
     return "jax"
 

pennylane/transforms/optimization/pattern_matching.py

@@ -161,6 +161,8 @@ def circuit():
     3: ─├C─│───H─╰X─╰C─┤
     4: ─╰C─╰X──────────┤
 
+    .. seealso:: :func:`~.pattern_matching`
+
     **Reference:**
 
     [1] Iten, R., Moyard, R., Metger, T., Sutter, D. and Woerner, S., 2022.
@@ -273,6 +275,63 @@ def pattern_matching(circuit_dag, pattern_dag):
 
     Returns:
         list(Match): the list of maximal matches.
+
+    **Example**
+
+    First let's consider the following circuit
+
+    .. code-block:: python
+
+        def circuit():
+            qml.S(wires=0)
+            qml.PauliZ(wires=0)
+            qml.S(wires=1)
+            qml.CZ(wires=[0, 1])
+            qml.S(wires=1)
+            qml.S(wires=2)
+            qml.CZ(wires=[1, 2])
+            qml.S(wires=2)
+            return qml.expval(qml.PauliX(wires=0))
+
+    Assume that we want to find all maximal matches of a pattern containing a sequence of two :class:`~.S` gates and
+    a :class:`~.PauliZ` gate:
+
+    .. code-block:: python
+
+        def pattern():
+            qml.S(wires=0)
+            qml.S(wires=0)
+            qml.PauliZ(wires=0)
+
+
+    >>> circuit_dag = qml.commutation_dag(circuit)()
+    >>> pattern_dag = qml.commutation_dag(pattern)()
+    >>> all_max_matches = qml.pattern_matching(circuit_dag, pattern_dag)
+
+    The matches are accessible by looping through the list outputted by ``qml.pattern_matching``. This output is a list
+    of lists containing indices. Each list represents a match between a gate in the pattern with a gate in the circuit.
+    The first indices represent the gates in the pattern and the second indices provides indices for the gates in the
+    circuit (by order of appearance).
+
+    >>> for match_conf in all_max_matches:
+    ...     print(match_conf.match)
+    [[0, 0], [2, 1]]
+    [[0, 2], [1, 4]]
+    [[0, 4], [1, 2]]
+    [[0, 5], [1, 7]]
+    [[0, 7], [1, 5]]
+
+    The first match of this list corresponds to match the first gate (:class:`~.S`) in the pattern with the first gate
+    in the circuit and also the third gate in the pattern (:class:`~.PauliZ`) with the second circuit gate.
+
+    .. seealso:: :func:`~.pattern_matching_optimization`
+
+    **Reference:**
+
+    [1] Iten, R., Moyard, R., Metger, T., Sutter, D. and Woerner, S., 2022.
+    Exact and practical pattern matching for quantum circuit optimization.
+    `doi.org/10.1145/3498325 <https://dl.acm.org/doi/abs/10.1145/3498325>`_
+
     """
     # Match list
     match_list = []

pennylane/transforms/qcut.py

@@ -1255,6 +1255,39 @@ def fn(x):
         ...     fn
         ... )
         array(-4.)
+
+        Using the Monte Carlo approach of [Peng et. al](https://arxiv.org/abs/1904.00102), the
+        `cut_circuit_mc` transform also supports returning sample-based expectation values of
+        observables that are diagonal in the computational basis, as shown below for a `ZZ` measurement
+        on wires `0` and `2`:
+
+        .. code-block::
+
+            dev = qml.device("default.qubit", wires=2, shots=10000)
+
+            def observable(bitstring):
+                return (-1) ** np.sum(bitstring)
+
+            @qml.cut_circuit_mc(classical_processing_fn=observable)
+            @qml.qnode(dev)
+            def circuit(x):
+                qml.RX(0.89, wires=0)
+                qml.RY(0.5, wires=1)
+                qml.RX(1.3, wires=2)
+
+                qml.CNOT(wires=[0, 1])
+                qml.WireCut(wires=1)
+                qml.CNOT(wires=[1, 2])
+
+                qml.RX(x, wires=0)
+                qml.RY(0.7, wires=1)
+                qml.RX(2.3, wires=2)
+                return qml.sample(wires=[0, 2])
+
+        We can now approximate the expectation value of the observable using
+
+        >>> circuit(x)
+        tensor(-0.776, requires_grad=True)
     """
     # pylint: disable=unused-argument, too-many-arguments
 
@@ -3107,6 +3140,7 @@ def _is_valid_cut(
 
     correct_num_fragments = k <= num_fragments_requested
     best_candidate_yet = (key not in cut_candidates) or (len(cut_candidates[key]) > num_cuts)
+    # pylint: disable=no-member
     all_fragments_fit = all(
         len(graph_to_tape(f).wires) <= max_free_wires for j, f in enumerate(fragments)
     )

setup.py

@@ -28,41 +28,39 @@
     "semantic_version==2.6",
     "autoray",
     "cachetools",
-    "pennylane-lightning>=0.22",
+    "pennylane-lightning>=0.23",
 ]
 
 info = {
-    'name': 'PennyLane',
-    'version': version,
-    'maintainer': 'Xanadu Inc.',
-    'maintainer_email': 'software@xanadu.ai',
-    'url': 'https://github.com/XanaduAI/pennylane',
-    'license': 'Apache License 2.0',
-    'packages': find_packages(where="."),
-    'entry_points': {
+    "name": "PennyLane",
+    "version": version,
+    "maintainer": "Xanadu Inc.",
+    "maintainer_email": "software@xanadu.ai",
+    "url": "https://github.com/XanaduAI/pennylane",
+    "license": "Apache License 2.0",
+    "packages": find_packages(where="."),
+    "entry_points": {
         # TODO: rename entry point 'pennylane.plugins' to 'pennylane.devices'.
         # This requires a rename in the setup file of all devices, and is best done during another refactor
-        'pennylane.plugins': [
-            'default.qubit = pennylane.devices:DefaultQubit',
-            'default.gaussian = pennylane.devices:DefaultGaussian',
-            'default.qubit.tf = pennylane.devices.default_qubit_tf:DefaultQubitTF',
-            'default.qubit.torch = pennylane.devices.default_qubit_torch:DefaultQubitTorch',
-            'default.qubit.autograd = pennylane.devices.default_qubit_autograd:DefaultQubitAutograd',
-            'default.qubit.jax = pennylane.devices.default_qubit_jax:DefaultQubitJax',
-            'default.mixed = pennylane.devices.default_mixed:DefaultMixed'
-            ],
-        'console_scripts': [
-                'pl-device-test=pennylane.devices.tests:cli'
-            ]
-        },
-    'description': 'PennyLane is a Python quantum machine learning library by Xanadu Inc.',
-    'long_description': open('README.md').read(),
-    'long_description_content_type': "text/markdown",
-    'provides': ["pennylane"],
-    'install_requires': requirements,
-    'extras_require': {'kernels': ['cvxpy', 'cvxopt']},
-    'package_data': {'pennylane': ['devices/tests/pytest.ini']},
-    'include_package_data': True
+        "pennylane.plugins": [
+            "default.qubit = pennylane.devices:DefaultQubit",
+            "default.gaussian = pennylane.devices:DefaultGaussian",
+            "default.qubit.tf = pennylane.devices.default_qubit_tf:DefaultQubitTF",
+            "default.qubit.torch = pennylane.devices.default_qubit_torch:DefaultQubitTorch",
+            "default.qubit.autograd = pennylane.devices.default_qubit_autograd:DefaultQubitAutograd",
+            "default.qubit.jax = pennylane.devices.default_qubit_jax:DefaultQubitJax",
+            "default.mixed = pennylane.devices.default_mixed:DefaultMixed",
+        ],
+        "console_scripts": ["pl-device-test=pennylane.devices.tests:cli"],
+    },
+    "description": "PennyLane is a Python quantum machine learning library by Xanadu Inc.",
+    "long_description": open("README.md").read(),
+    "long_description_content_type": "text/markdown",
+    "provides": ["pennylane"],
+    "install_requires": requirements,
+    "extras_require": {"kernels": ["cvxpy", "cvxopt"]},
+    "package_data": {"pennylane": ["devices/tests/pytest.ini"]},
+    "include_package_data": True,
 }
 
 classifiers = [
@@ -76,13 +74,13 @@
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Programming Language :: Python",
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.7',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3 :: Only',
-    "Topic :: Scientific/Engineering :: Physics"
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Physics",
 ]
 
 setup(classifiers=classifiers, **(info))

tests/interfaces/test_jax_qnode.py

@@ -1343,6 +1343,24 @@ def circ(projector):
 
         assert jnp.allclose(circ(projector), 1)
 
+    @pytest.mark.filterwarnings(
+        "ignore:Requested adjoint differentiation to be computed with finite shots."
+    )
+    @pytest.mark.parametrize("shots", [10, 1000])
+    def test_probs_obs_none(self, dev_name, diff_method, mode, shots):
+        """Test that the jax device works with qml.probs, a MeasurementProcess
+        that has obs=None even when shots>0."""
+        dev = qml.device(dev_name, wires=2, shots=shots)
+
+        if diff_method == "backprop":
+            pytest.skip("Backpropagation is unsupported if shots > 0.")
+
+        @qml.qnode(dev, interface="jax", diff_method="parameter-shift")
+        def circuit():
+            return qml.probs(wires=0)
+
+        assert jnp.allclose(circuit(), jnp.array([1.0, 0.0]))
+
     @pytest.mark.xfail(
         reason="Non-trainable parameters are not being correctly unwrapped by the interface"
     )