Merge branch 'main' into feature/add-qilimanjaro-target

Author: fedonman

include/cudaq/Optimizer/CodeGen/QIRAttributeNames.h

@@ -47,7 +47,7 @@ static constexpr const char BackwardsBranchingFlagName[] =
     "backwards_branching";
 } // namespace qir0_1
 
-namespace qir0_2 {
+namespace qir1_0 {
 static constexpr const char RequiredQubitsAttrName[] = "required_num_qubits";
 static constexpr const char RequiredResultsAttrName[] = "required_num_results";
 
@@ -60,6 +60,6 @@ static constexpr const char MultipleTargetBranchingFlagName[] =
     "multiple_target_branching";
 static constexpr const char MultipleReturnPointsFlagName[] =
     "multiple_return_points";
-} // namespace qir0_2
+} // namespace qir1_0
 
 } // namespace cudaq::opt

include/cudaq/Optimizer/CodeGen/QIRFunctionNames.h

@@ -31,7 +31,7 @@ static constexpr const char ReadResultBody[] =
     "__quantum__qis__read_result__body";
 }
 
-namespace qir0_2 {
+namespace qir1_0 {
 static constexpr const char ReadResult[] = "__quantum__rt__read_result";
 }
 

lib/Optimizer/CodeGen/ConvertToQIRAPI.cpp

@@ -587,7 +587,7 @@ struct DiscriminateOpRewrite
 };
 
 // Supported QIR versions.
-enum struct QirVersion { version_0_1, version_0_2 };
+enum struct QirVersion { version_0_1, version_1_0 };
 
 template <typename M>
 struct DiscriminateOpToCallRewrite
