Struct Graph 

pub struct Graph { /* private fields */ }

Implementations

impl Graph

pub fn neighbor_at(&self, v: V, n: usize) -> V

Explicitly index neighbors of a vertex. Used for iteration.

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl GraphLike for Graph

fn new() -> Graph

Initialise a new empty graph

fn vindex(&self) -> V

Next fresh vertex index

fn num_vertices(&self) -> usize

Number of vertices

fn num_edges(&self) -> usize

Number of edges

fn vertices(&self) -> impl Iterator<Item = V>

Get iterator over all vertices

fn edges(&self) -> impl Iterator<Item = (V, V, EType)>

Get iterator over all edges

fn inputs(&self) -> &Vec<V>

List of boundary vertices which serve as inputs

fn inputs_mut(&mut self) -> &mut Vec<V>

Mutable list of boundary vertices which serve as inputs

fn set_inputs(&mut self, inputs: Vec<V>)

Set inputs for the graph

fn outputs(&self) -> &Vec<V>

List of boundary vertices which serve as outputs

fn set_outputs(&mut self, outputs: Vec<V>)

Set outputs for the graph

fn outputs_mut(&mut self) -> &mut Vec<V>

Mutable list of boundary vertices which serve as outputs

fn add_vertex(&mut self, ty: VType) -> V

Add a vertex with the given type

fn add_vertex_with_data(&mut self, d: VData) -> V

Add a vertex with the given VData struct

fn add_named_vertex_with_data(&mut self, v: V, d: VData) -> Result<(), &str>

Add a vertex with the given name and VData struct

fn remove_vertex(&mut self, v: V)

Remove a vertex from a graph

fn add_edge_with_type(&mut self, s: V, t: V, ety: EType)

Add an edge with the given type

fn remove_edge(&mut self, s: V, t: V)

Remove an edge from a graph

fn vertex_data(&self, v: V) -> &VData

Get the data associated to the given vertex

fn vertex_data_opt(&self, v: V) -> Option<&VData>

Get the data associated to the given vertex, or None if it doesn’t exist

fn vertex_data_mut(&mut self, v: V) -> &mut VData

Get a mutable ref to the data associated to the given vertex

fn set_edge_type(&mut self, s: V, t: V, ety: EType)

Sets type of an edge

fn edge_type_opt(&self, s: V, t: V) -> Option<EType>

Returns type of an edge or None if the edge (or one of the vertices) doesn’t exist

fn set_coord(&mut self, v: V, coord: impl Into<Coord>)

Sets the coordinate of a vertex

fn coord(&self, v: V) -> Coord

Returns the coordinate of a vertex

fn set_qubit(&mut self, v: V, qubit: f64)

Sets the qubit index of the given vertex

fn qubit(&self, v: V) -> f64

Returns the qubit index of the given vertex

fn set_row(&mut self, v: V, row: f64)

Sets the row of the given vertex

fn row(&self, v: V) -> f64

Returns the row of the given vertex

fn neighbors(&self, v: V) -> impl Iterator<Item = usize>

Returns an iterator over neighbors of a vertex

fn incident_edges(&self, v: V) -> impl Iterator<Item = (usize, EType)>

Returns an iterator over pairs (v, t) for v the “other end” of an edge, and t its type.

fn degree(&self, v: V) -> usize

Returns degree of a vertex

fn scalar(&self) -> &FScalar

Returns the scalar associated with a ZX diagram

fn scalar_mut(&mut self) -> &mut FScalar

Returns a mutable ref to the scalar associated with a ZX diagram

fn find_edge<F>(&self, f: F) -> Option<(V, V, EType)>

where F: Fn(V, V, EType) -> bool,

Returns the first edge satisfying the given function, or None

fn find_vertex<F>(&self, f: F) -> Option<V>

where F: Fn(V) -> bool,

Returns the first vertex satisfying the given function, or None

fn contains_vertex(&self, v: V) -> bool

fn scalar_factors(&self) -> impl Iterator<Item = (&Expr, &FScalar)>

Returns an iterator over all of the parametrised scalar factors

fn get_scalar_factor(&self, e: &Expr) -> Option<FScalar>

Get the scalar factor associated with a given boolean expression

fn mul_scalar_factor(&mut self, e: Expr, s: FScalar)

Insert (i.e. multiply) a new scalar factor s^e into the overall scalar

fn pack(&mut self, force: bool)

This method can be called periodically to reduce wasted space in the graph representation

