uploading work on new pimpl data structures

if(Python_FOUND)

 if(${Python_VERSION} VERSION_GREATER_EQUAL 3.0.0)

   message(STATUS "Found Python version ${Python_VERSION}. Building QCOR Python API with ${Python_INCLUDE_DIRS}")

   add_subdirectory(python)

   #add_subdirectory(python)

 else()

  message(STATUS "Found Python version ${Python_VERSION}. Version must be greater than 3.0.0, skipping Python API build.")

 endif()

add_qcor_compile_and_exe_test(qrt_mixed_language simple/mixed_language.cpp)

add_qcor_compile_and_exe_test(qrt_simple-demo simple/simple-demo.cpp)

add_qcor_compile_and_exe_test(qrt_deuteron_exp_inst deuteron/deuteron_exp_inst.cpp)

add_qcor_compile_and_exe_test(qrt_deuteron_task_initiate deuteron/deuteron_task_initiate.cpp)

add_qcor_compile_and_exe_test(qrt_qaoa_example qaoa/qaoa_example.cpp)

add_qcor_compile_and_exe_test(qrt_qpe_example qpe/qpe_example_qrt.cpp)

add_qcor_compile_and_exe_test(qrt_kernel_include simple/multiple_kernels.cpp)

add_qcor_compile_and_exe_test(qrt_grover grover/grover.cpp)

add_qcor_compile_and_exe_test(qrt_adapt hybrid/adapt_h2.cpp)

#add_qcor_compile_and_exe_test(compute_action_uncompute0 compute_action_uncompute/compute_action_uncompute_h2_ucc1_example.cpp)

add_qcor_compile_and_exe_test(compute_action_uncompute1 compute_action_uncompute/multiple_in_kernel.cpp)

add_qcor_compile_and_exe_test(compute_action_uncompute2 compute_action_uncompute/cau_capture_vars.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_simple ftqc_qrt/simple-demo.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_rus ftqc_qrt/repeat-until-success.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_qec ftqc_qrt/bit-flip-code.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_deuteron ftqc_qrt/deuteron.cpp)

# too long add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_deuteron ftqc_qrt/deuteron.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_bit_flip_qec_std_lib ftqc_qrt/error_correcting_code.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_five_qubit_qec_std_lib ftqc_qrt/five_qubit_qec_code.cpp)

add_qcor_ftqc_compile_and_exe_test(qrt_ftqc_steane_qec_std_lib ftqc_qrt/steane_qec_code.cpp)

add_qcor_compile_and_exe_test(qrt_obj_func_simple simple/simple-objective-function.cpp)

add_qcor_compile_and_exe_test(qrt_kernel_autograd_simple simple/gradients_optimization.cpp)

add_qcor_compile_and_exe_test(qrt_hybrid_vqe_exe hybrid/deuteron_h2_vqe.cpp)

add_qcor_compile_and_exe_test(qrt_bell_ctrl bell/bell_control.cpp)

# Lambda tests

#include "OperatorPool.hpp"

#include "xacc.hpp"

#include "xacc_service.hpp"

using ObservablePtr = std::shared_ptr<Observable>;

// Initial State is HF

__qpu__ void initial_state(qreg q) {

  X(q[0]);

  X(q[2]);

}

// Adapt Ansatz, grows as the vector of input Observables grows

__qpu__ void adapt_ansatz(qreg q, std::vector<double> x,

                          std::vector<ObservablePtr> ops) {

  initial_state(q);

  for (auto [i, op] : enumerate(ops)) {

    exp_i_theta(q, x[i], op);

  }

}

