add sampling for qubit_mixed module

doc/releases/changelog-dev.md

@@ -114,6 +114,34 @@ added `binary_mapping()` function to map `BoseWord` and `BoseSentence` to qubit
 * Added submodule `devices.qubit_mixed.sampling` as a necessary step for the new API, featuring functions `sample_state`, `measure_with_samples` and `sample_probs` for sampling qubits in mixed-state devices.
   [(#6639)](https://github.com/PennyLaneAI/pennylane/pull/6639)
 
+* Support is added for `if`/`else` statements and `for` and `while` loops in circuits executed with `qml.capture.enabled`, via `autograph`
+  [(#6406)](https://github.com/PennyLaneAI/pennylane/pull/6406)
+  [(#6413)](https://github.com/PennyLaneAI/pennylane/pull/6413)
+  [(#6426)](https://github.com/PennyLaneAI/pennylane/pull/6426)
+
+* Added `christiansen_mapping()` function to map `BoseWord` and `BoseSentence` to qubit operators, using christiansen mapping.
+  [(#6623)](https://github.com/PennyLaneAI/pennylane/pull/6623)
+
+* The `qml.qchem.factorize` function now supports new methods for double factorization:
+  Cholesky decomposition (`cholesky=True`) and compressed double factorization (`compressed=True`).
+  [(#6573)](https://github.com/PennyLaneAI/pennylane/pull/6573)
+  [(#6611)](https://github.com/PennyLaneAI/pennylane/pull/6611)
+
+* Added `qml.qchem.symmetry_shift` function to perform the
+  [block-invariant symmetry shift](https://arxiv.org/pdf/2304.13772) on the electronic integrals.
+  [(#6574)](https://github.com/PennyLaneAI/pennylane/pull/6574)
+
+* Added submodule for calculating vibrational Hamiltonians
+  * Implemented helper functions for geometry optimization, harmonic analysis,
+    and normal-mode localization.
+    [(#6453)](https://github.com/PennyLaneAI/pennylane/pull/6453)
+  * Implemented helper functions for calculating one-mode PES, two-mode PES, and
+    three-mode PES.
+    [(#6616)](https://github.com/PennyLaneAI/pennylane/pull/6616)
+  * Implemented wrapper function for vibrational Hamiltonian calculation and dataclass
+    for storing the data.
+    [(#6652)](https://github.com/PennyLaneAI/pennylane/pull/6652)
+
 <h3>Improvements 🛠</h3>
 
 * Raises a comprehensive error when using `qml.fourier.qnode_spectrum` with standard numpy

pennylane/devices/qubit_mixed/measure.py

@@ -87,7 +87,7 @@ def calculate_reduced_density_matrix(
         state (TensorLike): state to apply the measurement to.
         is_state_batched (bool): whether the state is batched or not.
         readout_errors (List[Callable]): List of channels to apply to each wire being measured
-        to simulate readout errors. These are not applied on this type of measurement.
+            to simulate readout errors. These are not applied on this type of measurement.
 
     Returns:
         TensorLike: state or reduced density matrix.

pennylane/devices/qubit_mixed/sampling.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """
-Code relevant for sampling a qubit mixed state.
+Submodule for sampling a qubit mixed state.
 """
 # pylint: disable=too-many-positional-arguments, too-many-arguments
 import functools
@@ -75,14 +75,6 @@ def _process_samples(
     return mp.eigvals()[indices]
 
 
-def _process_counts_samples(processed_sample, mp_has_obs):
-    """Processes a set of samples and counts the results."""
-    observables, counts = math.unique(processed_sample, return_counts=True, axis=0)
-    if not mp_has_obs:
-        observables = ["".join(observable.astype("str")) for observable in observables]
-    return dict(zip(observables, counts))
-
-
 def _process_expval_samples(processed_sample):
     """Processes a set of samples and returns the expectation value of an observable."""
     eigvals, counts = math.unique(processed_sample, return_counts=True)
@@ -113,7 +105,7 @@ def _measure_with_samples_diagonalizing_gates(
 
     Args:
         mp (~.measurements.SampleMeasurement): The sample measurement to perform
-        state (np.ndarray[complex]): The state vector to sample from
+        state (TensorLike): The state vector to sample from
         shots (~.measurements.Shots): The number of samples to take
         is_state_batched (bool): whether the state is batched or not
         rng (Union[None, int, array_like[int], SeedSequence, BitGenerator, Generator]): A
@@ -133,12 +125,12 @@ def _measure_with_samples_diagonalizing_gates(
     total_indices = _get_num_wires(state, is_state_batched)
     wires = qml.wires.Wires(range(total_indices))
 
-    def _process_single_shot(samples):
+    def _process_single_shot_copy(samples):
         samples_processed = _process_samples(mp, samples, wires)
         if isinstance(mp, SampleMP):
             return math.squeeze(samples_processed)
         if isinstance(mp, CountsMP):
-            process_func = functools.partial(_process_counts_samples, mp_has_obs=mp.obs is not None)
+            process_func = functools.partial(mp.process_samples, wire_order=wires)
         elif isinstance(mp, ExpectationMP):
             process_func = _process_expval_samples
         elif isinstance(mp, VarianceMP):
@@ -169,7 +161,7 @@ def _process_single_shot(samples):
                 prng_key=prng_key,
                 readout_errors=readout_errors,
             )
-            processed_samples.append(_process_single_shot(samples))
+            processed_samples.append(_process_single_shot_copy(samples))
 
         return tuple(processed_samples)
 
@@ -183,7 +175,7 @@ def _process_single_shot(samples):
         readout_errors=readout_errors,
     )
 
-    return _process_single_shot(samples)
+    return _process_single_shot_copy(samples)
 
 
 def _measure_sum_with_samples(

tests/devices/qubit_mixed/test_qubit_mixed_sampling.py

@@ -143,7 +143,7 @@ def test_entangled_states(self, state_vector, expected_ratio):
             ratio, expected_ratio, atol=APPROX_ATOL
         ), f"Ratio {ratio} deviates from expected {expected_ratio}"
 
-    @pytest.mark.parametrize("num_shots", [10, 100, 1000])
+    @pytest.mark.parametrize("num_shots", [100, 1000])
     @pytest.mark.parametrize("seed", [42, 123, 987])
     def test_reproducibility(self, num_shots, seed, two_qubit_pure_state):
         """Test reproducibility with different shots and seeds."""
@@ -153,7 +153,7 @@ def test_reproducibility(self, num_shots, seed, two_qubit_pure_state):
         samples2 = sample_state(two_qubit_pure_state, num_shots, rng=rng2)
         assert np.array_equal(samples1, samples2), "Samples with the same seed are not equal"
 
-    @pytest.mark.parametrize("num_shots", [10, 100, 1000])
+    @pytest.mark.parametrize("num_shots", [100, 1000])
     @pytest.mark.parametrize("seed1, seed2", [(42, 43), (123, 124), (987, 988)])
     def test_different_seeds_produce_different_samples(
         self, num_shots, seed1, seed2, two_qubit_pure_state
@@ -182,10 +182,10 @@ def test_measure_with_samples_not_implemented_error(self):
         class CustomSampleMeasurement(SampleMeasurement):
             """A custom measurement process for testing."""
 
-            def process_counts(self, counts):
+            def process_counts(self, counts, wire_order=None):
                 return counts
 
-            def process_samples(self, samples, wire_orders=None):
+            def process_samples(self, samples, wire_order=None, shot_range=None, bin_size=None):
                 return samples
 
         # Prepare a simple state
@@ -200,7 +200,7 @@ def process_samples(self, samples, wire_orders=None):
 class TestMeasurements:
     """Test different measurement types"""
 
-    @pytest.mark.parametrize("num_shots", [10, 100, 1000])
+    @pytest.mark.parametrize("num_shots", [100, 1000])
     @pytest.mark.parametrize("wires", [(0,), (1,), (0, 1)])
     def test_sample_measurement(self, num_shots, wires, two_qubit_pure_state):
         """Test sample measurements with different shots and wire configurations."""
@@ -231,6 +231,30 @@ def test_counts_measurement(self, num_shots, two_qubit_pure_state):
             valid_states
         ), f"Invalid states in counts: {result.keys()}"
 
+    @pytest.mark.parametrize("num_shots", [100, 500])
+    def test_counts_measurement_all_outcomes(self, num_shots, two_qubit_pure_state):
+        """Test counts measurement with all_outcomes=True."""
+        shots = Shots(num_shots)
+        result = measure_with_samples(qml.counts(all_outcomes=True), two_qubit_pure_state, shots)
+
+        assert isinstance(result, dict), "Result is not a dictionary"
+        total_counts = sum(result.values())
+        assert (
+            total_counts == num_shots
+        ), f"Total counts {total_counts} do not match shots {num_shots}"
+
+        # Check that all possible 2-qubit states are present in the keys
+        all_possible_states = {"00", "01", "10", "11"}
+        assert (
+            set(result.keys()) == all_possible_states
+        ), f"Missing states in counts: {all_possible_states - set(result.keys())}"
+
+        # Check that only '01', '10', '11' have non-zero counts (based on two_qubit_pure_state fixture)
+        assert result["00"] == 0, "State '00' should have zero counts"
+        assert (
+            sum(result[state] > 0 for state in ["01", "10", "11"]) == 3
+        ), "Expected non-zero counts for '01', '10', and '11'"
+
     @pytest.mark.parametrize(
         "observable",
         [
@@ -247,7 +271,7 @@ def test_observable_measurements(self, observable, measurement, two_qubit_pure_s
         shots = Shots(10000)
         result = measure_with_samples(measurement(observable), two_qubit_pure_state, shots)
         assert isinstance(result, (float, np.floating)), "Result is not a floating point number"
-        if measurement == qml.expval:
+        if measurement is qml.expval:
             assert -1 <= result <= 1, f"Expectation value {result} out of bounds"
         else:
             assert 0 <= result <= 1, f"Variance {result} out of bounds"
@@ -314,7 +338,7 @@ def test_measure_sum_with_samples_partitioned_shots(self):
 class TestBatchedOperations:
     """Test batched state handling"""
 
-    @pytest.mark.parametrize("num_shots", [10, 100])
+    @pytest.mark.parametrize("num_shots", [100, 500])
     @pytest.mark.parametrize("batch_size", [2, 3, 4])
     def test_batched_sampling(self, num_shots, batch_size):
         """Test sampling with different batch sizes."""