fn phase_and_vars(&self, v: V) -> (Phase, Parity)

Returns the phase and any boolean variables at a vertex

fn set_phase(&mut self, v: V, phase: impl Into<Phase>)

Set the phase of a vertex

fn phase(&self, v: V) -> Phase

Returns the phase of vertex v

fn add_to_phase(&mut self, v: V, phase: impl Into<Phase>)

Adds a value to the phase of a vertex

fn set_vertex_type(&mut self, v: V, ty: VType)

Sets the type of a vertex

fn vertex_type(&self, v: V) -> VType

Returns the type of a vertex

fn vertex_type_opt(&self, v: V) -> Option<VType>

Returns type of a vertex or None if the vertex doesn’t exist

fn set_vars(&mut self, v: V, vars: Parity)

Sets the boolean variables that affect the phase of this vertex

fn vars(&self, v: V) -> Parity

Returns the boolean variables that affect the phase of this vertex

fn add_to_vars(&mut self, v: V, vars: &Parity)

Adds the given variables to the parity expression of the vertex

fn add_edge(&mut self, s: V, t: V)

Add an edge to the graph

fn edge_type(&self, s: V, t: V) -> EType

Returns the type of a given edge and panics if the edge doesn’t exist

fn connected(&self, v0: V, v1: V) -> bool

Returns true if the given vertices are connected

fn toggle_edge_type(&mut self, v0: V, v1: V)

Turns H-edges into normal edges and vice-versa

fn vertex_vec(&self) -> Vec<V>

Returns a vector of the vertices in the graph

fn edge_vec(&self) -> Vec<(V, V, EType)>

Returns a vector of the edges in the graph

fn neighbor_vec(&self, v: V) -> Vec<V>

Returns a vector of the neighbours of a given vertex

fn incident_edge_vec(&self, v: V) -> Vec<(V, EType)>

Returns a vector of the incident edges of a given vertex

fn x_to_z(&mut self)

Convert all X spiders to Z with the colour-change rule

fn add_vertex_with_phase(&mut self, ty: VType, phase: impl Into<Phase>) -> V

Add a vertex to the graph with the given type and phase

fn add_edge_smart(&mut self, s: V, t: V, ety: EType)

Add an edge and simplify if necessary to remove parallel edges

fn plug_vertex(&mut self, v: V, b: BasisElem)

Replace a boundary vertex with the given basis element

fn plug_output(&mut self, i: usize, b: BasisElem)

Plug the given basis vertex into the i-th output.

fn plug_input(&mut self, i: usize, b: BasisElem)

Plug the given basis vertex into the i-th input.

fn plug_inputs(&mut self, plug: &[BasisElem])

Plug the given list of normalised basis elements in as inputs, starting from the left

fn plug_outputs(&mut self, plug: &[BasisElem])

Plug the given list of normalised basis elements in as outputs, starting from the left

fn append_graph(&mut self, other: &impl GraphLike) -> FxHashMap<V, V>

Appends the given graph to the current one, with fresh names.

fn plug(&mut self, other: &impl GraphLike)

Plug the given graph into the outputs and multiply scalars

fn is_identity(&self) -> bool

Checks if the given graph only consists of wires from the inputs to outputs (in order)

fn tcount(&self) -> usize

Return number of Z or X spiders with non-Clifford phase

fn to_dot(&self) -> String

Return a graphviz-friendly string representation of the graph

fn adjoint(&mut self)

Exchange inputs and outputs and reverse all phases

fn to_adjoint(&self) -> Self

Same as GraphLike::adjoint(), but return as a copy

fn component_vertices(&self) -> Vec<FxHashSet<V>>

Returns vertices in the components of g

fn subgraph_from_vertices(&self, verts: Vec<V>) -> Self

Returns the full subgraph containing the given vertices

fn depth(&self) -> f64

Returns max row of any vertex

fn copy(&self, adjoint: bool) -> Self

Create a copy of the graph. If adjoint is set, the adjoint of the graph will be returned (inputs and outputs flipped, phases reversed). The copy will have consecutive vertex indices, even if the original graph did not.

fn make_bipartite(&mut self)

Performs inplace bipartite transformation of ZX graph by inserting opposite colored spiders between same-colored neighbors

fn adjacency_matrix(&self, nodelist: Option<&[V]>) -> Mat2

Returns the adjacency matrix of the graph, optionally in the order of nodelist (similar to nx’s adjacency_matrix)

impl PartialEq for Graph

fn eq(&self, other: &Graph) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Graph