qcor Namespace Reference

Classes
class	_qpu_lambda
class	AncQubitAllocator
class	ArgsTranslator
class	CompositeInstruction
class	DoNothingConsumer
class	FindFunctionVariableStoreInsts
class	FTQC
class	GradientFunction
class	KernelBackwardDifferenceGradient
class	KernelCentralDifferenceGradient
class	KernelForwardDifferenceGradient
class	KernelFunctor
class	KernelFunctorImpl
class	KernelGradientService
class	KernelSignature
class	LexerHelper
class	LLVM_IR_To_XACC
class	LLVMCompiler
class	LLVMJIT
class	NISQ
class	ObjectiveFunction
class	ObjectiveFunctionImpl
class	Operator
class	Optimizer
class	PyXasmTokenCollector
class	qcor_pimpl
class	QCORArgs
class	QCORBaseFunctionPass
class	QCORSyntaxHandler
class	QJIT
class	qrt_mapper
class	QuantumKernel
class	QuilTokenCollector
class	RBMChemistry
class	SearchForCallsToThisFunction
class	StaqTokenCollector
class	TokenCollector
class	UnitaryTokenCollector
class	VQEObjective
class	XACC_To_LLVM_IR
class	XACCJIT
class	XasmTokenCollector

Typedefs
template<typename Derived >
using	OneQubitKernel = QuantumKernel< Derived, qubit >
template<typename... Args>
using	callable_function_ptr = void(*)(std::shared_ptr< CompositeInstruction >, Args...)
using	GradientFunctionType = std::function< std::vector< double >(const std::vector< double > &, double)>
using	OptimizerFunctorNoGrad = std::function< double(const std::vector< double > &)>
using	OptimizerFunctor = std::function< double(const std::vector< double > &, std::vector< double > &)>
using	LocalOpaqueInstPtr = std::shared_ptr< xacc::Instruction >
template<typename T >
using	PairList = std::vector< std::pair< T, T > >
using	HeterogeneousMap = xacc::HeterogeneousMap
using	IRTransformation = xacc::IRTransformation
using	IRProvider = xacc::IRProvider
using	qreg = xacc::internal_compiler::qreg
using	UnitaryMatrix = Eigen::MatrixXcd
using	DenseMatrix = Eigen::MatrixXcd
template<typename... Args>
using	TranslationFunctor = std::function< std::tuple< Args... >(const std::vector< double > &)>
using	GradientEvaluator = std::function< void(std::vector< double > x, std::vector< double > &dx)>

Enumerations
enum	QrtType { NISQ, FTQC }

