update security scan and tests

Author: coruscating

.github/workflows/ci.yml

@@ -144,25 +144,25 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         pip install -e ".[dev]"
-        pip install safety bandit
+        pip install pip-audit bandit
 
-    - name: Run safety check for known vulnerabilities
+    - name: Run pip-audit to check for known vulnerabilities
       run: |
-        safety scan --output json > safety-report.json || true
-        safety scan --detailed-output
+        pip-audit --format=json > pip-audit-report.json || true
+        pip-audit -v
 
     - name: Run bandit security linter
       run: |
         bandit -r gadd/ -f json -o bandit-report.json || true
-        bandit -r gadd/ -ll
+        bandit -r gadd/
 
     - name: Upload security reports
       uses: actions/upload-artifact@v4
       if: always()
       with:
         name: security-reports
         path: |
-          safety-report.json
+          pip-audit-report.json
           bandit-report.json
 
   # Build Documentation

README.md

@@ -149,7 +149,7 @@ def custom_fidelity(circuit, result):
 best_strategy, result = gadd.train(
     sampler=sampler,
     training_circuit=circuit,
-    utility_function=custom_fidelity
+    utility_function=UtilityFactory.custom(custom_fidelity, "Custom Fidelity")
 )
 ```
 

gadd/__init__.py

@@ -8,7 +8,6 @@
     OneNormDistance,
     GHZUtility,
     UtilityFactory,
-    create_utility_function,
 )
 from .experiments import (
     create_bernstein_vazirani_circuit,
@@ -32,7 +31,6 @@
     "OneNormDistance",
     "GHZUtility",
     "UtilityFactory",
-    "create_utility_function",
     "create_bernstein_vazirani_circuit",
     "create_ghz_circuit",
     "run_bv_experiment",

gadd/experiments.py

@@ -7,7 +7,7 @@
 from qiskit_ibm_runtime import Sampler
 
 from .gadd import GADD
-from .utility_functions import create_utility_function
+from .utility_functions import UtilityFactory
 
 
 def create_bernstein_vazirani_circuit(bitstring: str) -> QuantumCircuit:
@@ -90,9 +90,7 @@ def run_bv_experiment(
     circuit = create_bernstein_vazirani_circuit(bitstring)
 
     # Create utility function
-    utility_function = create_utility_function(
-        circuit, utility_type="success_probability", target_state=bitstring
-    )
+    utility_function = UtilityFactory.success_probability(bitstring)
 
     # Standard sequences to compare
     comparison_seqs = kwargs.pop(
@@ -144,7 +142,7 @@ def run_ghz_experiment(
     circuit = create_ghz_circuit(n_qubits)
 
     # Create utility function
-    utility_function = create_utility_function(circuit, utility_type="ghz")
+    utility_function = UtilityFactory.ghz_state(n_qubits)
 
     # Standard sequences to compare
     comparison_seqs = kwargs.pop(

gadd/utility_functions.py

@@ -109,41 +109,6 @@ def verify_state(self, state: str, counts: Dict[str, float]) -> None:
             raise ValueError("Target state must be a binary string")
 
 
-def create_utility_function(
-    circuit: QuantumCircuit,
-    utility_type: str = "success_probability",
-    target_state: Optional[Union[str, int]] = None,
-    **kwargs,
-) -> UtilityFunction:
-    """
-    Create a utility function for a given circuit.
-
-    Args:
-        circuit: Quantum circuit to evaluate.
-        utility_type: Type of utility function ('success_probability', 'ghz', 'one_norm').
-        target_state: Target state for success probability (defaults to all-zero state).
-        **kwargs: Additional arguments for specific utility functions.
-
-    Returns:
-        UtilityFunction instance.
-    """
-    if utility_type == "success_probability":
-        if target_state is None:
-            target_state = "0" * circuit.num_qubits
-        return SuccessProbability(target_state)
-
-    elif utility_type == "ghz":
-        return GHZUtility(circuit.num_qubits)
-
-    elif utility_type == "one_norm":
-        if "ideal_distribution" not in kwargs:
-            raise ValueError("ideal_distribution required for one_norm utility")
-        return OneNormDistance(kwargs["ideal_distribution"])
-
-    else:
-        raise ValueError(f"Unknown utility type: {utility_type}")
-
-
 class SuccessProbability(UtilityFunction):
     """Utility function based on success probability of measuring a target state."""
 
@@ -270,7 +235,6 @@ def get_name(self) -> str:
         return self._name
 
 
-# Factory remains mostly the same but types are updated
 class UtilityFactory:
     """Factory class for creating common utility functions."""
 
@@ -291,7 +255,8 @@ def ghz_state(n_qubits: int) -> UtilityFunction:
 
     @staticmethod
     def custom(
-        function: Callable[[Dict[str, float]], float], name: str = "Custom Utility"
+        function: Callable[[Dict[str, float]], float],
+        name: str = "Custom Utility Function",
     ) -> UtilityFunction:
         """Create custom utility function."""
         return CustomUtility(function, name)

tests/test_group_operations.py

@@ -181,6 +181,23 @@ def test_inverse_uniqueness(self):
                 len(inverses), 1, f"Element {i} should have exactly one inverse"
             )
 
+    def test_invert_fallback_path(self):
+        """Test invert function when using multiplication search instead of inverse map."""
+        # Create a custom group without inverse_map to force the fallback path
+        custom_group = {
+            "elements": {"e": 0, "a": 1},
+            "names": {0: "e", 1: "a"},
+            "multiplication": [
+                [0, 1],  # e * e = e, e * a = a
+                [1, 0],  # a * e = a, a * a = e
+            ],
+            # Note: no inverse_map provided
+        }
+
+        # Test that it finds inverses correctly using multiplication
+        self.assertEqual(invert(0, custom_group), 0)  # e^-1 = e
+        self.assertEqual(invert(1, custom_group), 1)  # a^-1 = a
+
     def test_invert_custom_group_no_inverse(self):
         """Test that invert raises ValueError for element without inverse in custom group."""
         # Create a custom "group" that's not actually a group (element 2 has no inverse)
@@ -199,6 +216,20 @@ def test_invert_custom_group_no_inverse(self):
             invert(2, custom_group)
         self.assertIn("No inverse found for element 2", str(context.exception))
 
+    def test_complete_sequence_already_identity(self):
+        """Test complete_sequence_to_identity when sequence already multiplies to Ip."""
+        # Empty sequence is already identity, should return Ip
+        self.assertEqual(complete_sequence_to_identity([]), 0)
+
+        # Sequence that multiplies to Ip: [Xp, Xp] = Ip
+        self.assertEqual(complete_sequence_to_identity([2, 2]), 0)
+
+        # Another sequence that gives Ip: [Yp, Yp] = Ip
+        self.assertEqual(complete_sequence_to_identity([4, 4]), 0)
+
+        # Sequence that gives Im: [Xp, Xm] = Im, should return Im to get back to Ip
+        self.assertEqual(complete_sequence_to_identity([2, 3]), 1)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_utility_functions.py

@@ -3,11 +3,42 @@
 import unittest
 from qiskit.result import QuasiDistribution, Counts
 from gadd.utility_functions import (
+    normalize_counts,
     UtilityFactory,
+    SuccessProbability,
+    OneNormDistance,
+    GHZUtility,
+    CustomUtility,
 )
 
 
 class TestUtilityFunctions(unittest.TestCase):
+    """
+    Test the utility function class and helper functions.
+    """
+
+    def test_normalize_counts_edge_cases(self):
+        """Test normalize_counts with edge cases."""
+        # Test empty counts
+        with self.assertRaises(ValueError) as context:
+            normalize_counts({})
+        self.assertIn("Empty counts", str(context.exception))
+
+        # Test zero total counts
+        with self.assertRaises(ValueError) as context:
+            normalize_counts({"00": 0, "11": 0})
+        self.assertIn(
+            "Total counts/probabilities must be positive", str(context.exception)
+        )
+
+        # Test integer keys with different bit lengths
+        counts = {0: 100, 15: 200, 7: 300}  # 0b0, 0b1111, 0b111
+        normalized = normalize_counts(counts)
+        self.assertIn("0000", normalized)  # Should pad to 4 bits (max needed)
+        self.assertIn("1111", normalized)
+        self.assertIn("0111", normalized)
+        self.assertAlmostEqual(sum(normalized.values()), 1.0)
+
     def test_success_probability(self):
         """Test success probability utility function."""
         utility = UtilityFactory.success_probability("00")
@@ -61,6 +92,97 @@ def custom_func(counts):
         self.assertAlmostEqual(utility.compute(counts), 0.75)
         self.assertEqual(utility.get_name(), "Test Utility")
 
+    def test_verify_state(self):
+        """Test verify_state method."""
+        utility = SuccessProbability("00")
+
+        # Test valid state
+        counts = {"00": 0.5, "11": 0.5}
+        utility.verify_state("00", counts)  # Should not raise
+
+        # Test mismatched length
+        with self.assertRaises(ValueError) as context:
+            utility.verify_state("000", counts)
+        self.assertIn("length", str(context.exception))
+
+        # Test non-binary string
+        with self.assertRaises(ValueError) as context:
+            utility.verify_state("0x", counts)
+        self.assertIn("binary string", str(context.exception))
+
+        # Test empty counts
+        with self.assertRaises(ValueError) as context:
+            utility.verify_state("00", {})
+        self.assertIn("Empty counts", str(context.exception))
+
+    def test_success_probability_integer_target(self):
+        """Test SuccessProbability with integer target state."""
+        # Test with integer target
+        utility = SuccessProbability(3)  # Binary: 11
+        counts = {"00": 0.25, "01": 0.25, "10": 0.25, "11": 0.25}
+        self.assertAlmostEqual(utility.compute(counts), 0.25)
+
+        # Test that it pads correctly
+        utility2 = SuccessProbability(1)  # Binary: 1
+        counts2 = {"000": 0.5, "001": 0.5}
+        self.assertAlmostEqual(utility2.compute(counts2), 0.5)
+
+    def test_success_probability_invalid_target(self):
+        """Test SuccessProbability with invalid target."""
+        with self.assertRaises(ValueError) as context:
+            SuccessProbability("0a1")
+        self.assertIn("binary string", str(context.exception))
+
+    def test_one_norm_dimension_mismatch(self):
+        """Test OneNormDistance with mismatched dimensions."""
+        utility = OneNormDistance({"00": 0.5, "11": 0.5})
+
+        # Test with different length states
+        counts = {"000": 0.5, "111": 0.5}
+        with self.assertRaises(ValueError) as context:
+            utility.compute(counts)
+        self.assertIn("dimensions don't match", str(context.exception))
+
+    def test_ghz_utility_invalid_qubits(self):
+        """Test GHZUtility with invalid qubit number."""
+        with self.assertRaises(ValueError) as context:
+            GHZUtility(0)
+        self.assertIn("positive", str(context.exception))
+
+        with self.assertRaises(ValueError) as context:
+            GHZUtility(-1)
+        self.assertIn("positive", str(context.exception))
+
+    def test_counts_type_variations(self):
+        """Test various count input types."""
+        utility = SuccessProbability("00")
+
+        # Test with Counts object (mock it since we don't want to import from qiskit.result)
+        class MockCounts(dict):
+            pass
+
+        mock_counts = MockCounts({"00": 800, "01": 200})
+        result = utility.compute(mock_counts)
+        self.assertAlmostEqual(result, 0.8)
+
+    def test_all_utility_names(self):
+        """Test get_name methods for all utility types."""
+        # SuccessProbability
+        util1 = SuccessProbability("101")
+        self.assertEqual(util1.get_name(), "Success Probability (|101⟩)")
+
+        # OneNormDistance
+        util2 = OneNormDistance({"00": 1.0})
+        self.assertEqual(util2.get_name(), "1-Norm Distance")
+
+        # GHZUtility
+        util3 = GHZUtility(5)
+        self.assertEqual(util3.get_name(), "GHZ State Fidelity")
+
+        # CustomUtility with custom name
+        util4 = CustomUtility(lambda x: 0.5, "My Custom Utility")
+        self.assertEqual(util4.get_name(), "My Custom Utility")
+
 
 if __name__ == "__main__":
     unittest.main()