lint

Author: ciaranra

crates/pecos-qsim/src/pauli_prop.rs

@@ -40,7 +40,7 @@ pub type StdPauliProp = PauliProp<VecSet<usize>, usize>;
 /// - `zs`: Records qubits with Z Pauli operators
 ///
 /// Y operators are implicitly represented by qubits present in both sets since Y = iXZ.
-/// 
+///
 /// Optionally, the sign and phase can be tracked for full Pauli string representation.
 ///
 /// # Type Parameters
@@ -127,8 +127,8 @@ where
         PauliProp {
             xs: T::new(),
             zs: T::new(),
-            sign: Some(false),  // Start with +1
-            img: Some(0),       // Start with no imaginary component
+            sign: Some(false), // Start with +1
+            img: Some(0),      // Start with no imaginary component
             num_qubits: Some(num_qubits),
             _marker: PhantomData,
         }
@@ -263,33 +263,37 @@ where
     /// * `num_is` - Number of i factors to add
     pub fn flip_img(&mut self, num_is: usize) {
         if let Some(img) = self.img.as_mut() {
-            *img = (*img + num_is as u8) % 4;
-            
+            // Use modulo 4 on num_is first to ensure it fits in u8
+            // Safe to cast since modulo 4 guarantees result is 0-3
+            #[allow(clippy::cast_possible_truncation)]
+            let num_is_mod = (num_is % 4) as u8;
+            *img = (*img + num_is_mod) % 4;
+
             // If we've accumulated 2 or 3 i's, flip the sign
             let should_flip = *img == 2 || *img == 3;
-            
-            *img %= 2;  // Keep only 0 or 1 for the imaginary part
-            
+
+            *img %= 2; // Keep only 0 or 1 for the imaginary part
+
             if should_flip {
                 self.flip_sign();
             }
         }
     }
 
-    /// Adds Pauli operators from a BTreeMap representation.
+    /// Adds Pauli operators from a `BTreeMap` representation.
     ///
     /// The map should have keys "X", "Y", and "Z" with sets of qubit indices.
     /// This method properly handles operator composition with phase tracking if enabled.
     ///
     /// # Arguments
-    /// * `paulis` - BTreeMap with "X", "Y", "Z" keys mapping to sets of qubit indices
+    /// * `paulis` - `BTreeMap` with "X", "Y", "Z" keys mapping to sets of qubit indices
     ///
     /// # Example
     /// ```rust
     /// use std::collections::BTreeMap;
     /// use pecos_qsim::StdPauliProp;
     /// use pecos_core::{VecSet, Set};
-    /// 
+    ///
     /// let mut sim = StdPauliProp::with_sign_tracking(4);
     /// let mut paulis = BTreeMap::new();
     /// let mut x_set = VecSet::new();
@@ -298,7 +302,7 @@ where
     /// paulis.insert("X".to_string(), x_set);
     /// sim.add_paulis(&paulis);
     /// ```
-    pub fn add_paulis(&mut self, paulis: &BTreeMap<String, T>) 
+    pub fn add_paulis(&mut self, paulis: &BTreeMap<String, T>)
     where
         T: Clone,
         E: Copy,
