Improved swaps optimization in networks, added a test for checking no optimization results against swaps optimized results through the network, added the possibility of overriding the guess for lookahead.

aromanro · aromanro · commit a714780c68a8 · 2026-04-10T15:57:51.000+03:00
diff --git a/Network/Network.h b/Network/Network.h
@@ -988,6 +988,14 @@ class INetwork : public std::enable_shared_from_this<INetwork<Time>> {
   virtual void SetMPSOptimizationQubitsNumberThreshold(size_t threshold) = 0;
 
   virtual size_t GetMPSOptimizationQubitsNumberThreshold() const = 0;
+
+  virtual void SetLookaheadDepth(int depth) = 0;
+
+  virtual int GetLookaheadDepth() const = 0;
+
+  virtual void SetLookaheadDepthWithHeuristic(int depth) = 0;
+
+  virtual int GetLookaheadDepthWithHeuristic() const = 0;
 };
 
 }  // namespace Network
diff --git a/Network/NetworkJob.h b/Network/NetworkJob.h
@@ -384,24 +384,45 @@ class ExecuteJob {
 
           if (network->GetMPSOptimizeSwaps()) {
             // TODO: come up with something better!
-            int lookaheadVal = nrQubits;
-            if (nrQubits > 15) lookaheadVal = 15;
-
-            const int lookaheadDepth = layers.size() < 10 ? 5
-                                       : layers.size() < 20
-                                           ? static_cast<int>(lookaheadVal)
-                                       : layers.size() < 35 ? 1.5 * lookaheadVal
-                                                            : 2 * lookaheadVal;
-
-            const int lookaheadHeuristicDepth = layers.size() < 10 ? 4
-                                                : layers.size() < 20
-                                                    ? lookaheadDepth - 1
-                                                    : lookaheadDepth - 2;
+            int lookaheadDepthLocal = network->GetLookaheadDepth();
+
+            if (lookaheadDepthLocal == std::numeric_limits<int>::max()) {
+              double avgTwoQubitGatesPerLayer = 0.0;
+              for (const auto &layer : layers) {
+                int twoQubitGates = 0;
+                for (const auto &op : layer->GetOperations()) {
+                  if (op->AffectedQubits().size() >= 2) {
+                    ++twoQubitGates;
+                  }
+                }
+                avgTwoQubitGatesPerLayer += twoQubitGates;
+              }
+              avgTwoQubitGatesPerLayer /= layers.size();
+
+              int lookaheadVal =
+                  static_cast<int>(4. * avgTwoQubitGatesPerLayer);
+              if (lookaheadVal > 15) lookaheadVal = 15;
+
+              lookaheadDepthLocal = layers.size() < 10 || nrQubits <= 10 ? 0
+                                    : layers.size() < 20
+                                        ? static_cast<int>(lookaheadVal)
+                                    : layers.size() < 35 ? 1.5 * lookaheadVal
+                                                         : 2 * lookaheadVal;
+            }
+
+            int lookaheadHeuristicDepthLocal =
+                network->GetLookaheadDepthWithHeuristic();
+
+            if (lookaheadHeuristicDepthLocal == std::numeric_limits<int>::max())
+              lookaheadHeuristicDepthLocal =
+                  layers.size() < 10 || nrQubits <= 10 ? 0
+                                             : layers.size() < 20
+                                                 ? lookaheadDepthLocal - 1
+                                                 : lookaheadDepthLocal - 2;
 
             sim->SetUseOptimalMeetingPosition(true);
-            sim->SetLookaheadDepth(lookaheadDepth);
-            sim->SetLookaheadDepthWithHeuristic(lookaheadHeuristicDepth);
-
+            sim->SetLookaheadDepth(lookaheadDepthLocal);
+            sim->SetLookaheadDepthWithHeuristic(lookaheadHeuristicDepthLocal);
             sim->SetUpcomingGates(dcirc->GetOperations());
           }
         }
diff --git a/Network/SimpleDisconnectedNetwork.h b/Network/SimpleDisconnectedNetwork.h
@@ -23,7 +23,6 @@
 
 #include "../Simulators/MPSDummySimulator.h"
 
