41 visualization

examples/plot_data_structure.rs

@@ -0,0 +1,45 @@
+use std::collections::VecDeque;
+
+use bitvec::bitvec;
+use bitvec::prelude::Lsb0;
+use syn::data_structures::{CliffordTableau, PauliPolynomial, PauliString};
+use syn::ir::pauli_exponential::PauliExponential;
+
+fn main() {
+    // test tableaus
+    // Stab: ZZZ, -YIY, XIX
+    // Destab: -IXI, XXI, IYY
+    // qubit 1x: ZYI
+    // qubit 1z: IZZ
+    let pauli_1 = PauliString::from_text("ZYIIZZ");
+    // qubit 2x: ZIX
+    // qubit 2z: XII
+    let pauli_2 = PauliString::from_text("ZIXXII");
+    // qubit 3x: ZYY
+    // qubit 3z: IIZ
+    let pauli_3 = PauliString::from_text("ZYYIIZ");
+    let signs = bitvec![0, 1, 0, 1, 0, 0];
+    let my_tableaus = CliffordTableau::from_parts(vec![pauli_1, pauli_2, pauli_3], signs);
+    CliffordTableau::visualize_tableaus(&my_tableaus);
+
+    //test pauli polynomial
+
+    let ham = vec![("IXYZ", 0.3), ("XXII", 0.7), ("YYII", 0.12)];
+    let pp = PauliPolynomial::from_hamiltonian(ham);
+    pp.visualize_pauli_polynomial();
+
+    // visualize_pauli_exponential_simple(&pe);
+    let ham = vec![("IZZZ", 0.3)];
+    let pp = PauliPolynomial::from_hamiltonian(ham);
+    let ct = CliffordTableau::new(4);
+    let pe = PauliExponential::new(VecDeque::from([pp]), ct);
+    pe.visualize_pauli_exponential();
+
+    //visualize_pauli_exponential complex
+    let ham = vec![("IXYZ", 0.3), ("XXII", 0.7), ("YYII", 0.12)];
+
+    let pauli_polynomial = PauliPolynomial::from_hamiltonian(ham);
+    let clifford_tableau = CliffordTableau::new(4);
+    let complex_pe = PauliExponential::new(VecDeque::from([pauli_polynomial]), clifford_tableau);
+    complex_pe.visualize_pauli_exponential();
+}

src/data_structures/clifford_tableau.rs

@@ -41,6 +41,14 @@ impl CliffordTableau {
         self.size
     }
 
+    pub fn pauli_column(&self, i: usize) -> &PauliString {
+        &self.pauli_columns[i]
+    } //why does column does not work and I need a new getter method ?
+
+    pub fn signs(&self) -> &BitVec {
+        &self.signs
+    }
+
     pub(crate) fn x_signs(&self) -> BitVec {
         let n = self.size();
         self.signs[0..n].to_bitvec()
@@ -177,6 +185,49 @@ impl CliffordTableau {
             .collect::<Vec<_>>();
         self.pauli_columns = sorted_pauli_columns;
     }
+
+    pub fn visualize_tableaus(&self) {
+        println!("Clifford Tableau ({} qubits):", self.size());
+        print!("    ||");
+        for i in 0..self.size() {
+            print!(" X{} Z{}|", i + 1, i + 1);
+        }
+        println!();
+        print!("+/- ||");
+        for i in 0..self.signs().len() {
+            if self.signs().get(i).map(|b| *b) == Some(true) {
+                print!(" +");
+            } else {
+                print!(" -");
+            }
+            print!(" ");
+            if i % 2 != 0 {
+                print!("|");
+            }
+        }
+        println!();
+
+        for i in 0..self.size() {
+            print!("QB{} ||", i + 1);
+            let column = self.pauli_column(i).to_string();
+            let mut out = String::new();
+            let mut count = 0;
+            for ch in column.chars() {
+                if ch != ' ' {
+                    count += 1;
+                    out.push(ch);
+                    if count % 2 == 1 {
+                        out.push(' ');
+                    } else {
+                        out.push_str(" |");
+                    }
+                } else {
+                    out.push(' ');
+                }
+            }
+            println!(" {} ", out);
+        }
+    }
 }
 
 impl HasAdjoint for CliffordTableau {

src/data_structures/pauli_polynomial.rs

@@ -68,6 +68,33 @@ impl PauliPolynomial {
     pub fn angle(&self, i: usize) -> Angle {
         self.angles.read().unwrap()[i]
     }
+
+    pub fn visualize_pauli_polynomial(&self) {
+        println!("Pauli Polynomial size:{} ", self.size());
+        let angles = self.angles.read().unwrap();
+        let string_angles = angles
+            .iter()
+            .map(|x| format!("{:.3}", x)) //force 3 decimal place for easy formatting, is it reasonable?
+            .collect::<Vec<String>>()
+            .join(" | ");
+        println!("Angles | {} |", string_angles);
+        let chains = self.chains();
+        let mut index = 0;
+        for chain in chains {
+            print!("Qubit {}|", index);
+            let chain_str = chain.to_string();
+            let mut out = String::new();
+            for ch in chain_str.chars() {
+                out.push(ch);
+                if !ch.is_whitespace() {
+                    out.push_str("     |"); //bad, hardcoded spaces. Do we want variable length ?
+                }
+            }
+            println!(" {}", out);
+            index += 1;
+        }
+    } //visualize pauli polynomial is currently a method of the class, The formatting is
+      //hardcoded so it can be easily broken if input parameter changed.
 }
 
 impl PropagateClifford for PauliPolynomial {

src/ir/pauli_exponential.rs

@@ -27,6 +27,16 @@ impl PauliExponential {
             clifford_tableau,
         }
     }
+
+    pub fn visualize_pauli_exponential(&self) {
+        println!("Visualizing Pauli Exponential:");
+        // println!("Clifford Tableau:");
+        self.clifford_tableau.visualize_tableaus();
+        // println!("Pauli Polynomials:");
+        for polynomial in &self.pauli_polynomials {
+            polynomial.visualize_pauli_polynomial();
+        }
+    }
 }
 
 #[derive(Default)]