@@ -308,9 +312,9 @@ where
             for &item in x_set.iter() {
                 let was_y = self.contains_y(item);
                 let was_z = self.contains_z(item) && !was_y;
-                
+
                 self.add_x(item);
-                
+
                 if self.sign.is_some() {
                     if was_y {
                         // Y·X = -iZ (applying X after Y)
@@ -329,9 +333,9 @@ where
             for &item in z_set.iter() {
                 let was_y = self.contains_y(item);
                 let was_x = self.contains_x(item) && !was_y;
-                
+
                 self.add_z(item);
-                
+
                 if self.sign.is_some() {
                     if was_x {
                         // X·Z = -iY (applying Z after X)
@@ -350,9 +354,9 @@ where
             for &item in y_set.iter() {
                 let was_x = self.contains_x(item) && !self.contains_z(item);
                 let was_z = self.contains_z(item) && !self.contains_x(item);
-                
+
                 self.add_y(item);
-                
+
                 if self.sign.is_some() {
                     if was_z {
                         // Z·Y = -iX (applying Y after Z)
@@ -379,21 +383,21 @@ where
                 count += 1;
             }
         }
-        
+
         // Count Z-only qubits
         for item in self.zs.iter() {
             if !self.xs.contains(item) {
                 count += 1;
             }
         }
-        
+
         // Count Y qubits (both X and Z)
         for item in self.xs.iter() {
             if self.zs.contains(item) {
                 count += 1;
             }
         }
-        
+
         count
     }
 
@@ -427,24 +431,24 @@ where
     /// A string like "+", "-", "+i", or "-i" depending on the phase
     pub fn sign_string(&self) -> String {
         match (self.sign, self.img) {
-            (Some(false), Some(0)) | (Some(false), None) => "+".to_string(),
-            (Some(true), Some(0)) | (Some(true), None) => "-".to_string(),
+            (Some(false), Some(0) | None) => "+".to_string(),
+            (Some(true), Some(0) | None) => "-".to_string(),
             (Some(false), Some(1)) => "+i".to_string(),
             (Some(true), Some(1)) => "-i".to_string(),
-            _ => "".to_string(),
+            _ => String::new(),
         }
     }
 
     /// Returns the operator string representation for sparse format.
     ///
     /// # Returns
-    /// A string like "X_0 Z_2 Y_3" representing non-identity operators
-    pub fn sparse_string(&self) -> String 
+    /// A string like "`X_0` `Z_2` `Y_3`" representing non-identity operators
+    pub fn sparse_string(&self) -> String
     where
         E: Copy,
     {
         let mut entries = Vec::new();
-        
+
         // Collect all qubit indices with operators
         for &item in self.xs.iter() {
             if self.contains_y(item) {
@@ -453,19 +457,20 @@ where
                 entries.push((item, 'X'));
             }
         }
-        
+
         for &item in self.zs.iter() {
             if !self.xs.contains(&item) {
                 entries.push((item, 'Z'));
             }
         }
-        
+
         if entries.is_empty() {
             "I".to_string()
         } else {
             // Format as sparse representation
-            entries.iter()
-                .map(|(idx, op)| format!("{}{:?}", op, idx))
+            entries
+                .iter()
+                .map(|(idx, op)| format!("{op}{idx:?}"))
                 .collect::<Vec<_>>()
                 .join(" ")
         }
@@ -474,8 +479,8 @@ where
     /// Returns the full Pauli string representation with sign and operators.
     ///
     /// # Returns
-    /// A string like "+X_0 Z_2" in sparse format
-    pub fn to_pauli_string(&self) -> String 
+    /// A string like "+`X_0` `Z_2`" in sparse format
+    pub fn to_pauli_string(&self) -> String
     where
         E: Copy,
     {
@@ -486,45 +491,54 @@ where
 // Specialized implementation for StdPauliProp (usize indices)
 impl StdPauliProp {
     /// Get all qubits with X operators (including those with Y)
+    #[must_use]
     pub fn get_x_qubits(&self) -> Vec<usize> {
         self.xs.iter().copied().collect()
     }
-    
+
     /// Get all qubits with Z operators (including those with Y)
+    #[must_use]
     pub fn get_z_qubits(&self) -> Vec<usize> {
         self.zs.iter().copied().collect()
     }
-    
+
     /// Get all qubits with only X operators (not Y)
+    #[must_use]
     pub fn get_x_only_qubits(&self) -> Vec<usize> {
-        self.xs.iter()
+        self.xs
+            .iter()
             .filter(|&q| !self.contains_z(*q))
             .copied()
             .collect()
     }
-    
+
     /// Get all qubits with only Z operators (not Y)
+    #[must_use]
     pub fn get_z_only_qubits(&self) -> Vec<usize> {
-        self.zs.iter()
+        self.zs
+            .iter()
             .filter(|&q| !self.contains_x(*q))
             .copied()
             .collect()
     }
-    
+
     /// Get all qubits with Y operators (both X and Z)
+    #[must_use]
     pub fn get_y_qubits(&self) -> Vec<usize> {
-        self.xs.iter()
+        self.xs
+            .iter()
             .filter(|&q| self.contains_z(*q))
             .copied()
             .collect()
     }
-    
+
     /// Returns the operator string as a dense representation.
     ///
     /// Requires `num_qubits` to be set.
     ///
     /// # Returns
     /// A string like "IXYZ" representing the Pauli operators on each qubit
+    #[must_use]
     pub fn dense_string(&self) -> String {
         if let Some(n) = self.num_qubits {
             let mut result = String::with_capacity(n);
@@ -544,11 +558,12 @@ impl StdPauliProp {
             self.sparse_string()
         }
     }
-    
+
     /// Returns the full dense Pauli string with sign.
     ///
     /// # Returns
     /// A string like "+IXYZ" or "-iXYZ"
+    #[must_use]
     pub fn to_dense_string(&self) -> String {
         format!("{}{}", self.sign_string(), self.dense_string())
     }
@@ -694,19 +709,19 @@ mod tests {
     #[test]
     fn test_sign_tracking() {
         let mut sim = StdPauliProp::with_sign_tracking(4);
-        
+
         // Initially should be +
         assert_eq!(sim.sign_string(), "+");
-        
+
         // Flip sign
         sim.flip_sign();
         assert_eq!(sim.sign_string(), "-");
-        
+
         // Add imaginary phase
         sim.flip_sign(); // Back to +
         sim.flip_img(1);
         assert_eq!(sim.sign_string(), "+i");
-        
+
         // Two i's should give -1
         sim.flip_img(1);
         assert_eq!(sim.sign_string(), "-");
@@ -715,22 +730,22 @@ mod tests {
     #[test]
     fn test_weight() {
         let mut sim = StdPauliProp::new();
-        
+
         // Empty should have weight 0
         assert_eq!(sim.weight(), 0);
-        
+
         // Add X on qubit 0
         sim.add_x(0);
         assert_eq!(sim.weight(), 1);
-        
+
         // Add Z on qubit 1
         sim.add_z(1);
         assert_eq!(sim.weight(), 2);
-        
+
         // Add Y on qubit 2 (both X and Z)
         sim.add_y(2);
         assert_eq!(sim.weight(), 3);
-        
+
         // Adding X to qubit with Z makes Y
         sim.add_x(1);
         assert_eq!(sim.weight(), 3); // Still 3 operators
@@ -739,35 +754,35 @@ mod tests {
     #[test]
     fn test_dense_string() {
         let mut sim = StdPauliProp::with_sign_tracking(4);
-        
+
         sim.add_x(0);
         sim.add_z(2);
         sim.add_y(3);
-        
+
         assert_eq!(sim.dense_string(), "XIZY");
         assert_eq!(sim.to_dense_string(), "+XIZY");
-        
+
         sim.flip_sign();
         assert_eq!(sim.to_dense_string(), "-XIZY");
     }
 
     #[test]
     fn test_add_paulis() {
         let mut sim = StdPauliProp::with_sign_tracking(4);
-        
+
         let mut paulis = BTreeMap::new();
         let mut x_set = VecSet::new();
         x_set.insert(0);
         x_set.insert(1);
-        
+
         let mut z_set = VecSet::new();
         z_set.insert(2);
-        
+
         paulis.insert("X".to_string(), x_set);
         paulis.insert("Z".to_string(), z_set);
-        
+
         sim.add_paulis(&paulis);
-        
+
         assert!(sim.contains_x(0));
         assert!(sim.contains_x(1));
         assert!(sim.contains_z(2));
@@ -777,18 +792,18 @@ mod tests {
     #[test]
     fn test_pauli_composition_with_phase() {
         let mut sim = StdPauliProp::with_sign_tracking(2);
-        
+
         // Start with X on qubit 0
         sim.add_x(0);
-        
+
         // Add Z to same qubit: X·Z = -iY (applying Z after X)
         let mut paulis = BTreeMap::new();
         let mut z_set = VecSet::new();
         z_set.insert(0);
         paulis.insert("Z".to_string(), z_set);
-        
+
         sim.add_paulis(&paulis);
-        
+
         // Should now have Y on qubit 0
         assert!(sim.contains_y(0));
         // Phase should be -i (X·Z = -iY)