@@ -598,9 +598,9 @@ struct DiscriminateOpToCallRewrite
   matchAndRewrite(quake::DiscriminateOp disc, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if constexpr (M::discriminateToClassical) {
-      if constexpr (M::qirVersion == QirVersion::version_0_2) {
+      if constexpr (M::qirVersion == QirVersion::version_1_0) {
         rewriter.replaceOpWithNewOp<func::CallOp>(
-            disc, rewriter.getI1Type(), cudaq::opt::qir0_2::ReadResult,
+            disc, rewriter.getI1Type(), cudaq::opt::qir1_0::ReadResult,
             adaptor.getOperands());
       } else {
         rewriter.replaceOpWithNewOp<func::CallOp>(
@@ -2049,14 +2049,14 @@ struct QuakeToQIRAPIPass
       else
         processOperation<FullQIR</*opaquePtr=*/false>>(typeConverter);
     } else if (apiField[0] == "base-profile") {
-      if (apiField.size() > 1 && apiField[1] == "0.2") {
+      if (apiField.size() > 1 && apiField[1] == "1.0") {
         if (opaquePtr)
           processOperation<
-              BaseProfileQIR</*opaquePtr=*/true, QirVersion::version_0_2>>(
+              BaseProfileQIR</*opaquePtr=*/true, QirVersion::version_1_0>>(
               typeConverter);
         else
           processOperation<
-              BaseProfileQIR</*opaquePtr=*/false, QirVersion::version_0_2>>(
+              BaseProfileQIR</*opaquePtr=*/false, QirVersion::version_1_0>>(
               typeConverter);
       } else {
         if (opaquePtr)
@@ -2069,14 +2069,14 @@ struct QuakeToQIRAPIPass
               typeConverter);
       }
     } else if (apiField[0] == "adaptive-profile") {
-      if (apiField.size() > 1 && apiField[1] == "0.2") {
+      if (apiField.size() > 1 && apiField[1] == "1.0") {
         if (opaquePtr)
           processOperation<
-              AdaptiveProfileQIR</*opaquePtr=*/true, QirVersion::version_0_2>>(
+              AdaptiveProfileQIR</*opaquePtr=*/true, QirVersion::version_1_0>>(
               typeConverter);
         else
           processOperation<
-              AdaptiveProfileQIR</*opaquePtr=*/false, QirVersion::version_0_2>>(
+              AdaptiveProfileQIR</*opaquePtr=*/false, QirVersion::version_1_0>>(
               typeConverter);
       } else {
         if (opaquePtr)
@@ -2265,14 +2265,14 @@ struct QuakeToQIRAPIPrepPass
   }
 
   static StringRef getRequiredQubitsAttrName(StringRef version) {
-    if (version == "0.2")
-      return cudaq::opt::qir0_2::RequiredQubitsAttrName;
+    if (version == "1.0")
+      return cudaq::opt::qir1_0::RequiredQubitsAttrName;
     return cudaq::opt::qir0_1::RequiredQubitsAttrName;
   }
 
   static StringRef getRequiredResultsAttrName(StringRef version) {
-    if (version == "0.2")
-      return cudaq::opt::qir0_2::RequiredResultsAttrName;
+    if (version == "1.0")
+      return cudaq::opt::qir1_0::RequiredResultsAttrName;
     return cudaq::opt::qir0_1::RequiredResultsAttrName;
   }
 

python/runtime/cudaq/algorithms/py_translate.cpp

@@ -66,7 +66,7 @@ path, i.e., the trace, of the provided `kernel`.
 Args:
   format (str): format to translate to, <name[:version]>.
      Available format names: `qir`, `qir-full`, `qir-base`, `qir-adaptive`,
-     `openqasm2`. QIR versions: `0.1` and `0.2`.
+     `openqasm2`. QIR versions: `0.1` and `1.0`.
   kernel (:class:`Kernel`): The :class:`Kernel` to translate.
   *arguments (Optional[Any]): The concrete values to evaluate the kernel
     function at. Leave empty if the kernel doesn't accept any arguments.

python/tests/backends/test_QCI.py

@@ -10,8 +10,9 @@
 from multiprocessing import Process
 
 import cudaq
-from cudaq import spin
+import numpy as np
 import pytest
+from cudaq import spin
 from network_utils import check_server_connection
 
 try:
@@ -64,7 +65,6 @@ def test_sample():
     kernel.h(qubits[0])
     kernel.cx(qubits[0], qubits[1])
     kernel.mz(qubits)
-    print(kernel)
 
     # Run sample synchronously
     counts = cudaq.sample(kernel)
@@ -80,7 +80,6 @@ def test_sample():
     assert "11" in counts
 
     future = cudaq.sample_async(kernel)
-    print(future)
 
     # Persist the future to a file
     futureAsString = str(future)
@@ -105,7 +104,7 @@ def ansatz(theta: float):
         0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)
 
     # Run the observe task on synchronously
-    res = cudaq.observe(ansatz, hamiltonian, .59, shots_count=100)
+    res = cudaq.observe(ansatz, hamiltonian, .59, shots_count=200)
     assert assert_close(res.expectation())
 
     # Launch it asynchronously, enters the job into the queue
@@ -117,7 +116,6 @@ def ansatz(theta: float):
     # Launch the job async, job goes in the queue, and
     # we're free to dump the future to file
     future = cudaq.observe_async(ansatz, hamiltonian, .59, shots_count=100)
-    print(future)
     futureAsString = str(future)
 
     # Later you can come back and read it in
@@ -128,6 +126,129 @@ def ansatz(theta: float):
     assert assert_close(res.expectation())
 
 
+def test_u3_decomposition():
+
+    @cudaq.kernel
+    def kernel():
+        qubit = cudaq.qubit()
+        u3(0.0, np.pi / 2, np.pi, qubit)
+        mz(qubit)
+
+    # Test here is that this runs without error
+    cudaq.sample(kernel, shots_count=10)
+
+
+def test_u3_ctrl_decomposition():
+
+    @cudaq.kernel
+    def kernel():
+        control = cudaq.qubit()
+        target = cudaq.qubit()
+        u3.ctrl(0.0, np.pi / 2, np.pi, control, target)
+        mz(control)
+        mz(target)
+
+    # Test here is that this runs without error
+    cudaq.sample(kernel, shots_count=10)
+
+
+def test_state_preparation():
+
+    @cudaq.kernel
+    def kernel(vec: list[complex]):
+        qubits = cudaq.qvector(vec)
+        mz(qubits)
+
+    state = [1. / np.sqrt(2.), 1. / np.sqrt(2.), 0., 0.]
+    counts = cudaq.sample(kernel, state)
+    assert '00' in counts
+    assert '10' in counts
+    assert not '01' in counts
+    assert not '11' in counts
+
+
+def test_state_synthesis_from_simulator():
+
+    @cudaq.kernel
+    def kernel(state: cudaq.State):
+        qubits = cudaq.qvector(state)
+        mz(qubits)
+
+    state = cudaq.State.from_data(
+        np.array([1. / np.sqrt(2.), 1. / np.sqrt(2.), 0., 0.], dtype=complex))
+
+    counts = cudaq.sample(kernel, state)
+    assert "00" in counts
+    assert "10" in counts
+    assert len(counts) == 2
+
+    synthesized = cudaq.synthesize(kernel, state)
+    counts = cudaq.sample(synthesized)
+    assert '00' in counts
+    assert '10' in counts
+    assert len(counts) == 2
+
+
+def test_state_synthesis():
+
+    @cudaq.kernel
+    def init(n: int):
+        q = cudaq.qvector(n)
+        x(q[0])
+
+    @cudaq.kernel
+    def kernel(s: cudaq.State):
+        q = cudaq.qvector(s)
+        x(q[1])
+        mz(q)
+
+    s = cudaq.get_state(init, 2)
+    counts = cudaq.sample(kernel, s)
+    assert '11' in counts
+    assert len(counts) == 1
+
+
+def test_exp_pauli():
+
+    @cudaq.kernel
+    def test():
+        q = cudaq.qvector(2)
+        exp_pauli(1.0, q, "XX")
+        mz(q)
+
+    counts = cudaq.sample(test)
+    assert '00' in counts
+    assert '11' in counts
+    assert not '01' in counts
+    assert not '10' in counts
+
+
+def test_run():
+
+    @cudaq.kernel
+    def simple(numQubits: int) -> int:
+        qubits = cudaq.qvector(numQubits)
+        h(qubits.front())
+        for i, qubit in enumerate(qubits.front(numQubits - 1)):
+            x.ctrl(qubit, qubits[i + 1])
+        result = 0
+        for i in range(numQubits):
+            if mz(qubits[i]):
+                result += 1
+        return result
+
+    shots = 100
+    qubitCount = 4
+    results = cudaq.run(simple, qubitCount, shots_count=shots)
+    assert len(results) == shots
+    non_zero_count = 0
+    for result in results:
+        assert result == 0 or result == qubitCount  # 00..0 or 1...11
+        if result == qubitCount:
+            non_zero_count += 1
+    assert non_zero_count > 0
+
+
 # leave for gdb debugging
 if __name__ == "__main__":
     loc = os.path.abspath(__file__)

python/tests/mlir/qir_profile.py

@@ -33,7 +33,7 @@ def my_kernel():
         x(q)
         mz(q)
 
-    # This device requires qir:0.2
+    # This device requires qir:1.0
     cudaq.set_target('quantinuum', emulate=True, machine='Helios-1E')
     result = cudaq.sample(my_kernel)
 

python/tests/parallel/test_mqpu.py

@@ -6,9 +6,15 @@
 # the terms of the Apache License 2.0 which accompanies this distribution.     #
 # ============================================================================ #
 
-import cudaq, os, pytest, random, timeit
-from cudaq import spin
+import os
+import random
+import time
+import timeit
+
+import cudaq
 import numpy as np
+import pytest
+from cudaq import spin
 
 skipIfNoMQPU = pytest.mark.skipif(
     not (cudaq.num_available_gpus() > 0 and cudaq.has_target('nvidia-mqpu')),
@@ -18,6 +24,11 @@
 @pytest.fixture(autouse=True)
 def do_something():
     cudaq.set_target('nvidia-mqpu')
+    try:
+        assert cudaq.get_target().num_qpus(
+        ) > 0, "No QPUs available after target set"
+    except Exception as e:
+        pytest.skip(f"MQPU setup failed: {str(e)}")
     yield
     cudaq.__clearKernelRegistries()
     cudaq.reset_target()
@@ -155,12 +166,6 @@ def parameterized_kernel(n: int, layers: int, params: list[float],
 
 
 def check_accuracy(entity):
-    target = cudaq.get_target()
-    numQpus = target.num_qpus()
-    if numQpus == 0:
-        pytest.skip("No QPUs available for target, skipping test")
-    else:
-        print(f"Target: {target}, NumQPUs: {numQpus}")
     # Define its spin Hamiltonian.
     hamiltonian = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(
         0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)

runtime/common/CodeGenConfig.cpp

@@ -28,7 +28,7 @@ std::vector<std::string> splitString(const std::string &s,
 
 /// @brief Helper to parse `codegen` translation, with optional feature
 /// annotation.
-// e.g., "qir-adaptive:0.2:int_computations,float_computations"
+// e.g., "qir-adaptive:1.0:int_computations,float_computations"
 static std::tuple<std::string, std::string, std::vector<std::string>>
 parseCodeGenTranslationString(const std::string &settingStr) {
   auto transportFields = splitString(settingStr, ':');
@@ -100,10 +100,10 @@ cudaq::parseCodeGenTranslation(const std::string &codegenTranslation) {
       config.version = QirVersion::version_0_1;
       config.qir_major_version = 0;
       config.qir_minor_version = 1;
-    } else if (codeGenVersion == "0.2") {
-      config.version = QirVersion::version_0_2;
-      config.qir_major_version = 0;
-      config.qir_minor_version = 2;
+    } else if (codeGenVersion == "1.0") {
+      config.version = QirVersion::version_1_0;
+      config.qir_major_version = 1;
+      config.qir_minor_version = 0;
     } else {
       throw std::runtime_error(
           fmt::format("Unsupported QIR version '{}', codegen setting: {}",

runtime/common/CodeGenConfig.h

@@ -15,7 +15,7 @@
 
 namespace cudaq {
 
-enum struct QirVersion { version_0_1, version_0_2 };
+enum struct QirVersion { version_0_1, version_1_0 };
 
 /// @brief `Codegen` configuration.
 /// Note: it is currently flattened to contain all possible options
@@ -52,7 +52,7 @@ struct CodeGenConfig {
 
 /// @brief Helper to parse `codegen` translation, with optional feature
 /// annotation.
-/// e.g., `qir-adaptive:0.2:int_computations,float_computations`.
+/// e.g., `qir-adaptive:1.0:int_computations,float_computations`.
 /// Handles errors and returns structured configuration.
 CodeGenConfig parseCodeGenTranslation(const std::string &codegenTranslation);
 } // namespace cudaq

runtime/common/RecordLogParser.cpp

@@ -83,7 +83,7 @@ void cudaq::RecordLogParser::handleMetadata(
   if (entries.size() < 2 || entries.size() > 3)
     cudaq::info("Unexpected METADATA record: {}. Ignored.\n", entries);
   if (entries.size() == 3) {
-    if (entries[1] == cudaq::opt::qir0_2::RequiredResultsAttrName ||
+    if (entries[1] == cudaq::opt::qir1_0::RequiredResultsAttrName ||
         entries[1] == cudaq::opt::qir0_1::RequiredResultsAttrName) {
       metadata[ResultCountMetadataName] = entries[2];
     } else {