🐇 Address Rabbit's Comments

Author: simon1hofmann

mlir/unittests/Dialect/QCO/Transforms/Decomposition/decomposition_test_utils.h

@@ -10,9 +10,7 @@
 
 #pragma once
 
-#include "TestCaseUtils.h"
 #include "mlir/Dialect/QCO/Transforms/Decomposition/Helpers.h"
-#include "mlir/Dialect/QCO/Transforms/Decomposition/UnitaryMatrices.h"
 
 #include <Eigen/Core>
 #include <Eigen/QR>
@@ -23,15 +21,6 @@
 
 namespace mlir::qco::decomposition_test {
 
-using mqt::test::isEquivalentUpToGlobalPhase;
-
-/// Standard `U3(theta, phi, lambda)` matrix. Thin wrapper over the library
-/// `uMatrix` so every test uses the same implementation.
-[[nodiscard]] inline Eigen::Matrix2cd u3Matrix(double theta, double phi,
-                                               double lambda) {
-  return decomposition::uMatrix(theta, phi, lambda);
-}
-
 template <typename MatrixType>
 [[nodiscard]] MatrixType randomUnitaryMatrix(std::mt19937& rng) {
   static_assert(MatrixType::RowsAtCompileTime != Eigen::Dynamic &&

mlir/unittests/Dialect/QCO/Transforms/Decomposition/test_euler_decomposition.cpp

@@ -46,10 +46,9 @@ static std::size_t countGatesOfType(const OneQubitGateSequence& seq,
 /// Compare ``seq.getUnitaryMatrix()`` to ``u`` embedded on qubit 0 (4×4
 /// layout).
 static bool sequenceMatchesSingleQubitMatrix(const Eigen::Matrix2cd& u,
-                                             const OneQubitGateSequence& seq,
-                                             double tol = 1e-10) {
+                                             const OneQubitGateSequence& seq) {
   const Eigen::Matrix4cd expanded = expandToTwoQubits(u, 0);
-  return expanded.isApprox(seq.getUnitaryMatrix(), tol);
+  return expanded.isApprox(seq.getUnitaryMatrix());
 }
 
 // NOLINTNEXTLINE(misc-use-internal-linkage) -- gtest `TEST_P` at global scope
@@ -117,10 +116,19 @@ TEST(EulerDecompositionTest, ZyzAnglesFromUnitaryReconstructHadamard) {
 
   const auto angles =
       EulerDecomposition::anglesFromUnitary(hadamard, EulerBasis::ZYZ);
+  OneQubitGateSequence zyzSeq{
+      .gates =
+          {
+              {.type = GateKind::RZ, .parameter = {angles[2]}},
+              {.type = GateKind::RY, .parameter = {angles[0]}},
+              {.type = GateKind::RZ, .parameter = {angles[1]}},
+          },
+      .globalPhase = angles[3],
+  };
   const Eigen::Matrix2cd reconstructed =
-      u3Matrix(angles[0], angles[1], angles[2]);
+      EulerDecompositionTest::restore(zyzSeq);
 
-  EXPECT_TRUE(isEquivalentUpToGlobalPhase(hadamard, reconstructed));
+  EXPECT_TRUE(reconstructed.isApprox(hadamard));
 }
 
 TEST(EulerDecompositionTest, NativeEulerBasesRandomReconstruction) {
@@ -134,7 +142,7 @@ TEST(EulerDecompositionTest, NativeEulerBasesRandomReconstruction) {
     const double phase = angleDist(rng);
     const Eigen::Matrix2cd unitary =
         std::exp(std::complex<double>(0.0, phase)) *
-        u3Matrix(theta, phi, lambda);
+        decomposition::uMatrix(theta, phi, lambda);
     const Eigen::Matrix4cd expanded = expandToTwoQubits(unitary, 0);
 
     const auto u3Seq = EulerDecomposition::generateCircuit(
@@ -144,10 +152,8 @@ TEST(EulerDecompositionTest, NativeEulerBasesRandomReconstruction) {
     const auto zsxxSeq = EulerDecomposition::generateCircuit(
         EulerBasis::ZSXX, unitary, true, std::nullopt);
 
-    EXPECT_TRUE(
-        isEquivalentUpToGlobalPhase(expanded, u3Seq.getUnitaryMatrix()));
-    EXPECT_TRUE(
-        isEquivalentUpToGlobalPhase(expanded, zsxSeq.getUnitaryMatrix()));
+    EXPECT_TRUE(expanded.isApprox(u3Seq.getUnitaryMatrix()));
+    EXPECT_TRUE(expanded.isApprox(zsxSeq.getUnitaryMatrix()));
     EXPECT_TRUE(sequenceMatchesSingleQubitMatrix(unitary, zsxSeq));
     EXPECT_TRUE(sequenceMatchesSingleQubitMatrix(unitary, zsxxSeq));
 

mlir/unittests/TestCaseUtils.h

@@ -18,8 +18,6 @@
 #include <llvm/Support/raw_ostream.h>
 #include <mlir/IR/BuiltinOps.h>
 
-#include <cmath>
-#include <complex> // NOLINT(misc-include-cleaner)
 #include <cstddef>
 #include <cstdlib>
 #include <string>
@@ -28,26 +26,6 @@
 
 namespace mqt::test {
 
-/**
- * Check whether two unitary matrices are equal up to a single unit-modulus
- * global phase factor.
- *
- * The comparison is symmetric and numerically stable in the sense that a near
- * zero overlap (``|trace(rhs^H * lhs)| <= atol``) is treated as "not
- * equivalent" to avoid division by a tiny number.
- */
-template <typename Matrix>
-[[nodiscard]] bool isEquivalentUpToGlobalPhase(const Matrix& lhs,
-                                               const Matrix& rhs,
-                                               double atol = 1e-10) {
-  const auto overlap = (rhs.adjoint() * lhs).trace();
-  if (std::abs(overlap) <= atol) {
-    return false;
-  }
-  const auto factor = overlap / std::abs(overlap);
-  return lhs.isApprox(factor * rhs, atol);
-}
-
 template <typename BuilderT> struct NamedBuilder {
   const char* name = nullptr;
   void (*fn)(BuilderT&) = nullptr;