Add multi-control functionality

include/mqt-core/zx/FunctionalityConstruction.hpp

@@ -113,6 +113,18 @@ class FunctionalityConstruction {
                const std::optional<double>& unconvertedBeta = std::nullopt);
   static void addCcx(ZXDiagram& diag, Qubit ctrl0, Qubit ctrl1, Qubit target,
                      std::vector<Vertex>& qubits);
+  static void addCcz(ZXDiagram& diag, Qubit ctrl0, Qubit ctrl1, Qubit target,
+                     std::vector<Vertex>& qubits);
+  static void addCrz(ZXDiagram& diag, const PiExpression& phase,
+                     const Qubit control, const Qubit target,
+                     std::vector<Vertex>& qubits);
+  static void addMcrz(ZXDiagram& diag, const PiExpression& phase,
+                      std::vector<Qubit> controls, const Qubit target,
+                      std::vector<Vertex>& qubits);
+  static void addMcx(ZXDiagram& diag, std::vector<Qubit> controls,
+                     const Qubit target, std::vector<Vertex>& qubits);
+  static void addMcz(ZXDiagram& diag, std::vector<Qubit> controls,
+                     const Qubit target, std::vector<Vertex>& qubits);
   static op_it parseOp(ZXDiagram& diag, op_it it, op_it end,
                        std::vector<Vertex>& qubits, const qc::Permutation& p);
   static op_it parseCompoundOp(ZXDiagram& diag, op_it it, op_it end,

src/zx/FunctionalityConstruction.cpp

@@ -307,6 +307,147 @@
   addCnot(diag, ctrl0, ctrl1, qubits);
 }
 
+void FunctionalityConstruction::addCcz(ZXDiagram& diag, const Qubit ctrl0,
+                                       const Qubit ctrl1, const Qubit target,
+                                       std::vector<Vertex>& qubits) {
+
+  addCnot(diag, ctrl1, target, qubits);
+  addZSpider(diag, target, qubits, PiExpression(PiRational(-1, 4)));
+  addCnot(diag, ctrl0, target, qubits);
+  addZSpider(diag, target, qubits, PiExpression(PiRational(1, 4)));
+  addCnot(diag, ctrl1, target, qubits);
+  addZSpider(diag, ctrl1, qubits, PiExpression(PiRational(1, 4)));
+  addZSpider(diag, target, qubits, PiExpression(PiRational(-1, 4)));
+  addCnot(diag, ctrl0, target, qubits);
+  addZSpider(diag, target, qubits, PiExpression(PiRational(1, 4)));
+  addCnot(diag, ctrl0, ctrl1, qubits);
+  addZSpider(diag, ctrl0, qubits, PiExpression(PiRational(1, 4)));
+  addZSpider(diag, ctrl1, qubits, PiExpression(PiRational(-1, 4)));
+  addZSpider(diag, target, qubits, PiExpression(PiRational(0, 1)),
+             EdgeType::Hadamard);
+  addCnot(diag, ctrl0, ctrl1, qubits);
+  addZSpider(diag, target, qubits, PiExpression(), EdgeType::Hadamard);
+}
+
+void FunctionalityConstruction::addCrz(ZXDiagram& diag,
+                                       const PiExpression& phase,
+                                       const Qubit control, const Qubit target,
+                                       std::vector<Vertex>& qubits) {
+  addCnot(diag, target, control, qubits);
+  addZSpider(diag, control, qubits, -phase / 2);
+  addZSpider(diag, target, qubits, phase / 2);
+  addCnot(diag, target, control, qubits);
+}
+
+void FunctionalityConstruction::addMcrz(ZXDiagram& diag,
+                                        const PiExpression& phase,
+                                        std::vector<Qubit> controls,
+                                        const Qubit target,
+                                        std::vector<Vertex>& qubits) {
+
+  switch (controls.size()) {
+  case 0:
+    addZSpider(diag, target, qubits, phase);
+    return;
+  case 1:
+    addCrz(diag, phase, controls.front(), target, qubits);
+    return;
+  default:
+    const Qubit nextControl = controls.back();
+    controls.pop_back();
+
+    addCrz(diag, phase / 2, nextControl, target, qubits);
+    addMcx(diag, controls, target, qubits);
+    addCrz(diag, -phase / 2, nextControl, target, qubits);
+    addMcx(diag, controls, target, qubits);
+  }
+}
+
+void FunctionalityConstruction::addMcx(ZXDiagram& diag,
+                                       std::vector<Qubit> controls,
+                                       const Qubit target,
+                                       std::vector<Vertex>& qubits) {
+
+  switch (controls.size()) {
+  case 0:
+    addXSpider(diag, target, qubits, PiExpression(PiRational(1, 1)));
+    return;
+  case 1:
+    addCnot(diag, controls.front(), target, qubits);
+    return;
+  case 2:
+    addCcx(diag, controls.front(), controls.back(), target, qubits);
+    return;
+  default:
+    const auto half = static_cast<std::ptrdiff_t>((controls.size() + 1) / 2);
+    const std::vector<Qubit> first(controls.begin(), controls.begin() + half);
+    std::vector<Qubit> second(controls.begin() + half, controls.end());
+
+    if (qubits.size() > controls.size() + 1) {
+      controls.push_back(target);
+      Qubit anc = -1;
+      auto it = std::ranges::find_if(qubits, [&](Vertex x) {
+        return std::ranges::find(controls, static_cast<Qubit>(x)) ==
+               controls.end();
+      });
+      if (it == qubits.end()) {
+        throw ZXException("No ancilla qubit available for MCX decomposition");
+      } else {
+        anc = static_cast<Qubit>(*it);
+      }
+      controls.pop_back();
+      second.push_back(anc);
+
+      addMcx(diag, first, anc, qubits);
+      addMcx(diag, second, target, qubits);
+
+      addMcx(diag, first, anc, qubits);
+      addMcx(diag, second, target, qubits);
+    } else {
+      addRx(diag, PiExpression(PiRational(1, 4)), target, qubits);
+      addMcz(diag, second, target, qubits);
+      addRx(diag, PiExpression(-PiRational(1, 4)), target, qubits);
+      addMcx(diag, first, target, qubits);
+
+      addRx(diag, PiExpression(PiRational(1, 4)), target, qubits);
+      addMcz(diag, second, target, qubits);
+      addRx(diag, PiExpression(-PiRational(1, 4)), target, qubits);
+      addMcx(diag, first, target, qubits);
+      const Qubit lastControl = controls.back();
+      controls.pop_back();
+      addMcrz(diag, PiExpression(PiRational(1, 2)), controls, lastControl,
+              qubits);
+    }
+  }
+}
+
+void FunctionalityConstruction::addMcz(ZXDiagram& diag,
+                                       std::vector<Qubit> controls,
+                                       const Qubit target,
+                                       std::vector<Vertex>& qubits) {
+
+  switch (controls.size()) {
+  case 0:
+    addZSpider(diag, target, qubits, PiExpression(PiRational(1, 1)));
+    return;
+  case 1:
+    addCrz(diag, PiExpression(PiRational(1, 1)), controls.front(), target,
+           qubits);
+    return;
+  case 2:
+    addCcz(diag, controls.front(), controls.back(), target, qubits);
+    return;
+  default:
+    const Qubit nextControl = controls.back();
+    controls.pop_back();
+
+    addCrz(diag, PiExpression(PiRational(1, 2)), nextControl, target, qubits);
+    addMcx(diag, controls, target, qubits);
+    addCrz(diag, PiExpression(-PiRational(1, 2)), nextControl, target, qubits);
+    addMcx(diag, controls, target, qubits);
+  }
+}
+
 FunctionalityConstruction::op_it
 FunctionalityConstruction::parseOp(ZXDiagram& diag, op_it it, op_it end,
                                    std::vector<Vertex>& qubits,
@@ -538,6 +679,9 @@
                    qubits[static_cast<std::size_t>(target)],
                    EdgeType::Hadamard);
       break;
