Struct PhenomenologicalRotatedCode 

pub struct PhenomenologicalRotatedCode {
    pub vertices: Vec<CodeVertex>,
    pub edges: Vec<CodeEdge>,
}

CSS surface code (the rotated one) with X-type stabilizers

Fields

vertices: Vec<CodeVertex>

vertices in the code

edges: Vec<CodeEdge>

nearest-neighbor edges in the decoding graph

Implementations

impl PhenomenologicalRotatedCode

pub fn new( d: VertexNum, noisy_measurements: VertexNum, p: f64, max_half_weight: Weight, ) -> Self

pub fn create_code(d: VertexNum, noisy_measurements: VertexNum) -> Self

Trait Implementations

impl Clone for PhenomenologicalRotatedCode

fn clone(&self) -> PhenomenologicalRotatedCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PhenomenologicalRotatedCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ExampleCode for PhenomenologicalRotatedCode

fn vertices_edges(&mut self) -> (&mut Vec<CodeVertex>, &mut Vec<CodeEdge>)

get mutable references to vertices and edges

fn immutable_vertices_edges(&self) -> (&Vec<CodeVertex>, &Vec<CodeEdge>)

fn vertex_num(&self) -> VertexNum

get the number of vertices

fn compute_weights(&mut self, max_half_weight: Weight)

generic method that automatically computes integer weights from probabilities, scales such that the maximum integer weight is 10000 and the minimum is 1

fn sanity_check(&self) -> Result<(), String>

sanity check to avoid duplicate edges that are hard to debug

fn set_probability(&mut self, p: f64)

set probability of all edges; user can set individual probabilities

fn set_erasure_probability(&mut self, pe: f64)

set erasure probability of all edges; user can set individual probabilities

fn fill_vertices(&mut self, vertex_num: VertexNum)

automatically create vertices given edges

fn get_positions(&self) -> Vec<VisualizePosition>

gather all positions of vertices

fn get_initializer(&self) -> SolverInitializer

generate standard interface to instantiate Fusion blossom solver

fn set_defect_vertices(&mut self, defect_vertices: &[VertexIndex])

set defect vertices (non-trivial measurement result in case of single round of measurement, or different result from the previous round in case of multiple rounds of measurement)

fn set_erasures(&mut self, erasures: &[EdgeIndex])

set erasure edges

fn set_syndrome(&mut self, syndrome_pattern: &SyndromePattern)

set syndrome

fn get_defect_vertices(&self) -> Vec<VertexIndex>

get current defect vertices

fn get_erasures(&self) -> Vec<EdgeIndex>

get current erasure edges

fn get_syndrome(&self) -> SyndromePattern

get current syndrome

fn generate_random_errors(&mut self, seed: u64) -> SyndromePattern

generate random errors based on the edge probabilities and a seed for pseudo number generator

fn generate_errors(&mut self, edge_indices: &[EdgeIndex]) -> SyndromePattern

fn clear_errors(&mut self)

fn is_virtual(&self, vertex_idx: usize) -> bool

fn is_defect(&self, vertex_idx: usize) -> bool

fn reorder_vertices(&mut self, sequential_vertices: &[VertexIndex])

reorder the vertices such that new vertices (the indices of the old order) is sequential