-
 namespace Network {
 
 /**
@@ -407,7 +406,8 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
     const size_t n = simulator->GetNumberOfQubits();
     const size_t dim = 1ULL << n;
     amplitudes.resize(dim);
-    for (size_t state = 0; state < dim; ++state) amplitudes[state] = simulator->Amplitude(state);
+    for (size_t state = 0; state < dim; ++state)
+      amplitudes[state] = simulator->Amplitude(state);
 
     // Remap amplitudes back to the original qubit ordering if qubits were
     // remapped during execution on the host.
@@ -419,8 +419,7 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
       std::vector<size_t> simToOrig(n);
       size_t offset = offsetBase;
 
-      for (size_t qbit = 0; qbit < n; ++qbit)
-      {
+      for (size_t qbit = 0; qbit < n; ++qbit) {
         auto pos = qubitsMapOnHost.find(qbit);
         if (pos != qubitsMapOnHost.end())
           simToOrig[pos->second] = pos->first;
@@ -652,7 +651,7 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
         if (optSim) {
           job->optSim = optSim->Clone();
           job->executedGates = executed;
-        } 
+        }
 
         threadsPool.AddRunJob(std::move(job));
       }
@@ -680,7 +679,7 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
       } else {
         if (simulator && method == saveMethod && simType == saveSimType) {
           // use the already created simulator
-                      
+
           optSim = simulator;
           job->optSim = optSim;
           OptimizeMPSInitialQubitsMap(optSim, distCirc,
@@ -2048,14 +2047,14 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
                            singularValueThreshold.c_str());
           if (!mpsSample.empty())
             sim->Configure("mps_sample_measure_algorithm", mpsSample.c_str());
-        
+
           sim->AllocateQubits(nrQubits);
           sim->Initialize();
 
           OptimizeMPSInitialQubitsMap(sim, dcirc, nrQubits);
         } else {
           sim->AllocateQubits(nrQubits);
-          sim->Initialize();        
+          sim->Initialize();
         }
 
         if (!dontRunCircuitStart) {
@@ -2072,9 +2071,9 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
 
     std::shared_ptr<Simulators::ISimulator> sim =
         simulatorsEstimator->ChooseBestSimulator(
-        simulatorTypes, dcirc, counts, nrQubits, nrCbits, nrResultCbits,
-        simType, method, executed, maxBondDim, singularValueThreshold,
-        mpsSample, GetMaxSimulators(), pauliStrings, multithreading);
+            simulatorTypes, dcirc, counts, nrQubits, nrCbits, nrResultCbits,
+            simType, method, executed, maxBondDim, singularValueThreshold,
+            mpsSample, GetMaxSimulators(), pauliStrings, multithreading);
 
     if (sim) {
       sim->AllocateQubits(nrQubits);
@@ -2093,7 +2092,6 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
     return sim;
   }
 
-
   void SetInitialQubitsMapOptimization(bool optimize = true) override {
     optimizeInitialQubitsMap = optimize;
   }
@@ -2124,6 +2122,26 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
     return mpsOptimizationQubitsNumberThreshold;
   }
 
+  void SetLookaheadDepth(int depth) override {
+    if (depth < 0) depth = std::numeric_limits<int>::max();
+
+    lookaheadDepth = depth;
+  }
+
+  int GetLookaheadDepth() const override { return lookaheadDepth; }
+
+  void SetLookaheadDepthWithHeuristic(int depth) override {
+    if (depth < 0) depth = std::numeric_limits<int>::max();
+
+    if (depth > lookaheadDepth) depth = lookaheadDepth;
+
+    lookaheadDepthWithHeuristic = depth;
+  }
+
+  int GetLookaheadDepthWithHeuristic() const override {
+    return lookaheadDepthWithHeuristic;
+  }
+
  protected:
   void OptimizeMPSInitialQubitsMap(
       std::shared_ptr<Simulators::ISimulator> &sim,
@@ -2142,18 +2160,6 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
           dcirc->ConvertForCutting();  // convert the three qubit gates
           auto layers = dcirc->ToMultipleQubitsLayersNoClone();
 
-          double avgTwoQubitGatesPerLayer = 0.0;
-          for (const auto &layer : layers) {
-            int twoQubitGates = 0;
-            for (const auto &op : layer->GetOperations()) {
-              if (op->AffectedQubits().size() >= 2) {
-                ++twoQubitGates;
-              }
-            }
-            avgTwoQubitGatesPerLayer += twoQubitGates;
-          }
-          avgTwoQubitGatesPerLayer /= layers.size();
-
           Simulators::MPSDummySimulator dummySim(nrQubits);
           if (!maxBondDim.empty())
             dummySim.SetMaxBondDimension(maxBondDimValue);
@@ -2168,24 +2174,43 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
 
           if (mpsOptimizeSwaps) {
             // TODO: come up with something better!
-            int lookaheadVal = static_cast<int>(4. * avgTwoQubitGatesPerLayer);
-            if (lookaheadVal > 15) lookaheadVal = 15;
+            int lookaheadDepthLocal = lookaheadDepth;
+
+            if (lookaheadDepthLocal == std::numeric_limits<int>::max()) {
+              double avgTwoQubitGatesPerLayer = 0.0;
+              for (const auto &layer : layers) {
+                int twoQubitGates = 0;
+                for (const auto &op : layer->GetOperations()) {
+                  if (op->AffectedQubits().size() >= 2) {
+                    ++twoQubitGates;
+                  }
+                }
+                avgTwoQubitGatesPerLayer += twoQubitGates;
+              }
+              avgTwoQubitGatesPerLayer /= layers.size();
 
-            const int lookaheadDepth = layers.size() < 10 ? 0
-                                 : layers.size() < 20
-                                     ? static_cast<int>(lookaheadVal)
-                                 : layers.size() < 35 ? 1.5 * lookaheadVal
-                                                      : 2 * lookaheadVal;
+              int lookaheadVal = static_cast<int>(4. * avgTwoQubitGatesPerLayer);
+              if (lookaheadVal > 15) lookaheadVal = 15;
 
-            const int lookaheadHeuristicDepth = layers.size() < 10 ? 0
-                                          : layers.size() < 20
-                                              ? lookaheadDepth - 1
-                                              : lookaheadDepth - 2; 
+              lookaheadDepthLocal = layers.size() < 10 || nrQubits <= 10 ? 0
+                                    : layers.size() < 20
+                                        ? static_cast<int>(lookaheadVal)
+                                    : layers.size() < 35 ? 1.5 * lookaheadVal
+                                                         : 2 * lookaheadVal;
+            }
 
-            sim->SetUseOptimalMeetingPosition(true);
-            sim->SetLookaheadDepth(lookaheadDepth);
-            sim->SetLookaheadDepthWithHeuristic(lookaheadHeuristicDepth);
+            int lookaheadHeuristicDepthLocal = lookaheadDepthWithHeuristic;
 
+            if (lookaheadHeuristicDepthLocal == std::numeric_limits<int>::max())
+              lookaheadHeuristicDepthLocal =
+                  layers.size() < 10 || nrQubits <= 10 ? 0
+                                                : layers.size() < 20
+                                                    ? lookaheadDepthLocal - 1
+                                                    : lookaheadDepthLocal - 2;
+
+            sim->SetUseOptimalMeetingPosition(true);
+            sim->SetLookaheadDepth(lookaheadDepthLocal);
+            sim->SetLookaheadDepthWithHeuristic(lookaheadHeuristicDepthLocal);
             sim->SetUpcomingGates(dcirc->GetOperations());
           }
         }
@@ -2431,6 +2456,12 @@ class SimpleDisconnectedNetwork : public INetwork<Time> {
       32; /**< The bond dimension threshold for using MPS optimization. */
   size_t mpsOptimizationQubitsNumberThreshold =
       12; /**< The qubits number threshold for using MPS optimization. */
+
+  int lookaheadDepth =
+      std::numeric_limits<int>::max(); /**< The lookahead depth for MPS swap
+                                          optimization. */
+  int lookaheadDepthWithHeuristic = std::numeric_limits<int>::max(); /**< The
+            lookahead depth with heuristic for MPS swap optimization. */
 };
 
 }  // namespace Network
