Revert QBdt stabilizer work (putting back in branch)

unitaryfund · Aug 7, 2023 · 82aef87 · 82aef87
1 parent ca6d38b
commit 82aef87
Show file tree

Hide file tree

Showing 6 changed files with 57 additions and 563 deletions.
diff --git a/include/qbdt.hpp b/include/qbdt.hpp
@@ -16,12 +16,9 @@
 
 #pragma once
 
-#include "mpsshard.hpp"
 #include "qbdt_node.hpp"
-#include "qbdt_qstabilizer_node.hpp"
 #include "qengine.hpp"
 
-#define NODE_TO_STABILIZER(leaf) (std::dynamic_pointer_cast<QBdtQStabilizerNode>(leaf)->qReg)
 #define QINTERFACE_TO_QALU(qReg) std::dynamic_pointer_cast<QAlu>(qReg)
 #define QINTERFACE_TO_QPARITY(qReg) std::dynamic_pointer_cast<QParity>(qReg)
 
@@ -42,43 +39,7 @@ class QBdt : public QParity, public QInterface {
     bitCapInt bdtMaxQPower;
     std::vector<int64_t> deviceIDs;
     std::vector<QInterfaceEngine> engines;
-    std::vector<MpsShardPtr> shards;
 
-    void DumpBuffers()
-    {
-        for (size_t i = 0; i < shards.size(); ++i) {
-            shards[i] = NULL;
-        }
-    }
-    void FlushBuffers()
-    {
-        for (size_t i = 0U; i < shards.size(); ++i) {
-            const MpsShardPtr shard = shards[i];
-            if (shard) {
-                shards[i] = NULL;
-                ApplySingle(shard->gate, i);
-            }
-        }
-    }
-
-    void FlushIfBlocked(bitLenInt target, const std::vector<bitLenInt>& controls = std::vector<bitLenInt>())
-    {
-        for (const bitLenInt& control : controls) {
-            const MpsShardPtr shard = shards[control];
-            if (shard && !shard->IsPhase()) {
-                shards[control] = NULL;
-                ApplySingle(shard->gate, control);
-            }
-        }
-
-        const MpsShardPtr shard = shards[target];
-        if (shard) {
-            shards[target] = NULL;
-            ApplySingle(shard->gate, target);
-        }
-    }
-
-    QBdtQStabilizerNodePtr MakeQStabilizerNode(complex scale, bitLenInt qbCount, bitCapInt perm = 0U);
     QEnginePtr MakeQEngine(bitLenInt qbCount, bitCapInt perm = 0U);
 
     template <typename Fn> void GetTraversal(Fn getLambda)

diff --git a/include/qbdt_node.hpp b/include/qbdt_node.hpp
@@ -76,25 +76,6 @@ class QBdtNode : public QBdtNodeInterface {
 #else
     virtual void Apply2x2(complex const* mtrx, bitLenInt depth);
 #endif
-
-    virtual QBdtNodeInterfacePtr PopSpecial(bitLenInt depth = 1U)
-    {
-        if (!depth) {
-            return shared_from_this();
-        }
-
-        if (norm(scale) <= _qrack_qbdt_sep_thresh) {
-            SetZero();
-            return shared_from_this();
-        }
-
-        --depth;
-
-        branches[0U] = branches[0U]->PopSpecial(depth);
-        branches[1U] = branches[1U]->PopSpecial(depth);
-
-        return shared_from_this();
-    }
 };
 
 } // namespace Qrack
