add unittest for weyl decomposition

Author: taminob

mlir/unittests/CMakeLists.txt

@@ -7,3 +7,4 @@
 # Licensed under the MIT License
 
 add_subdirectory(translation)
+add_subdirectory(decomposition)

mlir/unittests/decomposition/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+set(testname "mqt-core-mlir-decomposition-test")
+file(GLOB_RECURSE DECOMPOSITION_TEST_SOURCES *.cpp)
+
+if(NOT TARGET ${testname})
+  # create an executable in which the tests will be stored
+  add_executable(${testname} ${DECOMPOSITION_TEST_SOURCES})
+  # link the Google test infrastructure and a default main function to the test executable.
+  target_link_libraries(${testname} PRIVATE GTest::gmock GTest::gtest_main LLVMFileCheck MLIRPass
+                                            MLIRTransforms MLIRMQTOptTransforms)
+  # discover tests
+  gtest_discover_tests(${testname} DISCOVERY_TIMEOUT 60)
+  set_target_properties(${testname} PROPERTIES FOLDER unittests)
+endif()

mlir/unittests/decomposition/test_weyl_decomposition.cpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#include "mlir/Dialect/MQTOpt/Transforms/Decomposition/WeylDecomposition.h"
+
+#include <gtest/gtest.h>
+
+using namespace mqt::ir::opt;
+using namespace mqt::ir::opt::decomposition;
+
+namespace {
+[[nodiscard]] matrix4x4 randomUnitaryMatrix() {
+  [[maybe_unused]] static auto initializeRandom = []() {
+    // Eigen uses std::rand() internally, use fixed seed for deterministic
+    // testing behavior
+    std::srand(123456UL);
+    return true;
+  }();
+  matrix4x4 randomMatrix = matrix4x4::Random();
+  Eigen::HouseholderQR<matrix4x4> qr{};
+  qr.compute(randomMatrix);
+  matrix4x4 unitaryMatrix = qr.householderQ();
+  assert(helpers::isUnitaryMatrix(unitaryMatrix));
+  return unitaryMatrix;
+}
+} // namespace
+
+class WeylDecompositionTest : public testing::TestWithParam<matrix4x4> {
+public:
+  [[nodiscard]] static matrix4x4
+  restore(const TwoQubitWeylDecomposition& decomposition) {
+    return k1(decomposition) * can(decomposition) * k2(decomposition) *
+           globalPhaseFactor(decomposition);
+  }
+
+  [[nodiscard]] static qfp
+  globalPhaseFactor(const TwoQubitWeylDecomposition& decomposition) {
+    return std::exp(IM * decomposition.globalPhase);
+  }
+  [[nodiscard]] static matrix4x4
+  can(const TwoQubitWeylDecomposition& decomposition) {
+    return decomposition.getCanonicalMatrix();
+  }
+  [[nodiscard]] static matrix4x4
+  k1(const TwoQubitWeylDecomposition& decomposition) {
+    return helpers::kroneckerProduct(decomposition.k1l, decomposition.k1r);
+  }
+  [[nodiscard]] static matrix4x4
+  k2(const TwoQubitWeylDecomposition& decomposition) {
+    return helpers::kroneckerProduct(decomposition.k2l, decomposition.k2r);
+  }
+};
+
+TEST_P(WeylDecompositionTest, TestExact) {
+  const auto& originalMatrix = GetParam();
+  auto decomposition = TwoQubitWeylDecomposition::create(originalMatrix, 1.0);
+  auto restoredMatrix = restore(decomposition);
+
+  EXPECT_TRUE(restoredMatrix.isApprox(originalMatrix))
+      << "RESULT:\n"
+      << restoredMatrix << '\n';
+}
+
+TEST_P(WeylDecompositionTest, TestApproximation) {
+  const auto& originalMatrix = GetParam();
+  auto decomposition =
+      TwoQubitWeylDecomposition::create(originalMatrix, 1.0 - 1e-12);
+  auto restoredMatrix = restore(decomposition);
+
+  EXPECT_TRUE(restoredMatrix.isApprox(originalMatrix))
+      << "RESULT:\n"
+      << restoredMatrix << '\n';
+}
+
+TEST(WeylDecompositionTest, Random) {
+  auto stopTime = std::chrono::steady_clock::now() + std::chrono::seconds{10};
+  auto iterations = 0;
+  while (std::chrono::steady_clock::now() < stopTime) {
+    auto originalMatrix = randomUnitaryMatrix();
+    auto decomposition =
+        TwoQubitWeylDecomposition::create(originalMatrix, 1.0 - 1e-12);
+    auto restoredMatrix = WeylDecompositionTest::restore(decomposition);
+
+    EXPECT_TRUE(restoredMatrix.isApprox(originalMatrix))
+        << "ORIGINAL:\n"
+        << originalMatrix << '\n'
+        << "RESULT:\n"
+        << restoredMatrix << '\n';
+    ++iterations;
+  }
+
+  RecordProperty("iterations", iterations);
+  std::cerr << "Iterations: " << iterations << '\n';
+}
+
+INSTANTIATE_TEST_CASE_P(
+    SingleQubitMatrices, WeylDecompositionTest,
+    ::testing::Values(helpers::kroneckerProduct(IDENTITY_GATE, IDENTITY_GATE),
+                      helpers::kroneckerProduct(rzMatrix(1.0), ryMatrix(3.1)),
+                      helpers::kroneckerProduct(IDENTITY_GATE, rxMatrix(0.1))));
+
+INSTANTIATE_TEST_CASE_P(
+    TwoQubitMatrices, WeylDecompositionTest,
+    ::testing::Values(
+        rzzMatrix(2.0), ryyMatrix(1.0) * rzzMatrix(3.0) * rxxMatrix(2.0),
+        TwoQubitWeylDecomposition{1.5, -0.2, 0.0}.getCanonicalMatrix() *
+            helpers::kroneckerProduct(rxMatrix(1.0), IDENTITY_GATE),
+        helpers::kroneckerProduct(rxMatrix(1.0), ryMatrix(1.0)) *
+            TwoQubitWeylDecomposition{1.1, 0.2, 3.0}.getCanonicalMatrix() *
+            helpers::kroneckerProduct(rxMatrix(1.0), IDENTITY_GATE),
+        helpers::kroneckerProduct(H_GATE, IPZ) *
+            getTwoQubitMatrix({.type = qc::X, .qubitId = {0, 1}}) *
+            helpers::kroneckerProduct(IPX, IPY)));