qir-alliance / qcor Goto Github PK

The following causes an assertion to be triggered

@qjit
def oracle(q : qreg):
    """
    Define the oracle for our phase estimation algorithm,
    a T gate on the last qubit
    """
    ... oracle code ...

but this does not

@qjit
def oracle(q : qreg):
    ... oracle code ...

make it easier to say PYTHONPATH=$(qcor -pythonpath) ( may consist of both qcor and xacc install paths )

but not when running that test individually by itself.

__qpu__ void hwe(qreg q, std::vector<double> x, const int layers, 
                    std::vector<std::pair<int,int>> cnot_coupling) {
    assert(x.size() == layers*q.size()*5);
... 
}

we should try to support asserts like the above in quantum kernels. right now this is a compile error

<built-in>:21:154: error: use of undeclared identifier 'extension__'
( static_cast < bool > ( x . size ( ) == layers * q . size ( ) * 5 ) ? void ( 0 ) : assert_fail ( "x.size() == layers*q.size()*5" , "hwe_test.cpp" , 3 , extension__ PRETTY_FUNCTION__ ) ) ; 

We should add a api call that lets users specific backend info like shots, backend, etc.

I followed the instructions for installation and got the error below:

ld: library not found for -lqir-qrt
clang-12: error: linker command failed with exit code 1 (use -v to see invocation)
None
1

Create internal runtime functions that make it easier on us to map XACC IR to LLVM IR qrt calls. We should have a kernel preamble function call, a simplified function for creating qrt calls, and a end submission call.

• A call to run initialize and setNameAndStore in one shot
• A call that takes inst name string, qreg name, and integer indices (easier than creating qreg[] in IR)
• A call that submits if execute on

I'm seeing the following results for compiling examples/unitary/ccnot.cpp with opt = 1

{
    "AcceleratorBuffer": {
        "name": "qreg_DCnZQHYUmN",
        "size": 3,
        "Information": {},
        "Measurements": {
            "000": 10,
            "001": 142,
            "010": 166,
            "011": 179,
            "100": 175,
            "101": 46,
            "110": 205,
            "111": 101
        }
    }
}

and the correct result without optimization

{
    "AcceleratorBuffer": {
        "name": "qreg_goULRASYIr",
        "size": 3,
        "Information": {},
        "Measurements": {
            "011": 1024
        }
    }
}

I tried all the level 1 passes individually to see what was causing the error, only thing that caused the incorrect results was single-qubit-merge.

@tnguyen-ornl

We need to update the clang code-gen tool to add necessary mac os x compiler headers.

Must figure out how to do this in a syntactically efficient manner, that can be used in C or C++

qcor-driver on mac os x does not work currently.

• Ability to pass literals to kernels:
  e.g. __qpu__ void myKernel(qreg q, int varName), we should be able to call myKernel(q, 0) (passes 0 to varName).
  Currently, we need to assign literal to a local variable before passing it to the function argument.

• Ability to assign classical function return values to local classical variables.
  e.g.

std::vector<double> myLocalArray = someFunc(...); // someFunc is strictly classical

Currently, this is not available/not reliable.
We can work around this by modifying the function signature to take the local variable by reference and update it rather than returning a value.

• Ability to do fully-classical conditional.
  e.g.

__qpu__ void myKernel(qreg q, int switchVar) {
	if (switchVar != 0) {
		// Do something, e.g. add gates
	}
}

Maybe related to the above, early return should also be nice.

e.g.

__qpu__ void myKernel(qreg q, int switchVar) {
    if (swicthVar == 0) {
       return;
    }
   // Gates when switchVar != 0
}

In Python, we should enable it so that one can extract the unitary matrix representation of an evaluated quantum kernel

@qjit
def ansatz(q : qreg, theta : float):
   ...

u_mat = ansatz.as_unitary_matrix(q, 2.2)

Similarly, in C++

auto u_mat = ansatx::as_unitary_matrix(q,2.2);

To do this, we could start by porting the https://github.com/eclipse/xacc/blob/master/quantum/plugins/algorithms/gradient_strategies/autodiff/Autodiff.cpp visitor implementation to qcor_utils

We need to hook up the ability to use controlled versions of defined qjit kernels (and adjoint, print, etc).

for a simple test problem, I am noticing on the Mojave CI that qcor compile times are much slower than on Linux with brew or apt-get.