Functions
void	append_kernel (const std::string name, const std::vector< std::string > &program_arg_types, const std::vector< std::string > &program_parameters)
void	set_verbose (bool verbose)
void	info (const std::string &s)
std::string	run_token_collector (clang::Preprocessor &PP, clang::CachedTokens &Toks, std::vector< std::string > bufferNames)
std::string	run_token_collector (clang::Preprocessor &PP, clang::CachedTokens &Toks, std::string &src_to_prepend, const std::string kernel_name, const std::vector< std::string > &program_arg_types, const std::vector< std::string > &program_parameters, std::vector< std::string > bufferNames)
Handle	taskInitiate (std::shared_ptr< ObjectiveFunction > objective, std::shared_ptr< Optimizer > optimizer)
template<class Op >
void	split (const std::string &s, char delim, Op op)
std::vector< std::string >	split (const std::string &s, char delim)
std::vector< std::string >	split_args_signature (const std::string &source)
void	ltrim (std::string &s)
void	rtrim (std::string &s)
void	trim (std::string &s)
void	init_kernel_signature_args_impl (std::shared_ptr< CompositeInstruction > ir)
template<typename T , typename... ArgsType>
void	init_kernel_signature_args_impl (std::shared_ptr< CompositeInstruction > ir, T &t, ArgsType &...Args)
template<typename... T>
void	init_kernel_signature_args (std::shared_ptr< CompositeInstruction > ir, T &...multi_inputs)
template<typename T , typename... ArgsType>
void	init_kernel_signature_args_impl (std::shared_ptr< CompositeInstruction > ir, std::vector< T > &vec_arg, ArgsType... Args)
template<typename... ArgsType>
void	init_kernel_signature_args_impl (std::shared_ptr< CompositeInstruction > ir, KernelSignature< ArgsType... > &kernel_signature)
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (const std::string obj_name, void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator observable, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (const std::string obj_name, void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, std::shared_ptr< ArgsTranslator< Args... >> args_translator, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (const std::string obj_name, void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, std::shared_ptr< ArgsTranslator< Args... >> args_translator, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), std::shared_ptr< ArgsTranslator< Args... >> args_translator, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (const std::string obj_name, void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), std::shared_ptr< ArgsTranslator< Args... >> args_translator, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (const std::string obj_name, void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, const int nParams, HeterogeneousMap &&options={})
template<typename... CaptureArgs, typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (_qpu_lambda< CaptureArgs... > &lambda, std::shared_ptr< ArgsTranslator< Args... >> args_translator, Operator &observable, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... CaptureArgs>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (_qpu_lambda< CaptureArgs... > &lambda, Operator &observable, qreg &q, const int nParams, HeterogeneousMap &&options={})
template<typename... Args>
std::shared_ptr< ObjectiveFunction >	createObjectiveFunction (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), Operator &observable, qreg &q, const int nParams, std::shared_ptr< GradientFunction > gradient_method, HeterogeneousMap &&options={})
void	__internal_exec_observer (xacc::AcceleratorBuffer *b, std::vector< std::shared_ptr< CompositeInstruction >> v)
Operator	operator+ (double coeff, Operator op)
Operator	operator+ (Operator op, double coeff)
Operator	operator- (double coeff, Operator op)
Operator	operator- (Operator op, double coeff)
Operator	adag (int idx)
Operator	a (int idx)
Operator	X (int idx)
Operator	Y (int idx)
Operator	Z (int idx)
Operator	allZs (const int nQubits)
Operator	SP (int idx)
Operator	SM (int idx)
Eigen::MatrixXcd	get_dense_matrix (Operator &op)
Operator	createOperator (const std::string &repr)
Operator	createOperator (const std::string &name, const std::string &repr)
Operator	createOperator (const std::string &name, HeterogeneousMap &&options)
Operator	createOperator (const std::string &name, HeterogeneousMap &options)
Operator	createObservable (const std::string &repr)
Operator	createObservable (const std::string &name, const std::string &repr)
Operator	operatorTransform (const std::string &type, Operator &op)
Operator	_internal_python_createObservable (const std::string &name, const std::string &repr)
double	observe (std::shared_ptr< CompositeInstruction > program, Operator &obs, xacc::internal_compiler::qreg &q)
std::shared_ptr< Optimizer >	createOptimizer (const std::string &type, xacc::HeterogeneousMap &&options)
template<typename T >
bool	ptr_is_a (std::shared_ptr< Observable > ptr)
bool	get_verbose ()
void	set_shots (const int shots)
void	error (const std::string &msg)
void	set_backend (const std::string &backend)
void	persist_var_to_qreg (const std::string &key, double &val, qreg &q)
void	persist_var_to_qreg (const std::string &key, int &val, qreg &q)
std::shared_ptr< qcor::IRTransformation >	createTransformation (const std::string &transform_type)
std::shared_ptr< CompositeInstruction >	compile (const std::string &src)
std::vector< double >	random_vector (const double l_range, const double r_range, const std::size_t size)
template<typename T >
std::vector< T >	linspace (T a, T b, size_t N)
std::vector< int >	range (int N)
std::vector< int >	range (int start, int stop, int step)
std::vector< int >	range (int start, int stop)
template<typename T >
int	len (const T &countable)
template<typename T >
int	len (T &countable)
void	print ()
template<typename T , typename... TAIL>
void	print (const T &t, TAIL... tail)
template<typename... Args>
std::shared_ptr< ArgsTranslator< Args... > >	createArgsTranslator (TranslationFunctor< Args... > functor)
template<typename... Args>
auto	args_translator (std::function< std::tuple< Args... >(const std::vector< double >)> &&functor_lambda)
template<typename T , typename TIter = decltype(std::begin(std::declval<T>())), typename = decltype(std::end(std::declval<T>()))>
constexpr auto	enumerate (T &&iterable)
double	hadamard_test (StatePrep state_prep, Unitary unitary, int n_state_qubits)
template<typename... Args>
std::shared_ptr< KernelFunctor >	createKernelFunctor (void(*quantum_kernel_functor)(std::shared_ptr< CompositeInstruction >, Args...), size_t nQubits, size_t nParams)
std::shared_ptr< KernelFunctor >	createKernelFunctor (std::shared_ptr< CompositeInstruction > composite)
std::unique_ptr< clang::CodeGenAction >	emit_llvm_ir (const std::string src_code, std::vector< std::string > extra_headers={})
std::string	GetExecutablePath (const char *Argv0, void *MainAddr)

Variables
bool	qrt = false
std::string	qpu_name = "qpp"
int	shots = 0
llvm::ExitOnError	ExitOnErr
std::map< std::string, std::string >	qrt_to_xacc

Detailed Description

Implements time-series phase estimation protocol: Refs: https://arxiv.org/pdf/2010.02538.pdf Notes: We support both *unverified* and *verified* versions of the protocol. i.e. for noise-free simulation, we can use the *unverified* version whereby no post-selection based on measurement results of the main qubit register is required.

Variable Documentation

qrt_to_xacc

std::map<std::string, std::string> qcor::qrt_to_xacc

Initial value:

{
    {"h", "H"},           {"rz", "Rz"},     {"ry", "Ry"},   {"rx", "Rx"},
    {"x", "X"},           {"y", "Y"},       {"z", "Z"},     {"s", "S"},
    {"t", "T"},           {"sdg", "Sdg"},   {"tdg", "Tdg"}, {"cy", "CY"},
    {"cz", "CZ"},         {"swap", "Swap"}, {"crz", "CRZ"}, {"ch", "CH"},
    {"cphase", "CPhase"}, {"i", "I"},       {"u", "U"},     {"u1", "U1"},
    {"cnot", "CNOT"},     {"mz", "Measure"}}