Commit 0173dea1 authored by Nguyen, Thien Minh's avatar Nguyen, Thien Minh
Browse files

Add the remaining MSFT QIS impl. 



Signed-off-by: default avatarThien Nguyen <nguyentm@ornl.gov>
parent 2415dfe5

examples/qsharp/FTQC/Functor/driver.cpp

+4 −2
Original line number Diff line number Diff line 
#include <iostream>

#include <vector>



qcor_include_qsharp(QCOR__Testing__TestFunctors__Interop, void);

qcor_include_qsharp(QCOR__Testing__TestFunctors__Interop, int64_t);



// Compile with:

// Include both the qsharp source and this driver file
@@ -10,6 +10,8 @@ qcor_include_qsharp(QCOR__Testing__TestFunctors__Interop, void); 
// Run with:

// $ ./a.out

int main() {

  QCOR__Testing__TestFunctors__Interop();

  const auto error_code = QCOR__Testing__TestFunctors__Interop();

  std::cout << "Error code: " << error_code << "\n";

  qcor_expect(error_code == 0);

  return 0;

}
 
 No newline at end of file

examples/qsharp/FTQC/Functor/functor.qs

+32 −9
Original line number Diff line number Diff line
@@ -12,38 +12,61 @@ namespace QCOR.Testing { 
    }



    @EntryPoint()

    operation TestFunctors() : Unit {

    // Return 0 if success.

    operation TestFunctors() : Int {

        let qop = Qop(_, 1);

        let adj_qop = Adjoint qop;

        let ctl_qop = Controlled qop;

        let adj_ctl_qop = Adjoint Controlled qop;

        let ctl_ctl_qop = Controlled ctl_qop;



        mutable error_code = 0; 

        use (q1, q2, q3) = (Qubit(), Qubit(), Qubit()) {

            qop(q1);

            if (M(q1) != One) { Message("error code: 1"); }

            if (M(q1) != One) { 

                Message("error code: 1"); 

                set error_code = 1;

            }

 

            adj_qop(q2);

            if (M(q2) != One) { Message("error code: 2"); }

            if (M(q2) != One) { 

                Message("error code: 2"); 

                set error_code = 2;

            }



            ctl_qop([q1], q3);

            if (M(q3) != One) { Message("error code: 3"); }

            if (M(q3) != One) { 

                Message("error code: 3"); 

                set error_code = 3;

            }



            adj_ctl_qop([q2], q3);

            if (M(q3) != Zero) { Message("error code: 2"); }

            if (M(q3) != Zero) { 

                Message("error code: 2"); 

                set error_code = 2;

            }



            ctl_ctl_qop([q1], ([q2], q3));

            if (M(q3) != One) { Message("error code: 5"); }

            if (M(q3) != One) { 

                Message("error code: 5"); 

                set error_code = 5;

            }



            Controlled qop([q1, q2], q3);

            if (M(q3) != Zero) { Message("error code: 6"); }

            if (M(q3) != Zero) { 

                Message("error code: 6"); 

                set error_code = 6;

            }



            use q4 = Qubit() {

                Adjoint qop(q3);

                Adjoint Controlled ctl_ctl_qop([q1], ([q2], ([q3], q4)));

                if (M(q4) != One) { Message("error code: 7"); }

                if (M(q4) != One) { 

                    Message("error code: 7"); 

                    set error_code = 7;

                }

            }

        }

        return error_code;

    }



    operation NoArgs() : Unit

mlir/qir_qrt/qir-qis-ms-compat.cpp

+106 −24
Original line number Diff line number Diff line 
#include "qir-qrt.hpp"

#include "qir-qrt-ms-compat.hpp"

#include "qir-qrt.hpp"

#include <iostream>

#include <stdexcept>

#include <math.h>

#include <stdexcept>



namespace {

static std::vector<Pauli> extractPauliIds(Array *paulis) {
@@ -38,17 +38,25 @@ void __quantum__qis__exp__ctladj(Array *ctls, Array *paulis, double angle, 
    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

}

void __quantum__qis__h__body(Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  // Delegate to __quantum__qis__h

  __quantum__qis__h(q);

}

void __quantum__qis__h__ctl(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__h(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}



void __quantum__qis__r__body(Pauli pauli, double theta, Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";
@@ -73,74 +81,131 @@ void __quantum__qis__r__body(Pauli pauli, double theta, Qubit *q) { 
  }

}

void __quantum__qis__r__adj(Pauli pauli, double theta, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__r__body(pauli, -theta, q);

}

void __quantum__qis__r__ctl(Array *ctls, Pauli pauli, double theta, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__r__body(pauli, theta, q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}

void __quantum__qis__r__ctladj(Array *ctls, Pauli pauli, double theta,

                               Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__r__body(pauli, -theta, q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}

void __quantum__qis__s__body(Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__s(q);

}

void __quantum__qis__s__adj(Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__sdg(q);

}



void __quantum__qis__s__ctl(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__s__body(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}



void __quantum__qis__s__ctladj(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__s__adj(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}



void __quantum__qis__t__body(Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__t(q);

}

void __quantum__qis__t__adj(Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__tdg(q);

}

void __quantum__qis__t__ctl(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__t__body(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}

void __quantum__qis__t__ctladj(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__t__adj(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}



void __quantum__qis__x__body(Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__x(q);

}



void __quantum__qis__x__adj(Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  // Self-adjoint

  __quantum__qis__x__body(q);

}



void __quantum__qis__x__ctl(Array *ctls, Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";
@@ -160,12 +225,14 @@ void __quantum__qis__x__ctl(Array *ctls, Qubit *q) { 
    __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

  }

}



void __quantum__qis__x__ctladj(Array *ctls, Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  // Self-adjoint

  return __quantum__qis__x__ctl(ctls, q);

}



void __quantum__qis__y__body(Qubit *q) {

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";
@@ -178,14 +245,24 @@ void __quantum__qis__y__adj(Qubit *q) { 
  __quantum__qis__y__body(q);

}

void __quantum__qis__y__ctl(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__y__body(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}

void __quantum__qis__y__ctladj(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  // Self-adjoint

  __quantum__qis__y__ctl(ctls, q);

}

void __quantum__qis__z__body(Qubit *q) {

  if (verbose)
@@ -199,35 +276,41 @@ void __quantum__qis__z__adj(Qubit *q) { 
  __quantum__qis__z__body(q);

}

void __quantum__qis__z__ctl(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";



  std::vector<Qubit *> ctrl_qubits;

  for (int i = 0; i < ctls->size(); ++i) {

    int8_t *arrayPtr = (*ctls)[i];

    Qubit *ctrl_qubit = *(reinterpret_cast<Qubit **>(arrayPtr));

    ctrl_qubits.emplace_back(ctrl_qubit);

  }

  __quantum__rt__start_ctrl_u_region();

  __quantum__qis__z__body(q);

  __quantum__rt__end_multi_ctrl_u_region(ctrl_qubits);

}

void __quantum__qis__z__ctladj(Array *ctls, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  // Self-adjoint

  __quantum__qis__z__ctl(ctls, q);

}

void __quantum__qis__rx__body(double theta, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__rx(theta, q);

}

void __quantum__qis__ry__body(double theta, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__ry(theta, q);

}

void __quantum__qis__rz__body(double theta, Qubit *q) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__rz(theta, q);

}

void __quantum__qis__cnot__body(Qubit *src, Qubit *tgt) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  __quantum__qis__cnot(src, tgt);
@@ -288,7 +371,6 @@ Result *__quantum__qis__measure__body(Array *bases, Array *qubits) { 
}



double __quantum__qis__intasdouble__body(int32_t intVal) {

  // TODO

  if (verbose)

    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

  return static_cast<double>(intVal);

mlir/qir_qrt/qir-qrt.cpp

+5 −5
Original line number Diff line number Diff line
@@ -416,11 +416,11 @@ void __quantum__rt__end_multi_ctrl_u_region( 
      std::make_pair("control-idx", ctrl_bits),

  });



  std::cout << "Running Ctrl on ";

  for (const auto &bit : ctrl_bits) {

    std::cout << bit << " ";

  }

  std::cout << ":\n" << ctrlKernel->toString() << "\n";

  // std::cout << "Running Ctrl on ";

  // for (const auto &bit : ctrl_bits) {

  //   std::cout << bit << " ";

  // }

  // std::cout << ":\n" << ctrlKernel->toString() << "\n";

  for (int instId = 0; instId < ctrlKernel->nInstructions(); ++instId) {

    ::quantum::qrt_impl->general_instruction(

        ctrlKernel->getInstruction(instId));