Added two-qubit zx tests and made qcec compatible to new core version.

include/checker/dd/simulation/StateGenerator.hpp

@@ -8,6 +8,7 @@
 #include "StateType.hpp"
 #include "algorithms/RandomCliffordCircuit.hpp"
 #include "checker/dd/TaskManager.hpp"
+#include "dd/Node.hpp"
 #include "dd/Package.hpp"
 #include "dd/Simulation.hpp"
 
@@ -153,8 +154,9 @@ class StateGenerator {
     // add |0> edges for all the ancillary qubits
     auto initial = stabilizer;
     for (std::size_t p = randomQubits; p < totalQubits; ++p) {
-      initial = dd->makeDDNode(static_cast<dd::Qubit>(p),
-                               std::array{initial, qc::VectorDD::zero});
+      initial = dd->makeDDNode(
+          static_cast<dd::Qubit>(p),
+          std::array<dd::vEdge, 2>{initial, qc::VectorDD::zero()});
     }
 
     // return the resulting decision diagram

src/EquivalenceCheckingManager.cpp

@@ -179,8 +179,8 @@ void EquivalenceCheckingManager::run() {
 EquivalenceCheckingManager::EquivalenceCheckingManager(
     const qc::QuantumComputation& circ1, const qc::QuantumComputation& circ2,
     Configuration config)
-    : qc1(circ1.size() > circ2.size() ? circ2.clone() : circ1.clone()),
-      qc2(circ1.size() > circ2.size() ? circ1.clone() : circ2.clone()),
+    : qc1(circ1.size() > circ2.size() ? circ2 : circ1),
+      qc2(circ1.size() > circ2.size() ? circ1 : circ2),
       configuration(std::move(config)) {
   // clones both circuits (the circuit with fewer gates always gets to be qc1)
 

src/checker/dd/applicationscheme/GateCostApplicationScheme.cpp

@@ -18,16 +18,16 @@ legacyCostFunction(const GateCostLookupTableKeyType& key) noexcept {
     case qc::Y:
     case qc::Z:
     case qc::S:
-    case qc::Sdag:
+    case qc::Sdg:
     case qc::T:
-    case qc::Tdag:
-    case qc::Phase:
+    case qc::Tdg:
+    case qc::P:
     case qc::U2:
-    case qc::U3:
+    case qc::U:
     case qc::SX:
-    case qc::SXdag:
+    case qc::SXdg:
     case qc::V:
-    case qc::Vdag:
+    case qc::Vdg:
     case qc::RX:
     case qc::RY:
     case qc::RZ:
@@ -51,36 +51,36 @@ legacyCostFunction(const GateCostLookupTableKeyType& key) noexcept {
   switch (gate) {
   case qc::X:
     return 2UL * (nc - 2UL) *
-               ((2UL * legacyCostFunction({qc::Phase, 0})) +
+               ((2UL * legacyCostFunction({qc::P, 0})) +
                 (2UL * legacyCostFunction({qc::U2, 0})) +
                 (3UL * legacyCostFunction({qc::X, 1}))) +
            (6UL * legacyCostFunction({qc::X, 1})) +
-           (8UL * legacyCostFunction({qc::U3, 0}));
-  case qc::U3:
+           (8UL * legacyCostFunction({qc::U, 0}));
+  case qc::U:
   case qc::U2:
   case qc::V:
-  case qc::Vdag:
+  case qc::Vdg:
   case qc::RX:
   case qc::RY:
   case qc::H:
   case qc::SX:
-  case qc::SXdag:
+  case qc::SXdg:
     // heuristic
     return (2U * legacyCostFunction({qc::X, nc})) +
-           (4U * legacyCostFunction({qc::U3, 0}));
-  case qc::Phase:
+           (4U * legacyCostFunction({qc::U, 0}));
+  case qc::P:
   case qc::S:
-  case qc::Sdag:
+  case qc::Sdg:
   case qc::T:
-  case qc::Tdag:
+  case qc::Tdg:
   case qc::RZ:
     // heuristic
     return (2U * legacyCostFunction({qc::X, nc})) +
-           (3U * legacyCostFunction({qc::Phase, 0}));
+           (3U * legacyCostFunction({qc::P, 0}));
   case qc::Y:
   case qc::Z:
     return legacyCostFunction({qc::X, nc}) +
-           (2U * legacyCostFunction({qc::U3, 0}));
+           (2U * legacyCostFunction({qc::U, 0}));
   case qc::SWAP:
     return legacyCostFunction({qc::X, nc}) +
            (2U * legacyCostFunction({qc::X, 1}));
@@ -89,7 +89,7 @@ legacyCostFunction(const GateCostLookupTableKeyType& key) noexcept {
            (2U * legacyCostFunction({qc::S, nc})) +
            (2U * legacyCostFunction({qc::H, nc}));
   case qc::Peres:
-  case qc::Peresdag:
+  case qc::Peresdg:
     return legacyCostFunction({qc::X, nc + 1U}) +
            legacyCostFunction({qc::X, nc});
   default:

test/legacy/test_general.cpp

@@ -155,21 +155,21 @@ TEST_F(GeneralTest, NoGateCancellation) {
   qc2.x(0);
 
   // two-qubit gates that cannot be cancelled
-  qc1.x(0, 1_pc);
-  qc2.x(1, 0_pc);
-  qc1.x(0, 1_pc);
-  qc2.x(1, 0_pc);
+  qc1.cx(1_pc, 0);
+  qc2.cx(0_pc, 1);
+  qc1.cx(1_pc, 0);
+  qc2.cx(0_pc, 1);
 
   // gates with parameters that cannot be cancelled
-  qc1.phase(0, 2.0);
-  qc2.phase(0, -2.0);
-  qc1.phase(0, -2.0);
-  qc2.phase(0, 2.0);
+  qc1.p(2.0, 0);
+  qc2.p(-2.0, 0);
+  qc1.p(-2.0, 0);
+  qc2.p(2.0, 0);
 
   // gates with different number of controls that cannot be cancelled
   qc1.x(0);
-  qc2.x(0, 1_pc);
-  qc1.x(0, 1_pc);
+  qc2.cx(1_pc, 0);
+  qc1.cx(1_pc, 0);
   qc2.x(0);
 
   auto config                               = ec::Configuration{};

test/test_equality.cpp

@@ -52,7 +52,7 @@ TEST_F(EqualityTest, CloseButNotEqualAlternating) {
   qc1.x(0);
 
   qc2.x(0);
-  qc2.phase(0, dd::PI / 1024.);
+  qc2.p(dd::PI / 1024., 0);
 
   config.functionality.traceThreshold    = 1e-2;
   config.execution.runAlternatingChecker = true;
@@ -66,7 +66,7 @@ TEST_F(EqualityTest, CloseButNotEqualConstruction) {
   qc1.x(0);
 
   qc2.x(0);
-  qc2.phase(0, dd::PI / 1024.);
+  qc2.p(dd::PI / 1024., 0);
 
   config.functionality.traceThreshold     = 1e-2;
   config.execution.runConstructionChecker = true;
@@ -80,7 +80,7 @@ TEST_F(EqualityTest, CloseButNotEqualAlternatingGlobalPhase) {
   qc1.x(0);
 
   qc2.x(0);
-  qc2.phase(0, dd::PI / 1024.);
+  qc2.p(dd::PI / 1024., 0);
   // add a global phase of -1
   qc2.z(0);
   qc2.x(0);
@@ -100,7 +100,7 @@ TEST_F(EqualityTest, CloseButNotEqualSimulation) {
   qc1.h(0);
 
   qc2.h(0);
-  qc2.phase(0, dd::PI / 1024.);
+  qc2.p(dd::PI / 1024., 0);
 
   config.simulation.fidelityThreshold   = 1e-2;
   config.execution.runSimulationChecker = true;
@@ -116,9 +116,9 @@ TEST_F(EqualityTest, SimulationMoreThan64Qubits) {
   qc1 = qc::QuantumComputation(65U);
   qc1.h(0);
   for (auto i = 0U; i < 64U; ++i) {
-    qc1.x(i + 1, 0_pc);
+    qc1.cx(0_pc, i + 1);
   }
-  qc2                                   = qc1.clone();
+  qc2                                   = qc1;
   config.execution.runSimulationChecker = true;
   ec::EquivalenceCheckingManager ecm(qc1, qc2, config);
   ecm.run();

test/test_gate_cost_application_scheme.cpp

@@ -35,7 +35,7 @@ TEST_F(GateCostApplicationSchemeTest, SchemeFromProfile) {
   ofs.close();
 
   // apply Toffoli gate
-  qc.x(0, {1_pc, 2_pc});
+  qc.mcx({1_pc, 2_pc}, 0);
 
   auto tm = ec::TaskManager<qc::MatrixDD>(qc, dd);
 
@@ -71,7 +71,7 @@ TEST_F(GateCostApplicationSchemeTest, iSWAP) {
 TEST_F(GateCostApplicationSchemeTest, Peres) {
   using namespace qc::literals;
 
-  qc.peres(1, 2, 0_pc);
+  qc.cperes(0_pc, 1, 2);
 
   auto tm = ec::TaskManager<qc::MatrixDD>(qc, dd);
 

test/test_symbolic.cpp

@@ -22,10 +22,10 @@ class SymbolicTest : public ::testing::Test {
 };
 
 TEST_F(SymbolicTest, SymbolicEqu) {
-  symQc1.rx(0, xMonom);
+  symQc1.rx(xMonom, 0);
 
   symQc2.h(0);
-  symQc2.rz(0, xMonom);
+  symQc2.rz(xMonom, 0);
   symQc2.h(0);
 
   auto ecm = ec::EquivalenceCheckingManager(symQc1, symQc2);
@@ -35,10 +35,10 @@ TEST_F(SymbolicTest, SymbolicEqu) {
 }
 
 TEST_F(SymbolicTest, SymbolicNonEqu) {
-  symQc1.rx(0, xMonom);
+  symQc1.rx(xMonom, 0);
 
   symQc2.h(0);
-  symQc2.rz(0, xMonomNeg);
+  symQc2.rx(xMonomNeg, 0);
   symQc2.h(0);
 
   auto ecm = ec::EquivalenceCheckingManager(symQc1, symQc2);
@@ -53,11 +53,11 @@ TEST_F(SymbolicTest, Timeout) {
   symQc1                   = qc::QuantumComputation(2);
   symQc2                   = qc::QuantumComputation(2);
   for (auto i = 0; i < numLayers; ++i) {
-    symQc1.x(0, 1_pc);
-    symQc1.rx(0, xMonom);
+    symQc1.cx(1_pc, 0);
+    symQc1.rx(xMonom, 0);
 
-    symQc2.x(0, 1_pc);
-    symQc2.rx(0, xMonom);
+    symQc2.cx(1_pc, 0);
+    symQc2.rx(xMonom, 0);
   }
   ec::Configuration config{};
   config.execution.timeout = 1;
@@ -70,8 +70,8 @@ TEST_F(SymbolicTest, Timeout) {
 
 TEST_F(SymbolicTest, InvalidCircuit) {
   auto qc = qc::QuantumComputation(4);
-  qc.x(0, {1_pc, 2_pc, 3_pc});
-  qc.rx(0, xMonom);
+  qc.mcx({1_pc, 2_pc, 3_pc}, 0);
+  qc.rx(xMonom, 0);
   auto ecm = ec::EquivalenceCheckingManager(qc, qc);
   ecm.run();