Class find_embedding::chain#

class chain#

Public Functions

inline chain(vector<int> &w, int l)#

construct this chain, linking it to the qubit_weight vector w (common to all chains in an embedding, typically) and setting its variable label l

inline chain &operator=(const vector<int> &c)#

assign this to a vector of ints.

each incoming qubit will have itself as a parent.

inline chain &operator=(const chain &c)#

assign this to another chain

inline size_t size() const#

number of qubits in chain

inline size_t count(const int q) const#

returns 0 if q is not contained in this, 1 otherwise

inline int get_link(const int x) const#

get the qubit, in this, which links this to the chain of x (if x==label, interpret the linking qubit as the chain’s root)

inline void set_link(const int x, const int q)#

set the qubit, in this, which links this to the chain of x (if x==label, interpret the linking qubit as the chain’s root)

inline int drop_link(const int x)#

discard and return the linking qubit for x, or -1 if that link is not set

inline void set_root(const int q)#

insert the qubit q into this, and set q to be the root (represented as the linking qubit for label)

inline void clear()#

empty this data structure

inline void add_leaf(const int q, const int parent)#

add the qubit q as a leaf, with parent as its parent

inline int trim_branch(int q)#

try to delete the qubit q from this chain, and keep deleting until no more qubits are free to be deleted.

return the first ancestor which cannot be deleted

inline int trim_leaf(int q)#

try to delete the qubit q from this chain.

if q cannot be deleted, return it; otherwise return its parent

inline int parent(const int q) const#

the parent of q in this chain &#8212; which might be q but otherwise cycles should be impossible

inline void adopt(const int p, const int q)#

assign p to be the parent of q, on condition that both p and q are contained in this, q is its own parent, and q is not the root

inline int refcount(const int q) const#

return the number of references that this makes to the qubit q &#8212; where a “reference” is an occurrence of q as a parent or an occurrence of q as a linking qubit / root

inline size_t freeze(vector<chain> &others, frozen_chain &keep)#

store this chain into a frozen_chain, unlink all chains from this, and clear()

inline void thaw(vector<chain> &others, frozen_chain &keep)#

restore a frozen_chain into this, re-establishing links from other chains.

precondition: this is empty.

template<typename embedding_problem_t>
inline void steal(chain &other, embedding_problem_t &ep, int chainsize = 0)#

assumes this and other have links for eachother’s labels steals all qubits from other which are available to be taken by this; starting with the qubit links and updating qubit links after all

link this chain to another, following the path q, parent[q], parent[parent[q]], …

from this to other and intermediate nodes (all but the last) into this (preconditions: this and other are not linked, q is contained in this, and the parent-path is eventually contained in other)

inline iterator begin() const#

iterator pointing to the first qubit in this chain

inline iterator end() const#

iterator pointing to the end of this chain

inline void diagnostic()#

run the diagnostic, and if it fails, report the failure to the user and throw a CorruptEmbeddingException.

the last_op argument is used in the error message

inline int run_diagnostic() const#

run the diagnostic and return a nonzero status r in case of failure if(r&1), then the parent of a qubit is not contained in this chain if(r&2), then there is a refcounting error in this chain

class iterator#