File embedding_problem.hpp¶

namespace find_embedding

Enums

enum find_embeddingVARORDER¶

Values:

find_embeddingVARORDER_SHUFFLE¶

find_embeddingVARORDER_DFS¶

find_embeddingVARORDER_BFS¶

find_embeddingVARORDER_PFS¶

find_embeddingVARORDER_RPFS¶

find_embeddingVARORDER_KEEP¶

class find_embeddingdomain_handler_masked

#include <embedding_problem.hpp>

this domain handler stores masks for each variable so that prepare_visited and prepare_distances are barely more expensive than a memcopy

Public Functions

find_embedding::domain_handler_maskeddomain_handler_masked(optional_parameters &p, int n_v, int n_f, int n_q, int n_r)¶

virtual find_embedding::domain_handler_masked~domain_handler_masked()¶

void find_embedding::domain_handler_maskedprepare_visited(vector<int> &visited, const int u, const int v)¶

void find_embedding::domain_handler_maskedprepare_distances(vector<distance_t> &distance, const int u, const distance_t &mask_d)¶

void find_embedding::domain_handler_maskedprepare_distances(vector<distance_t> &distance, const int u, const distance_t &mask_d, const int start, const int stop)¶

bool find_embedding::domain_handler_maskedaccepts_qubit(const int u, const int q)¶

Private Members

optional_parameters &find_embedding::domain_handler_maskedparams¶

vector<vector<int>> find_embedding::domain_handler_maskedmasks¶

class find_embeddingdomain_handler_universe

#include <embedding_problem.hpp>

this is the trivial domain handler, where every variable is allowed to use every qubit

Public Functions

find_embedding::domain_handler_universedomain_handler_universe(optional_parameters&, int, int, int, int)¶

virtual find_embedding::domain_handler_universe~domain_handler_universe()¶

Public Static Functions

static void find_embedding::domain_handler_universeprepare_visited(vector<int> &visited, int, int)¶

static void find_embedding::domain_handler_universeprepare_distances(vector<distance_t> &distance, const int, const distance_t&)¶

static void find_embedding::domain_handler_universeprepare_distances(vector<distance_t> &distance, const int, const distance_t&, const int start, const int stop)¶

static bool find_embedding::domain_handler_universeaccepts_qubit(int, int)¶

template <class fixed_handler, class domain_handler> class find_embeddingembedding_problem : public find_embedding::embedding_problem_base, public fixed_handler, public domain_handler

#include <embedding_problem.hpp>

A template to construct a complete embedding problem by combining embedding_problem_base with fixed/domain handlers.

Public Functions

find_embedding::embedding_problemembedding_problem(optional_parameters &p, int n_v, int n_f, int n_q, int n_r, vector<vector<int>> &v_n, vector<vector<int>> &q_n)¶

virtual find_embedding::embedding_problem~embedding_problem()¶

Private Types

template<> using find_embedding::embedding_problem<fixed_handler, domain_handler>ep_t = embedding_problem_base ¶

template<> using find_embedding::embedding_problem<fixed_handler, domain_handler>fh_t = fixed_handler¶

template<> using find_embedding::embedding_problem<fixed_handler, domain_handler>dh_t = domain_handler¶

class find_embeddingembedding_problem_base

#include <embedding_problem.hpp>

Common form for all embedding problems.

Needs to be extended with a fixed handler and domain handler to be complete.

Subclassed by find_embedding::embedding_problem< fixed_handler, domain_handler >

Public Functions

find_embedding::embedding_problem_baseembedding_problem_base(optional_parameters &p_, int n_v, int n_f, int n_q, int n_r, vector<vector<int>> &v_n, vector<vector<int>> &q_n)¶

virtual find_embedding::embedding_problem_base~embedding_problem_base()¶

const vector<int> &find_embedding::embedding_problem_basevar_neighbors(int u) const: a vector of neighbors for the variable u

const vector<int> &find_embedding::embedding_problem_basequbit_neighbors(int q) const: a vector of neighbors for the qubit q

int find_embedding::embedding_problem_basenum_vars() const: number of variables which are not fixed

int find_embedding::embedding_problem_basenum_qubits() const: number of qubits which are not reserved

int find_embedding::embedding_problem_basenum_fixed() const: number of fixed variables

int find_embedding::embedding_problem_basenum_reserved() const: number of reserved qubits

template <typename... Args> void find_embedding::embedding_problem_baseerror(const char *format, Args... args) const: printf regardless of the verbosity level

template <typename... Args> void find_embedding::embedding_problem_basemajor_info(const char *format, Args... args) const: printf at the major_info verbosity level

