Native mid-circuit measurements support composite measurements, etc. (phase 2)

.github/workflows/interface-unit-tests.yml

@@ -81,20 +81,20 @@ jobs:
             cat >matrix_max_parallel.json <<-EOF
           {
             "default": 1,
-            "tf-tests": 3,
-            "core-tests": 3,
+            "core-tests": 5,
+            "gradients-tests": 2,
             "jax-tests": 5,
-            "gradients-tests": 2
+            "tf-tests": 3
           }
           EOF
           else
             cat >matrix_max_parallel.json <<-EOF
           {
             "default": 1,
-            "torch-tests": 2,
-            "tf-tests": 6,
+            "core-tests": 5,
             "jax-tests": 10,
-            "core-tests": 3
+            "tf-tests": 6,
+            "torch-tests": 2
           }
           EOF
           fi
@@ -264,9 +264,7 @@ jobs:
            || fromJSON(needs.setup-ci-load.outputs.matrix-max-parallel).default
          }}
       matrix:
-        group:
-          - '1'
-          - '2'
+        group: [1, 2, 3, 4, 5]
         python-version: >-
           ${{
             fromJSON(needs.setup-ci-load.outputs.python-version).core-tests
@@ -286,7 +284,7 @@ jobs:
       install_pennylane_lightning_master: true
       pytest_coverage_flags: ${{ inputs.pytest_coverage_flags }}
       pytest_markers: core and not qcut and not finite-diff and not param-shift
-      pytest_additional_args: --splits 2 --group ${{ matrix.group }}
+      pytest_additional_args: --splits 5 --group ${{ matrix.group }} --durations-path='.github/workflows/core_tests_durations.json'
       additional_pip_packages: pytest-split
       requirements_file: ${{ strategy.job-index == 0 && 'core.txt' || '' }}
 

doc/releases/changelog-dev.md

@@ -118,9 +118,9 @@
   ```pycon
   >>> circuit()
   array([[0, 1, 1, 0, 0],
-         [1, 0, 1, 1, 1],
-         [0, 0, 0, 1, 0],
-         [1, 0, 0, 1, 1]])
+        [1, 0, 1, 1, 1],
+        [0, 0, 0, 1, 0],
+        [1, 0, 0, 1, 1]])
   ```
 
 * A function called `apply_operation` has been added to the new `qutrit_mixed` module found in `qml.devices` that applies operations to device-compatible states.
@@ -146,7 +146,7 @@
 * PennyLane can now use lightning provided VJPs by selecting `device_vjp=True` on the QNode.
   [(#4914)](https://github.com/PennyLaneAI/pennylane/pull/4914)
 
-* Remove queuing (`AnnotatedQueue`) from `qml.cut_circuit` and `qml.cut_circuit_mc` to improve performance 
+* Remove queuing (`AnnotatedQueue`) from `qml.cut_circuit` and `qml.cut_circuit_mc` to improve performance
   for large workflows.
   [(#5108)](https://github.com/PennyLaneAI/pennylane/pull/5108)
 
@@ -156,27 +156,35 @@
 <h4>Community contributions 🥳</h4>
 
 * `parity_transform` is added for parity mapping of a fermionic Hamiltonian.
-   [(#4928)](https://github.com/PennyLaneAI/pennylane/pull/4928)
-   It is now possible to transform a fermionic Hamiltonian to a qubit Hamiltonian with parity mapping.
+  [(#4928)](https://github.com/PennyLaneAI/pennylane/pull/4928)
+  It is now possible to transform a fermionic Hamiltonian to a qubit Hamiltonian with parity mapping.
 
-   ```python
-   import pennylane as qml
-   fermi_ham = qml.fermi.FermiWord({(0, 0) : '+', (1, 1) : '-'})
+  ```python
+  import pennylane as qml
+  fermi_ham = qml.fermi.FermiWord({(0, 0) : '+', (1, 1) : '-'})
+
+  qubit_ham = qml.fermi.parity_transform(fermi_ham, n=6)
+  ```
+
+  ```pycon
+  >>> print(qubit_ham)
+  (-0.25j*(PauliY(wires=[0]))) + ((-0.25+0j)*(PauliX(wires=[0]) @ PauliZ(wires=[1]))) +
+  ((0.25+0j)*(PauliX(wires=[0]))) + (0.25j*(PauliY(wires=[0]) @ PauliZ(wires=[1])))
+  ```
 
-   qubit_ham = qml.fermi.parity_transform(fermi_ham, n=6)
-   ```
+<h3>Improvements 🛠</h3>
 
-   ```pycon
-   >>> print(qubit_ham)
-   (-0.25j*(PauliY(wires=[0]))) + ((-0.25+0j)*(PauliX(wires=[0]) @ PauliZ(wires=[1]))) +
-   ((0.25+0j)*(PauliX(wires=[0]))) + (0.25j*(PauliY(wires=[0]) @ PauliZ(wires=[1])))
-   ```
+* The `default.qubit` device now supports mid-circuit measurements without using the deferred measurement
+  principle when using finite shots. The native execution mode comprises all features supported with `qml.defer_measurements`, including
+  classical control, collecting statistics, and post-selection. This PR notably introduces support for
+  post-selection, measurement value lists, and composite measurements.
+  [(#5120)](https://github.com/PennyLaneAI/pennylane/pull/5120)
 
 * The transform `split_non_commuting` now accepts measurements of type `probs`, `sample` and `counts` which accept both wires and observables.
   [(#4972)](https://github.com/PennyLaneAI/pennylane/pull/4972)
 
 * Improve efficiency of matrix calculation when operator is symmetric over wires
-   [(#3601)](https://github.com/PennyLaneAI/pennylane/pull/3601)
+  [(#3601)](https://github.com/PennyLaneAI/pennylane/pull/3601)
 
 * The module `pennylane/math/quantum.py` has now support for the min-entropy.
   [(#3959)](https://github.com/PennyLaneAI/pennylane/pull/3959/)
@@ -342,13 +350,14 @@
   (with potentially negative eigenvalues) has been implemented.
   [(#5048)](https://github.com/PennyLaneAI/pennylane/pull/5048)
 
-* Controlled operators with a custom controlled version decomposes like how their
-  controlled counterpart decomposes, as opposed to decomposing into their controlled version.   
+* Controlled operators with a custom controlled version decomposes like how their controlled
+  counterpart decomposes, as opposed to decomposing into their controlled version.
   [(#5069)](https://github.com/PennyLaneAI/pennylane/pull/5069)
   [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/)
-  
+
   For example:
-  ```
+
+  ```pycon
   >>> qml.ctrl(qml.RX(0.123, wires=1), control=0).decomposition()
   [
     RZ(1.5707963267948966, wires=[1]),
@@ -486,16 +495,16 @@
 * `PauliSentence.wires` no longer imposes a false order.
   [(#5041)](https://github.com/PennyLaneAI/pennylane/pull/5041)
 
-* `qml.qchem.import_state` now applies the chemist-to-physicist 
+* `qml.qchem.import_state` now applies the chemist-to-physicist
   sign convention when initializing a PennyLane state vector from
-  classically pre-computed wavefunctions. That is, it interleaves 
+  classically pre-computed wavefunctions. That is, it interleaves
   spin-up/spin-down operators for the same spatial orbital index,
-  as standard in PennyLane (instead of commuting all spin-up 
-  operators to the left, as is standard in quantum chemistry). 
+  as standard in PennyLane (instead of commuting all spin-up
+  operators to the left, as is standard in quantum chemistry).
   [(#5114)](https://github.com/PennyLaneAI/pennylane/pull/5114)
 
 * Multi-wire controlled `CNOT` and `PhaseShift` can now be decomposed correctly.
-  [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/) 
+  [(#5125)](https://github.com/PennyLaneAI/pennylane/pull/5125/)
   [(#5148)](https://github.com/PennyLaneAI/pennylane/pull/5148)
 
 * `draw_mpl` no longer raises an error when drawing a circuit containing an adjoint of a controlled operation.

pennylane/devices/qubit/apply_operation.py

@@ -231,7 +231,7 @@ def apply_conditional(
     Returns:
         ndarray: output state
     """
-    if mid_measurements[op.meas_val.measurements[0]]:
+    if op.meas_val.concretize(mid_measurements):
         return apply_operation(
             op.then_op,
             state,
@@ -260,17 +260,20 @@ def apply_mid_measure(
     """
     if is_state_batched:
         raise ValueError("MidMeasureMP cannot be applied to batched states.")
+    if not np.allclose(np.linalg.norm(state), 1.0):
+        mid_measurements[op] = 0
+        return np.zeros_like(state)
     wire = op.wires
     probs = qml.devices.qubit.measure(qml.probs(wire), state)
     sample = np.random.binomial(1, probs[1])
     mid_measurements[op] = sample
+    if op.postselect is not None and sample != op.postselect:
+        return np.zeros_like(state)
     axis = wire.toarray()[0]
     slices = [slice(None)] * qml.math.ndim(state)
     slices[axis] = int(not sample)
     state[tuple(slices)] = 0.0
     state_norm = np.linalg.norm(state)
-    if state_norm < 1.0e-15:
-        raise ValueError("Cannot normalize projected state.")
     state = state / state_norm
     if op.reset and sample == 1:
         state = apply_operation(