@tnguyen-ornl will you look into this separately on your Mojave install?

We need to develop a standard library for qcor that is automatically installed when qcor is installed.

          Rz(q[(i], x[rz_xidx]);

this did not throw an error and just did not put the quantum::rz() function in the rewritten src.

We want to take something like

for (int i = 0; i < n; i++) {
  H(q[i]);
} 

to

for (int i = 0; i < 1; i++) {
  H(q[0]);
  H(q[1]);
  H(q[2]);
  ...
  H(q[n-1]);
}

when we know at compile time what n is.

Look into LoopInfoWrapperPass

Rigetti QCS has moved to a access model whereby you have a JupyterLab IDE, no more VM with sudo access.

The VM is not bad, 32gb RAM and 8 cores, Ubuntu 20.04.

You cannot run the aide-qc install script as is, it requires sudo.

You can clone deploy and dpkg -x xacc . to install locally. Problem is that the qcor executable has hard-coded paths.

When I try to just in time compile a kernel with name 't' (any function body content), I get a weird symbol not found error coming out of the jit code

def t(q : qreg):
    H(q[0])
    CNOT(q[0], q[1])
    CNOT(q[1], q[2])
    Measure(q[0])
    Measure(q[1])
    Measure(q[2])

Failure value returned from cantFail wrapped call
Symbols not found: [ __cxx_global_var_init ]
UNREACHABLE executed at /usr/local/aideqc/llvm/include/llvm/Support/Error.h:749!
Aborted (core dumped)

We should hook up the qcor executable to provide a --credentials or something like that would take the name of the accelerator, and any other info to write the appropriate .*_config file.

qcor --set-credentials ibm --hub ibm-q-ornl --group ornl --project PROJECT

There should also be an --update-credentials to change some of this info.

Just like we have set_qpu we should also have setters for python for optimization and placement.

For IR Passes, we really want to flatten entry level quantum kernels (those whose parent or caller is regular function / not quantum / something like main()). This will make it easier on us to figure out the flattened qasm qrt calls and map to XACC IR. This flattening can be accomplished via function inlining. This link seems to suggest that clang will automatically accomplish this for functions annotated with __attribute__((always_inline)) https://lists.llvm.org/pipermail/llvm-dev/2018-May/123425.html.

We should be able to add this attribute to non-entry kernels in the token_collector_util.cpp file.

Thinking out loud - need to provide documentation and mechanism for advanced users to leverage QuantumKernel<Derived,Args...>.

We should implement the adapt vqe workflow as a QuantumSimulationWorkflow.

We should provide a way to build quantum kernels programmatically (similar to other packages circuit types).

This should be a high-level wrapper around either the QJIT work or the xacc IRProvider.

It should alternately allow a user to provide a unitary matrix and delegate to a desired circuit synthesis strategy.

It should be treated just like a standard quantum kernel function, exposing some kind of call operation.

You should be able to declaratively provide kernel arguments or variables.

things like getObservable should be createObservable

Steps to reproduce:

• Navigate to qcor/examples/qrt folder.
• Execute qcor -o deuteron_qpp -qpu qpp deuteron_task_initiate.cpp
• QCOR successfully generates deuteron_qpp executable.
• Re-execute qcor -o deuteron_qpp -qpu qpp deuteron_task_initiate.cpp
• QCOR compilation failed with the error:

deuteron_task_initiate.cpp:1:10: fatal error: 'qcor.hpp' file not found
#include "qcor.hpp"
         ^~~~~~~~~~
1 error generated.
None
1

We need to delete the file deuteron_qpp to get it to work again.

Need to update PyObjectiveFunction to support gradients by creating the kernel_evaluator functor and passing to the helper ObjectiveFunction

We can add metadata to the llvm ir printout with this class. Think about using it to maybe add xacc ir toString to a qrt call.

We need to setup the vqe objective to default to autodiff when gradient strategy is not provided. May need some update to autodiff, in that it looks for CompositeInstruction variables, and those are not set on the qcor composite instruction.

Add a .readme to give high level overview of each subdirectory of qcor/examples/.

if we install with apt-get, then the install directory will be /usr/local/xacc, which will have root permissions, and anyone using python or qjit will not be able to cache or read llvm module bitcode files. Need to update qjit to cache to the home directory.