diff --git a/include/qbdt_node_interface.hpp b/include/qbdt_node_interface.hpp
@@ -33,7 +33,7 @@ namespace Qrack {
 class QBdtNodeInterface;
 typedef std::shared_ptr<QBdtNodeInterface> QBdtNodeInterfacePtr;
 
-class QBdtNodeInterface : public std::enable_shared_from_this<QBdtNodeInterface> {
+class QBdtNodeInterface {
 protected:
     static size_t SelectBit(bitCapInt perm, bitLenInt bit) { return (size_t)((perm >> bit) & 1U); }
     static void _par_for_qbdt(const bitCapInt end, BdtFunc fn);
@@ -82,8 +82,6 @@ class QBdtNodeInterface : public std::enable_shared_from_this<QBdtNodeInterface>
         // Virtual destructor for inheritance
     }
 
-    virtual bool IsStabilizer() { return false; }
-
     virtual void InsertAtDepth(QBdtNodeInterfacePtr b, bitLenInt depth, const bitLenInt& size, bitLenInt parDepth = 1U)
     {
         throw std::out_of_range("QBdtNodeInterface::InsertAtDepth() not implemented! (You probably set "
@@ -148,20 +146,26 @@ class QBdtNodeInterface : public std::enable_shared_from_this<QBdtNodeInterface>
                                 "QRACK_QBDT_SEPARABILITY_THRESHOLD too high.)");
     }
 
+#if ENABLE_COMPLEX_X2
     virtual void Apply2x2(const complex2& mtrxCol1, const complex2& mtrxCol2, const complex2& mtrxColShuff1,
         const complex2& mtrxColShuff2, bitLenInt depth)
-    {
-        throw std::out_of_range("QBdtQStabilizerNode::Apply2x2() not implemented!");
-    }
+#else
     virtual void Apply2x2(complex const* mtrx, bitLenInt depth)
+#endif
     {
-        throw std::out_of_range("QBdtQStabilizerNode::Apply2x2() not implemented!");
+        throw std::out_of_range("QBdtNodeInterface::Apply2x2() not implemented! (You probably set "
+                                "QRACK_QBDT_SEPARABILITY_THRESHOLD too high.)");
     }
 
-    virtual QBdtNodeInterfacePtr PopSpecial(bitLenInt depth = 1U)
+#if ENABLE_COMPLEX_X2
+    virtual void PushSpecial(const complex2& mtrxCol1, const complex2& mtrxCol2, const complex2& mtrxColShuff1,
+        const complex2& mtrxColShuff2, QBdtNodeInterfacePtr& b1)
+#else
+    virtual void PushSpecial(complex const* mtrx, QBdtNodeInterfacePtr& b1)
+#endif
     {
-        throw std::out_of_range(
-            "QBdtNodeInterface::PopSpecial() not implemented! (Check IsStabilizer() before PopSpecial().)");
+        throw std::out_of_range("QBdtNodeInterface::PushSpecial() not implemented! (You probably called "
+                                "PushStateVector() past terminal depth.)");
     }
 };
 

diff --git a/src/qbdt/node.cpp b/src/qbdt/node.cpp
@@ -587,15 +587,21 @@ void QBdtNode::PushStateVector(const complex2& mtrxCol1, const complex2& mtrxCol
     b0->Branch();
     b1->Branch();
 
-    b0 = b0->PopSpecial();
-    b1 = b1->PopSpecial();
-
     // For parallelism, keep shared_ptr from deallocating.
     QBdtNodeInterfacePtr b00 = b0->branches[0U];
     QBdtNodeInterfacePtr b01 = b0->branches[1U];
     QBdtNodeInterfacePtr b10 = b1->branches[0U];
     QBdtNodeInterfacePtr b11 = b1->branches[1U];
 
+    if (!b00) {
+        b0->PushSpecial(mtrxCol1, mtrxCol2, mtrxColShuff1, mtrxColShuff2, b1);
+
+        b0->PopStateVector();
+        b1->PopStateVector();
+
+        return;
+    }
+
     if (true) {
         std::lock(b00->mtx, b01->mtx);
         std::lock_guard<std::mutex> lock0(b00->mtx, std::adopt_lock);
@@ -738,15 +744,21 @@ void QBdtNode::PushStateVector(
     b0->Branch();
     b1->Branch();
 
-    b0 = b0->PopSpecial();
-    b1 = b1->PopSpecial();
-
     // For parallelism, keep shared_ptr from deallocating.
     QBdtNodeInterfacePtr b00 = b0->branches[0U];
     QBdtNodeInterfacePtr b01 = b0->branches[1U];
     QBdtNodeInterfacePtr b10 = b1->branches[0U];
     QBdtNodeInterfacePtr b11 = b1->branches[1U];
 
+    if (!b00) {
+        b0->PushSpecial(mtrx, b1);
+
+        b0->PopStateVector();
+        b1->PopStateVector();
+
+        return;
+    }
+
     if (true) {
         std::lock(b00->mtx, b01->mtx);
         std::lock_guard<std::mutex> lock0(b00->mtx, std::adopt_lock);