address code review comments

Author: Jaybsoni

pennylane/estimator/compact_hamiltonian.py

@@ -15,7 +15,7 @@
 Contains classes used to compactly store the metadata of various Hamiltonians which are relevant for resource estimation.
 """
 import copy
-from collections import defaultdict
+from collections import Counter
 from dataclasses import dataclass
 
 
@@ -321,7 +321,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self._num_qubits = num_qubits
         self._one_norm = one_norm
 
-        (max_weight, num_pauli_words, pauli_dist, commuting_groups) = _validate_inputs(
+        (max_weight, num_pauli_words, pauli_dist, commuting_groups) = _preprocess_inputs(
             num_qubits, num_pauli_words, max_weight, pauli_dist, commuting_groups
         )
 
@@ -428,7 +428,7 @@ def _pauli_dist_from_commuting_groups(commuting_groups: tuple[dict]):
     return total_pauli_dist
 
 
-def _validate_inputs(
+def _preprocess_inputs(
     num_qubits: int,
     num_pauli_words: int | None,
     max_weight: int | None,

pennylane/estimator/templates/trotter.py

@@ -1930,6 +1930,16 @@ def __init__(
                 "Unsupported Hamiltonian representation for TrotterPauli."
                 f"This method works with PauliHamiltonian, {type(pauli_ham)} provided"
             )
+        if (not isinstance(num_steps, int)) or num_steps < 1:
+            raise ValueError(
+                f"`num_steps` is expected to be a positive integer greater than one, got {num_steps}"
+            )
+
+        if not (isinstance(order, int) and order > 0 and (order == 1 or order % 2 == 0)):
+            raise ValueError(
+                f"`order` is expected to be a positive integer and either one or a multiple of two; got {order}"
+            )
+
         self.num_steps = num_steps
         self.order = order
         self.pauli_ham = pauli_ham
@@ -2097,7 +2107,7 @@ def cost_pauli_group(pauli_dist: dict):
                 a commuting group of Pauli words.
 
         """
-return [
-    GateCount(PauliRot.resource_rep(pauli_word), count)
-    for pauli_word, count in pauli_dist.items()
-]
+        return [
+            GateCount(PauliRot.resource_rep(pauli_word), count)
+            for pauli_word, count in pauli_dist.items()
+        ]

tests/estimator/templates/test_estimator_trotter.py

@@ -808,6 +808,81 @@ def test_initialization(self, pauli_ham, num_steps, order, wires, expected_num_w
                 ValueError,
                 "Expected 5 wires, got 4",
             ),
+            (
+                qre.PauliHamiltonian(
+                    num_qubits=5,
+                    commuting_groups=(
+                        {"XX": 15, "X": 5},
+                        {"ZZ": 10},
+                        {"YY": 5, "X": 5},
+                    ),
+                ),
+                10,
+                3,
+                ["w1", "w2", "w3", "w4", "w5"],
+                ValueError,
+                "`order` is expected to be a positive integer and either one or a multiple of two",
+            ),
+            (
+                qre.PauliHamiltonian(
+                    num_qubits=5,
+                    commuting_groups=(
+                        {"XX": 15, "X": 5},
+                        {"ZZ": 10},
+                        {"YY": 5, "X": 5},
+                    ),
+                ),
+                10,
+                2.0,
+                ["w1", "w2", "w3", "w4", "w5"],
+                ValueError,
+                "`order` is expected to be a positive integer and either one or a multiple of two",
+            ),
+            (
+                qre.PauliHamiltonian(
+                    num_qubits=5,
+                    commuting_groups=(
+                        {"XX": 15, "X": 5},
+                        {"ZZ": 10},
+                        {"YY": 5, "X": 5},
+                    ),
+                ),
+                10,
+                -2,
+                ["w1", "w2", "w3", "w4", "w5"],
+                ValueError,
+                "`order` is expected to be a positive integer and either one or a multiple of two",
+            ),
+            (
+                qre.PauliHamiltonian(
+                    num_qubits=5,
+                    commuting_groups=(
+                        {"XX": 15, "X": 5},
+                        {"ZZ": 10},
+                        {"YY": 5, "X": 5},
+                    ),
+                ),
+                10.5,
+                4,
+                ["w1", "w2", "w3", "w4", "w5"],
+                ValueError,
+                "`num_steps` is expected to be a positive integer greater than one",
+            ),
+            (
+                qre.PauliHamiltonian(
+                    num_qubits=5,
+                    commuting_groups=(
+                        {"XX": 15, "X": 5},
+                        {"ZZ": 10},
+                        {"YY": 5, "X": 5},
+                    ),
+                ),
+                -5,
+                4,
+                ["w1", "w2", "w3", "w4", "w5"],
+                ValueError,
+                "`num_steps` is expected to be a positive integer greater than one",
+            ),
         ),
     )
     def test_init_raises_error_incompatible_inputs(