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

More updates to handle new Q#-generated code: 



It'll generate calls to general x-control (CNOT) and generic measurement.

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

examples/qsharp/FTQC/Bell/bell.qs

+4 −1
Original line number Diff line number Diff line
@@ -2,14 +2,16 @@ namespace QCOR 
{

// Using QCOR Intrinsic instruction set

// see QirTarget.qs    

open QCOR.Intrinsic;

open Microsoft.Quantum.Intrinsic;

@EntryPoint()

operation TestBell(count : Int) : Int {

    Message($"Count = {count}");

    // Simple bell test

    mutable numOnes = 0;

    mutable agree = 0;

    use q = Qubit[2];

    for test in 1..count {

        Message("Run Bell experiment");

        H(q[0]);

        CNOT(q[0],q[1]);

        let res0 = M(q[0]);
@@ -21,6 +23,7 @@ operation TestBell(count : Int) : Int { 
        // Count the number of ones we saw:

        if res0 == One {

            set numOnes += 1;

            Message("Get one");

        }

        

        Reset(q[0]);

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

+73 −6
Original line number Diff line number Diff line 
#include "qir-qrt.hpp"

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

#include <iostream>

#include <stdexcept>

#include <math.h>



namespace {

static std::vector<Pauli> extractPauliIds(Array *paulis) {

  std::vector<Pauli> pauliIds;

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

    pauliIds.emplace_back(static_cast<Pauli>(*paulis->getItemPointer(i)));

  }

  return pauliIds;

}

} // namespace

// QRT QIS (quantum instructions) implementation for MSFT Compatability

extern "C" {

void __quantum__qis__exp__body(Array *paulis, double angle, Array *qubits) {
@@ -102,25 +113,33 @@ void __quantum__qis__t__ctladj(Array *ctls, Qubit *q) { 
    std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

}

void __quantum__qis__x__body(Qubit *q) {

  // TODO

  if (verbose)

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

  __quantum__qis__x(q);

}

void __quantum__qis__x__adj(Qubit *q) {

  // TODO

  if (verbose)

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

  // Self-adjoint

  __quantum__qis__x__body(q);

}

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

  // TODO

  if (verbose)

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

  if (ctls && ctls->size() == 1) {

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

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

    __quantum__qis__cnot(ctrl_qubit, q);

  } else {

    // TODO:

    std::cout << "Multiple-control is not supported yet.\n";

  }

}

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

  // TODO

  if (verbose)

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

  // Self-adjoint

  return __quantum__qis__x__ctl(ctls, q);

}

void __quantum__qis__y__body(Qubit *q) {

  // TODO
@@ -190,11 +209,59 @@ void __quantum__qis__cnot__body(Qubit *src, Qubit *tgt) { 
}



Result *__quantum__qis__measure__body(Array *bases, Array *qubits) {

  // TODO

  if (verbose)

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

  return nullptr;

  if (bases->size() != qubits->size()) {

    throw "Invalid Measure instruction: the list of bases must match the list "

          "of qubits.";

  }

  const auto paulis = extractPauliIds(bases);

  std::vector<bool> results;

  for (size_t i = 0; i < paulis.size(); ++i) {

    const auto pauli = paulis[i];

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

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

    switch (pauli) {

    case Pauli::Pauli_I:

      // std::cout << "I";

      results.emplace_back(true);

      break;

    case Pauli::Pauli_X: {

      // std::cout << "X";

      __quantum__qis__h(q);

      Result *bit_result = __quantum__qis__mz(q);

      results.emplace_back(*bit_result);

      break;

    }



    case Pauli::Pauli_Y: {

      // std::cout << "Y";

      __quantum__qis__rx(M_PI / 2.0, q);

      Result *bit_result = __quantum__qis__mz(q);

      results.emplace_back(*bit_result);

      break;

    }



    case Pauli::Pauli_Z: {

      // std::cout << "Z";

      Result *bit_result = __quantum__qis__mz(q);

      results.emplace_back(*bit_result);

      break;

    }



    default:

      __builtin_unreachable();

    }

  }

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

  // All equal measure result:

  if (std::equal(results.begin() + 1, results.end(), results.begin())) {

    return results[0] ? ResultOne : ResultZero;

  }

  // Zero otherwise:

  return ResultZero;

}



double __quantum__qis__intasdouble__body(int32_t intVal) {

  // TODO

  if (verbose)