int main() {

  // Define the Hamiltonian using the QCOR API

  auto H = 0.1202 * Z(0) * Z(1) + 0.168336 * Z(0) * Z(2) +

           0.1202 * Z(2) * Z(3) + 0.17028 * Z(2) + 0.17028 * Z(0) +

           0.165607 * Z(0) * Z(3) + 0.0454063 * Y(0) * Y(1) * X(2) * X(3) -

           0.106477 - 0.220041 * Z(3) + 0.174073 * Z(1) * Z(3) +

           0.0454063 * Y(0) * Y(1) * Y(2) * Y(3) - 0.220041 * Z(1) +

           0.165607 * Z(1) * Z(2) + 0.0454063 * X(0) * X(1) * Y(2) * Y(3) +

           0.0454063 * X(0) * X(1) * X(2) * X(3);

  // Use XACC to generate the operator pool Ai

  auto pool =

      xacc::getService<xacc::quantum::OperatorPool>("singlet-adapted-uccsd");

  pool->optionalParameters({{"n-electrons", 2}});

  auto ops = pool->generate(H.nBits());

  // Compute all [H, Ai] commutators

  std::vector<ObservablePtr> commutators(ops.size());

  std::generate(commutators.begin(), commutators.end(),

                [n = 0, &H, &ops]() mutable {

                  auto c = H.commutator(ops[n]);

                  n++;

                  return c;

                });

  // Local Declarations

  double energy = 0.0;

  std::vector<double> x;

  std::vector<ObservablePtr> all_ops;

  // Get the Optimizer

  auto optimizer = createOptimizer("nlopt");

  // Allocate a qreg

  auto q = qalloc(H.nBits());

  // Create an ArgsTranslator to translate

  // vec<double> x -> qreg, vec<double> vec<ObservablePtr

  auto args_translator = std::make_shared<ArgsTranslator<

      qreg, std::vector<double>, std::vector<std::shared_ptr<Observable>>>>(

      [&](const std::vector<double> &xx) {

        return std::make_tuple(q, xx, all_ops);

      });

  // start ADAPT loop

  for (int iter = 0; iter < 100; iter++) {

    double max_grad = 0.0, grad_norm = 0.0;

    int max_grad_idx = 0, counter = 0;

    // Compute the gradient vector dEi = <[H,Ai]>

    std::vector<double> grad_vec(commutators.size());

    std::generate(grad_vec.begin(), grad_vec.end(), [&]() {

      // Create an ObjectiveFunction to compute <[H,Ai]>

      auto obj = createObjectiveFunction(adapt_ansatz, commutators[counter],

                                         args_translator, q, x.size());

      counter++;

      // compute the grad element <[H,Ai]>

      auto grad = (*obj)(x);

      // set the gradient norm

      grad_norm += grad * grad;

      return grad;

    });

    // grad_vec is filled, find the index of the max element

    auto max_idx = std::distance(

        grad_vec.begin(), std::max_element(grad_vec.begin(), grad_vec.end()));

    // Grow the list of operators to build the ansatz

    all_ops.push_back(ops[max_idx]);

    // Check for convergence

    if (grad_norm < 1e-6) {

      std::cout << "Converged on gradient norm\n";

      break;

    }

    // Add a new parameter to the ansatz params

    x.push_back(0.0);

    // Create another ObjectiveFunction to

    // run the VQE min

    auto vqe =

        createObjectiveFunction(adapt_ansatz, H, args_translator, q, x.size());

    // Set the initial parameters

    optimizer->appendOption("initial-parameters", x);

    // Run task initiate and sync

    auto handle = taskInitiate(vqe, optimizer);

    auto results = sync(handle);

    // Get the energy

    energy = results.opt_val;

    // Get the current optimal params

    x = results.opt_params;

    std::cout << "Current Adapt Energy = " << energy << "\n";

  }

  std::cout << "Adapt computing energy = " << energy << "\n";

  std::cout << "Number of Adapt Parameters = " << x.size() << "\n";

  std::cout << "Adapt Optimal Parameters = [";

  for (auto xx : x) {

    std::cout << xx << " ";

  }

  std::cout << "]\n";

  // Run the kernel

  {

    class adapt_ansatz t(qalloc(H.nBits()), x, all_ops);

    t.optimize_only = true;

    // kernel executed upon destruction,

    // will only build up circuit and run pass manager

  }

  std::cout << "NInsts: " << quantum::program->nInstructions() << "\n";

  std::cout << "Number of Adapt Ansatz Gates: "

            << quantum::program->nInstructions() << "\n";

  return 0;

}

 No newline at end of file

#include <qcor_hadamard_test>

using FO = FermionOperator;

int main() {

  std::vector<FermionOperator> exp_args{

  std::vector<Operator> exp_args{

      -4 * adag(0) * a(0) - 4 * adag(2) * a(2) +

          8 * adag(0) * a(0) * adag(2) * a(2),

      0.01 * adag(0) * a(1) + .01 * adag(3) * a(2) + .01 * adag(1) * a(0) +

  auto H = 5.907 - 2.1433 * X(0) * X(1) - 2.1433 * Y(0) * Y(1) + .21829 * Z(0) -

           6.125 * Z(1);

  auto optimizer = createOptimizer("nlopt", {{"maxeval", 20}, {"ftol", 0.1}});

  OptFunction f(

  ObjectiveFunction f(

      [&](const std::vector<double> &x, std::vector<double> &dx) {

        const double angle = x[0];

        auto statePrep =