template <typename... Args> void find_embedding::embedding_problem_baseminor_info(const char *format, Args... args) const: print at the minor_info verbosity level

template <typename... Args> void find_embedding::embedding_problem_baseextra_info(const char *format, Args... args) const: print at the extra_info verbosity level

template <typename... Args> void find_embedding::embedding_problem_basedebug(const char *ONDEBUGformat, Args... ONDEBUGargs) const: print at the debug verbosity level (only works when CPPDEBUG is set)

int find_embedding::embedding_problem_baserandint(int m): make a random integer between 0 and m-1

template <typename A, typename B> void find_embedding::embedding_problem_baseshuffle(A a, B b): shuffle the data bracketed by iterators a and b

void find_embedding::embedding_problem_basequbit_component(int q0, vector<int> &component, vector<int> &visited): compute the connected component of the subset component of qubits, containing q0, and usingvisited as an indicator for which qubits have been explored

const vector<int> &find_embedding::embedding_problem_basevar_order(VARORDER order = VARORDER_SHUFFLE): compute a variable ordering according to the order strategy

void find_embedding::embedding_problem_basedfs_component(int x, const vector<vector<int>> &neighbors, vector<int> &component, vector<int> &visited): Perform a depth first search.

Public Members

optional_parameters &find_embedding::embedding_problem_baseparams: A mutable reference to the user specified parameters.

int find_embedding::embedding_problem_basealpha¶

int find_embedding::embedding_problem_baseinitialized¶

int find_embedding::embedding_problem_baseembedded¶

int find_embedding::embedding_problem_basedesperate¶

int find_embedding::embedding_problem_basetarget_chainsize¶

int find_embedding::embedding_problem_baseimproved¶

int find_embedding::embedding_problem_baseweight_bound¶

Protected Attributes

int find_embedding::embedding_problem_basenum_v¶

int find_embedding::embedding_problem_basenum_f¶

int find_embedding::embedding_problem_basenum_q¶

int find_embedding::embedding_problem_basenum_r¶

vector<vector<int>> &find_embedding::embedding_problem_basequbit_nbrs¶: Mutable references to qubit numbers and variable numbers.

vector<vector<int>> &find_embedding::embedding_problem_basevar_nbrs¶

uniform_int_distribution find_embedding::embedding_problem_baserand¶: distribution over [0, 0xffffffff]

vector<int> find_embedding::embedding_problem_basevar_order_space¶

vector<int> find_embedding::embedding_problem_basevar_order_visited¶

vector<int> find_embedding::embedding_problem_basevar_order_shuffle¶

int_queue find_embedding::embedding_problem_basevar_order_pq¶

Private Functions

void find_embedding::embedding_problem_basepfs_component(int x, const vector<vector<int>> &neighbors, vector<int> &component, vector<int> &visited)¶: Perform a priority first search (priority = #of visited neighbors)

void find_embedding::embedding_problem_baserpfs_component(int x, const vector<vector<int>> &neighbors, vector<int> &component, vector<int> &visited)¶: Perform a reverse priority first search (reverse priority = #of unvisited neighbors)

void find_embedding::embedding_problem_basebfs_component(int x, const vector<vector<int>> &neighbors, vector<int> &component, vector<int> &visited)¶: Perform a breadth first search, shuffling level sets.

class find_embeddingfixed_handler_hival

#include <embedding_problem.hpp>

This fixed handler is used when the fixed variables are processed before instantiation and relabeled such that variables v >= num_v are fixed and qubits q >= num_q are reserved.

Public Functions

find_embedding::fixed_handler_hivalfixed_handler_hival(optional_parameters&, int n_v, int, int n_q, int)¶

virtual find_embedding::fixed_handler_hival~fixed_handler_hival()¶

bool find_embedding::fixed_handler_hivalfixed(const int u)¶

bool find_embedding::fixed_handler_hivalreserved(const int q)¶

Private Members

int find_embedding::fixed_handler_hivalnum_v¶

int find_embedding::fixed_handler_hivalnum_q¶

class find_embeddingfixed_handler_list

#include <embedding_problem.hpp>

This fixed handler is used when variables are allowed to be fixed after instantiation.

For that functionality, we probably need…

dynamic modification of var_neighbors and qubit_neighbors to maintain speed gains: fixed variables are sinks, reserved qubits are sources.
access to / ownership of var_neighbors and qubit_neighbors in this data structure
move existing initialization code from find_embedding.hpp into fixed_handler_hival (note the interplay with shuffling qubit labels, this might get gross)

Public Functions