diff --git a/Simulators/GpuSimulator.h b/Simulators/GpuSimulator.h
@@ -738,7 +738,7 @@ class GpuSimulator : public GpuState {
     cloned->singularValueThreshold = singularValueThreshold;
 
     cloned->lookaheadDepth = lookaheadDepth;
-    cloned->useOptimalMeetingPositionOnly = useOptimalMeetingPositionOnly;
+    cloned->useOptimalMeetingPosition = useOptimalMeetingPosition;
     cloned->upcomingGates = upcomingGates;
     cloned->upcomingGateIndex = upcomingGateIndex;
 
diff --git a/Simulators/GpuState.h b/Simulators/GpuState.h
@@ -76,6 +76,9 @@ class GpuState : public ISimulator {
         } else
           throw std::runtime_error(
               "GpuState::Initialize: Failed to create the MPS state.");
+        // default is true
+        if (!useOptimalMeetingPosition)
+          mps->SetUseOptimalMeetingPosition(false);
       } else if (simulationType == SimulationType::kTensorNetwork) {
         tn = SimulatorsFactory::CreateGpuLibTensorNetSim();
         if (tn) {
@@ -265,13 +268,13 @@ class GpuState : public ISimulator {
   }
 
   void SetUseOptimalMeetingPosition(bool enable) override {
-    useOptimalMeetingPositionOnly = enable;
+    useOptimalMeetingPosition = enable;
     if (mps) mps->SetUseOptimalMeetingPosition(enable);
   }
 
   void SetLookaheadDepth(int depth) override {
     lookaheadDepth = depth;
-    if (mps && depth > 0 && !useOptimalMeetingPositionOnly)
+    if (mps && depth > 0 && !useOptimalMeetingPosition)
       mps->SetUseOptimalMeetingPosition(true);
   }
 
@@ -1202,7 +1205,7 @@ class GpuState : public ISimulator {
 
   int lookaheadDepth = 0;
   int lookaheadDepthWithHeuristic = 0;
-  bool useOptimalMeetingPositionOnly = false;
+  bool useOptimalMeetingPosition = true;
   std::vector<std::shared_ptr<Circuits::IOperation<>>> upcomingGates;
   long long int upcomingGateIndex = 0;
   std::unique_ptr<Simulators::MPSDummySimulator> dummySim;
diff --git a/Simulators/MPSDummySimulator.h b/Simulators/MPSDummySimulator.h
@@ -405,7 +405,7 @@ class MPSDummySimulator {
 
   std::vector<long long int> ComputeOptimalQubitsMap(
       const std::vector<std::shared_ptr<Circuits::Circuit<>>>& layers,
-      int nrShuffles = 25) {
+      int nrShuffles = 10) {
     const IndexType nrQubits = getNrQubits();
 
     if (layers.empty() || nrQubits <= 2) return qubitsMap;
diff --git a/Simulators/QCSimSimulator.h b/Simulators/QCSimSimulator.h
@@ -924,7 +924,7 @@ class QCSimSimulator : public QCSimState {
     cloned->useMPSMeasureNoCollapse = useMPSMeasureNoCollapse;
 
     cloned->lookaheadDepth = lookaheadDepth;
-    cloned->useOptimalMeetingPositionOnly = useOptimalMeetingPositionOnly;
+    cloned->useOptimalMeetingPosition = useOptimalMeetingPosition;
     cloned->upcomingGates = upcomingGates;
     cloned->upcomingGateIndex = upcomingGateIndex;
 
diff --git a/Simulators/QCSimState.h b/Simulators/QCSimState.h
@@ -68,6 +68,8 @@ class QCSimState : public ISimulator {
         if (limitEntanglement && singularValueThreshold > 0.)
           mpsSimulator->setLimitEntanglement(singularValueThreshold);
         if (limitSize && chi > 0) mpsSimulator->setLimitBondDimension(chi);
+        // default is true
+        if (!useOptimalMeetingPosition) mpsSimulator->SetUseOptimalMeetingPosition(false);
       } else if (simulationType == SimulationType::kStabilizer)
         cliffordSimulator =
             std::make_unique<QC::Clifford::StabilizerSimulator>(nrQubits);
@@ -250,14 +252,14 @@ class QCSimState : public ISimulator {
   }
 
   void SetUseOptimalMeetingPosition(bool enable) override {
-    useOptimalMeetingPositionOnly = enable;
+    useOptimalMeetingPosition = enable;
     if (mpsSimulator)
         mpsSimulator->SetUseOptimalMeetingPosition(enable);
   }
 
   void SetLookaheadDepth(int depth) override {
     lookaheadDepth = depth;
-    if (mpsSimulator && depth > 0 && !useOptimalMeetingPositionOnly)
+    if (mpsSimulator && depth > 0 && !useOptimalMeetingPosition)
       mpsSimulator->SetUseOptimalMeetingPosition(true);
   }
 
@@ -1494,7 +1496,7 @@ class QCSimState : public ISimulator {
 
   int lookaheadDepth = 0;
   int lookaheadDepthWithHeuristic = 0;
-  bool useOptimalMeetingPositionOnly = false;
+  bool useOptimalMeetingPosition = true;
   std::vector<std::shared_ptr<Circuits::IOperation<>>> upcomingGates;
   long long int upcomingGateIndex = 0;
   std::unique_ptr<Simulators::MPSDummySimulator> dummySim;
diff --git a/tests/mpsswapsopttests.cpp b/tests/mpsswapsopttests.cpp
