use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::errors::PauliGraphError;
use crate::{GateType, Pauli};
pub(crate) fn string_to_paulis(pstr: &str) -> Result<Vec<Pauli>, PauliGraphError> {
pstr.chars()
.map(|pauli| match pauli {
'I' => Ok(Pauli::I),
'X' => Ok(Pauli::X),
'Y' => Ok(Pauli::Y),
'Z' => Ok(Pauli::Z),
_ => Err(PauliGraphError::InvalidInputJson(format!(
"Invalid Pauli string: contains invalid character: {}",
pauli
))),
})
.collect()
}
fn paulis_to_string(paulis: &[Pauli]) -> String {
paulis
.iter()
.map(|p| match p {
Pauli::I => 'I',
Pauli::X => 'X',
Pauli::Y => 'Y',
Pauli::Z => 'Z',
})
.collect()
}
fn serialize_pauli_string<S>(v: &[Pauli], s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
s.serialize_str(&paulis_to_string(v))
}
fn serialize_pauli_string_bool_vec<S>(v: &Vec<(Vec<Pauli>, bool)>, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
use serde::ser::SerializeSeq;
let mut seq = s.serialize_seq(Some(v.len()))?;
for (paulis, sign_bit) in v {
seq.serialize_element(&(paulis_to_string(paulis), sign_bit))?;
}
seq.end()
}
fn deserialize_pauli_string<'de, D>(deserializer: D) -> Result<Vec<Pauli>, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
string_to_paulis(&s).map_err(serde::de::Error::custom)
}
fn deserialize_pauli_string_bool_vec<'de, D>(
deserializer: D,
) -> Result<Vec<(Vec<Pauli>, bool)>, D::Error>
where
D: Deserializer<'de>,
{
let items = Vec::<(String, bool)>::deserialize(deserializer)?;
items
.into_iter()
.map(|(s, sign_bit)| {
Ok((
string_to_paulis(&s).map_err(serde::de::Error::custom)?,
sign_bit,
))
})
.collect()
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(tag = "type")]
pub enum Op {
Rotation {
data: RotationData,
},
Measure {
data: MeasureData,
},
Reset {
data: ResetData,
},
BlackBox {
data: BlackBoxData,
},
ConditionalBox {
data: ConditionalBoxData,
},
Tableau {
data: TableauData,
},
Gate {
data: GateData,
},
SetBoundary,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct RotationData {
#[serde(
serialize_with = "serialize_pauli_string",
deserialize_with = "deserialize_pauli_string"
)]
pub(crate) string: Vec<Pauli>,
angle: f64,
}
impl RotationData {
pub fn new(string: Vec<Pauli>, angle: f64) -> Self {
Self { string, angle }
}
pub fn get_string(&self) -> &Vec<Pauli> {
&self.string
}
pub fn get_angle(&self) -> f64 {
self.angle
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct MeasureData {
#[serde(
serialize_with = "serialize_pauli_string",
deserialize_with = "deserialize_pauli_string"
)]
pub(crate) string: Vec<Pauli>,
sign_bit: bool,
cbit: usize,
}
impl MeasureData {
pub fn new(string: Vec<Pauli>, sign_bit: bool, cbit: usize) -> Self {
Self {
string,
sign_bit,
cbit,
}
}
pub fn get_string(&self) -> &Vec<Pauli> {
&self.string
}
pub fn get_sign_bit(&self) -> bool {
self.sign_bit
}
pub fn get_cbit(&self) -> usize {
self.cbit
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ResetData {
#[serde(
serialize_with = "serialize_pauli_string",
deserialize_with = "deserialize_pauli_string"
)]
pub(crate) first_string: Vec<Pauli>,
#[serde(
serialize_with = "serialize_pauli_string",
deserialize_with = "deserialize_pauli_string"
)]
pub(crate) second_string: Vec<Pauli>,
first_sign_bit: bool,
second_sign_bit: bool,
}
impl ResetData {
pub fn new(
first_string: Vec<Pauli>,
second_string: Vec<Pauli>,
first_sign_bit: bool,
second_sign_bit: bool,
) -> Self {
Self {
first_string,
second_string,
first_sign_bit,
second_sign_bit,
}
}
pub fn get_first_string(&self) -> &Vec<Pauli> {
&self.first_string
}
pub fn get_second_string(&self) -> &Vec<Pauli> {
&self.second_string
}
pub fn get_first_sign_bit(&self) -> bool {
self.first_sign_bit
}
pub fn get_second_sign_bit(&self) -> bool {
self.second_sign_bit
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct BlackBoxData {
qubits: Vec<usize>,
content: String,
}
impl BlackBoxData {
pub fn new(qubits: Vec<usize>, content: String) -> Self {
Self { qubits, content }
}
pub fn get_qubits(&self) -> &Vec<usize> {
&self.qubits
}
pub fn get_content(&self) -> &String {
&self.content
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ConditionalBoxData {
conditional_bits: Vec<usize>,
conditional_values: Vec<bool>,
pub(crate) ops: Vec<Op>,
}
impl ConditionalBoxData {
pub fn new(ops: Vec<Op>, conditional_bits: Vec<usize>, conditional_values: Vec<bool>) -> Self {
Self {
conditional_bits,
conditional_values,
ops,
}
}
pub fn get_conditional_bits(&self) -> &Vec<usize> {
&self.conditional_bits
}
pub fn get_conditional_values(&self) -> &Vec<bool> {
&self.conditional_values
}
pub fn get_ops(&self) -> &Vec<Op> {
&self.ops
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct TableauData {
#[serde(
serialize_with = "serialize_pauli_string_bool_vec",
deserialize_with = "deserialize_pauli_string_bool_vec"
)]
pub(crate) z_images: Vec<(Vec<Pauli>, bool)>,
#[serde(
serialize_with = "serialize_pauli_string_bool_vec",
deserialize_with = "deserialize_pauli_string_bool_vec"
)]
pub(crate) x_images: Vec<(Vec<Pauli>, bool)>,
}
impl TableauData {
pub fn new(z_images: Vec<(Vec<Pauli>, bool)>, x_images: Vec<(Vec<Pauli>, bool)>) -> Self {
Self { z_images, x_images }
}
pub fn get_z_images(&self) -> &Vec<(Vec<Pauli>, bool)> {
&self.z_images
}
pub fn get_x_images(&self) -> &Vec<(Vec<Pauli>, bool)> {
&self.x_images
}
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct GateData {
gate_type: GateType,
params: Vec<f64>,
args: Vec<usize>,
data: Option<String>,
conditional_bits: Vec<usize>,
conditional_values: Vec<bool>,
}
impl GateData {
pub fn new(gate_type: GateType, args: Vec<usize>) -> Self {
Self {
gate_type,
params: vec![],
args,
data: None,
conditional_bits: vec![],
conditional_values: vec![],
}
}
pub fn with_params(mut self, params: Vec<f64>) -> Self {
self.params = params;
self
}
pub fn with_data(mut self, data: String) -> Self {
self.data = Some(data);
self
}
pub fn with_conditional(
mut self,
conditional_bits: Vec<usize>,
conditional_values: Vec<bool>,
) -> Self {
self.conditional_bits = conditional_bits;
self.conditional_values = conditional_values;
self
}
pub fn get_gate_type(&self) -> &GateType {
&self.gate_type
}
pub fn get_params(&self) -> &Vec<f64> {
&self.params
}
pub fn get_args(&self) -> &Vec<usize> {
&self.args
}
pub fn get_data(&self) -> &Option<String> {
&self.data
}
pub fn get_conditional_bits(&self) -> &Vec<usize> {
&self.conditional_bits
}
pub fn get_conditional_values(&self) -> &Vec<bool> {
&self.conditional_values
}
}