+    case qc::OpType::RZ:
+      addCrz(diag, parseParam(op.get(), 0), ctrl, target, qubits);
+      break;
 
     case qc::OpType::I:
       break;
@@ -578,16 +722,42 @@
         ctrl1 = static_cast<Qubit>(p.at(ctrl.qubit));
       }
     }
+    std::vector<Qubit> controls;
+    for (const auto& ctrl : op->getControls()) {
+      controls.push_back(static_cast<Qubit>(p.at(ctrl.qubit)));
+    }
     switch (op->getType()) {
     case qc::OpType::X:
       addCcx(diag, ctrl0, ctrl1, target, qubits);
       break;
-
+    case qc::OpType::Z:
+      addCcz(diag, ctrl0, ctrl1, target, qubits);
+      break;
+    case qc::OpType::RZ:
+      addMcrz(diag, parseParam(op.get(), 0), controls, target, qubits);
+      break;
+    default:
+      throw ZXException("Unsupported Multi-control operation: " +
+                        qc::toString(op->getType()));
+    }
+  } else if (op->getNtargets() == 1) {
+    const auto target = static_cast<Qubit>(p.at(op->getTargets().front()));
+    std::vector<Qubit> controls;
+    for (const auto& ctrl : op->getControls()) {
+      controls.push_back(static_cast<Qubit>(p.at(ctrl.qubit)));
+    }
+    switch (op->getType()) {
+    case qc::OpType::X:
+      addMcx(diag, controls, target, qubits);
+      break;
     case qc::OpType::Z:
       addZSpider(diag, target, qubits, PiExpression(), EdgeType::Hadamard);
-      addCcx(diag, ctrl0, ctrl1, target, qubits);
+      addMcx(diag, controls, target, qubits);
       addZSpider(diag, target, qubits, PiExpression(), EdgeType::Hadamard);
       break;
+    case qc::OpType::RZ:
+      addMcrz(diag, parseParam(op.get(), 0), controls, target, qubits);
+      break;
     default:
       throw ZXException("Unsupported Multi-control operation: " +
                         qc::toString(op->getType()));
@@ -701,15 +871,26 @@
     case qc::OpType::S:
     case qc::OpType::Tdg:
     case qc::OpType::Sdg:
+    case qc::OpType::RZ:
       return true;
 
     default:
       return false;
     }
   } else if (op->getNcontrols() == 2) {
     switch (op->getType()) {
     case qc::OpType::X:
     case qc::OpType::Z:
+    case qc::OpType::RZ:
+      return true;
+    default:
+      return false;
+    }
+  } else if (op->getNtargets() == 1) {
+    switch (op->getType()) {
+    case qc::OpType::X:
+    case qc::OpType::Z:
+    case qc::OpType::RZ:
       return true;
     default:
       return false;

test/zx/test_zx_functionality.cpp

@@ -219,14 +219,143 @@ TEST_F(ZXFunctionalityTest, Compound) {
   EXPECT_TRUE(diag.isIdentity());
 }
 
-TEST_F(ZXFunctionalityTest, UnsupportedMultiControl) {
+// TEST_F(ZXFunctionalityTest, UnsupportedMultiControl) {
+//   using namespace qc::literals;
+//   qc = qc::QuantumComputation(4);
+//   qc.mcx({1, 2, 3}, 0);
+//   EXPECT_FALSE(FunctionalityConstruction::transformableToZX(&qc));
+//   EXPECT_THROW(const ZXDiagram diag =
+//                    FunctionalityConstruction::buildFunctionality(&qc),
+//                ZXException);
+// }
+
+TEST_F(ZXFunctionalityTest, CRZ) {
+  using namespace qc::literals;
+  qc = qc::QuantumComputation(2);
+  qc.crz(PI / 2, 0, 1);
+
+  auto qcPrime = qc::QuantumComputation(2);
+
+  qcPrime.cx(0, 1);
+  qcPrime.rz(-PI / 4, 1);
+  qcPrime.cx(0, 1);
+  qcPrime.rz(PI / 4, 1);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  auto dPrime = FunctionalityConstruction::buildFunctionality(&qcPrime);
+
+  d.concat(dPrime.invert());
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
+}
+
+TEST_F(ZXFunctionalityTest, MultiControlX) {
   using namespace qc::literals;
   qc = qc::QuantumComputation(4);
   qc.mcx({1, 2, 3}, 0);
-  EXPECT_FALSE(FunctionalityConstruction::transformableToZX(&qc));
-  EXPECT_THROW(const ZXDiagram diag =
-                   FunctionalityConstruction::buildFunctionality(&qc),
-               ZXException);
+
+  auto qcPrime = qc::QuantumComputation(4);
+  qcPrime.mcx({1, 2, 3}, 0);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  auto dPrime = FunctionalityConstruction::buildFunctionality(&qcPrime);
+
+  d.concat(dPrime.invert());
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
+}
+
+TEST_F(ZXFunctionalityTest, MultiControlXLarger) {
+  using namespace qc::literals;
+  qc = qc::QuantumComputation(5);
+  qc.mcx({1, 2, 3}, 0);
+
+  auto qcPrime = qc::QuantumComputation(5);
+  qcPrime.mcx({1, 2}, 4);
+  qcPrime.mcx({3, 4}, 0);
+  qcPrime.mcx({1, 2}, 4);
+  qcPrime.mcx({3, 4}, 0);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  auto dPrime = FunctionalityConstruction::buildFunctionality(&qcPrime);
+
+  d.concat(dPrime.invert());
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
+}
+
+TEST_F(ZXFunctionalityTest, MultiControlX0) {
+  using namespace qc::literals;
+  qc = qc::QuantumComputation(1);
+  qc.mcx({}, 0);
+
+  auto qcPrime = qc::QuantumComputation(1);
+
+  qcPrime.x(0);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  auto dPrime = FunctionalityConstruction::buildFunctionality(&qcPrime);
+
+  d.concat(dPrime.invert());
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
+}
+
+TEST_F(ZXFunctionalityTest, MultiControlX1) {
+  using namespace qc::literals;
+  qc = qc::QuantumComputation(2);
+  qc.mcx({1}, 0);
+
+  auto qcPrime = qc::QuantumComputation(2);
+
+  qcPrime.cx(1, 0);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  auto dPrime = FunctionalityConstruction::buildFunctionality(&qcPrime);
+
+  d.concat(dPrime.invert());
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
+}
+
+TEST_F(ZXFunctionalityTest, MultiCRZ) {
+  using namespace qc::literals;
+  qc = qc::QuantumComputation(3);
+  qc.mcrz(PI / 4, {1, 2}, 0);
+  qc.mcrz(-PI / 4, {1, 2}, 0);
+
+  auto d = FunctionalityConstruction::buildFunctionality(&qc);
+
+  fullReduce(d);
+
+  EXPECT_TRUE(d.isIdentity());
+  EXPECT_TRUE(d.globalPhaseIsZero());
+  EXPECT_TRUE(d.connected(d.getInput(0), d.getOutput(0)));
 }
 
 TEST_F(ZXFunctionalityTest, UnsupportedControl) {