new 'gatecost' heuristic implemented

include/PathSimulator.hpp

@@ -51,23 +51,25 @@ class PathSimulator: public CircuitSimulator<Config> {
             PairwiseRecursiveGrouping,
             BracketGrouping,
             Alternating,
-            Cotengra
+            Cotengra,
+            GateCost
         };
 
         // mode to use
         Mode mode;
 
         // settings for the bracket size
         std::size_t bracketSize;
-        // settings for the alternating mode
-        std::size_t alternatingStart;
-
+        // settings for the alternating and gatecost mode, which need a starting point
+        std::size_t startingPoint;
+        // settings for the gate costs mode
+        std::list<std::size_t> gateCost;
         // random seed
         std::size_t seed;
 
         //Add new variables here
-        explicit Configuration(const Mode mode_ = Mode::Sequential, const std::size_t bracketSize_ = 2, const std::size_t alternatingStart_ = 0, const std::size_t seed_ = 0):
-            mode(mode_), bracketSize(bracketSize_), alternatingStart(alternatingStart_), seed(seed_){};
+        explicit Configuration(const Mode mode_ = Mode::Sequential, const std::size_t bracketSize_ = 2, const std::size_t startingPoint_ = 0, std::list<std::size_t> gateCost_ = {}, const std::size_t seed_ = 0):
+            mode(mode_), bracketSize(bracketSize_), startingPoint(startingPoint_), gateCost(std::move(gateCost_)), seed(seed_){};
 
         static Mode modeFromString(const std::string& mode) {
             if (mode == "sequential" || mode == "0") {
@@ -80,6 +82,8 @@ class PathSimulator: public CircuitSimulator<Config> {
                 return Mode::Alternating;
             } else if (mode == "cotengra" || mode == "4") {
                 return Mode::Cotengra;
+            } else if (mode == "gate_cost" || mode == "5") {
+                return Mode::GateCost;
             } else {
                 throw std::invalid_argument("Invalid simulation path mode: " + mode);
             }
@@ -97,6 +101,8 @@ class PathSimulator: public CircuitSimulator<Config> {
                     return "alternating";
                 case Mode::Cotengra:
                     return "cotengra";
+                case Mode::GateCost:
+                    return "gate_cost";
                 default:
                     throw std::invalid_argument("Invalid simulation path mode");
             }
@@ -108,7 +114,10 @@ class PathSimulator: public CircuitSimulator<Config> {
             if (mode == Mode::BracketGrouping) {
                 conf["bracket_size"] = bracketSize;
             } else if (mode == Mode::Alternating) {
-                conf["alternating_start"] = alternatingStart;
+                conf["starting_point"] = startingPoint;
+            } else if (mode == Mode::GateCost) {
+                conf["starting_point"] = startingPoint;
+                conf["gate_cost"]      = gateCost;
             }
             if (seed != 0) {
                 conf["seed"] = seed;
@@ -132,8 +141,8 @@ class PathSimulator: public CircuitSimulator<Config> {
         qc::CircuitOptimizer::removeFinalMeasurements(*(CircuitSimulator<Config>::qc));
 
         // case distinction for the starting point of the alternating strategy
-        if (configuration.alternatingStart == 0) {
-            configuration.alternatingStart = (CircuitSimulator<Config>::qc->getNops()) / 2;
+        if (configuration.startingPoint == 0) {
+            configuration.startingPoint = (CircuitSimulator<Config>::qc->getNops()) / 2;
         }
 
         // Add new strategies here
@@ -147,17 +156,19 @@ class PathSimulator: public CircuitSimulator<Config> {
             case Configuration::Mode::Cotengra:
                 break;
             case Configuration::Mode::Alternating:
-                generateAlternatingSimulationPath(configuration.alternatingStart);
+                generateAlternatingSimulationPath(configuration.startingPoint);
+                break;
+            case Configuration::Mode::GateCost:
+                generateGatecostSimulationPath(configuration.startingPoint, configuration.gateCost);
                 break;
-            case Configuration::Mode::Sequential:
             default:
                 generateSequentialSimulationPath();
                 break;
         }
     }
 
-    PathSimulator(std::unique_ptr<qc::QuantumComputation>&& qc_, typename Configuration::Mode mode, std::size_t bracketSize, std::size_t alternatingStart, std::size_t seed_):
-        PathSimulator<Config>(std::move(qc_), Configuration{mode, bracketSize, alternatingStart, seed_}) {}
+    PathSimulator(std::unique_ptr<qc::QuantumComputation>&& qc_, typename Configuration::Mode mode_, std::size_t bracketSize_, std::size_t startingPoint_, std::list<std::size_t> gateCost_, std::size_t seed_):
+        PathSimulator(std::move(qc_), Configuration{mode_, bracketSize_, startingPoint_, std::move(gateCost_), seed_}) {}
 
     std::map<std::string, std::size_t> Simulate(std::size_t shots) override;
 
@@ -176,6 +187,7 @@ class PathSimulator: public CircuitSimulator<Config> {
     void generatePairwiseRecursiveGroupingSimulationPath();
     void generateBracketSimulationPath(std::size_t bracketSize);
     void generateAlternatingSimulationPath(std::size_t startingPoint);
+    void generateGatecostSimulationPath(std::size_t startingPoint, std::list<std::size_t>& gateCosts);
 
 private:
     std::unordered_map<std::size_t, tf::Task>                                 tasks{};

mqt/ddsim/__init__.py

@@ -1,3 +1,4 @@
 from mqt.ddsim.provider import DDSIMProvider
-from mqt.ddsim.pyddsim import CircuitSimulator, HybridCircuitSimulator, PathCircuitSimulator, UnitarySimulator, HybridMode, \
-    PathSimulatorMode, PathSimulatorConfiguration, ConstructionMode, get_matrix, dump_tensor_network, __version__
+from mqt.ddsim.pyddsim import CircuitSimulator, HybridCircuitSimulator, PathCircuitSimulator, UnitarySimulator, \
+    HybridMode, PathSimulatorMode, PathSimulatorConfiguration, ConstructionMode, get_matrix, dump_tensor_network, \
+    __version__

mqt/ddsim/bindings.cpp

@@ -160,6 +160,7 @@ PYBIND11_MODULE(pyddsim, m) {
             .value("cotengra", PathSimulator<>::Configuration::Mode::Cotengra)
             .value("bracket", PathSimulator<>::Configuration::Mode::BracketGrouping)
             .value("alternating", PathSimulator<>::Configuration::Mode::Alternating)
+            .value("gate_cost", PathSimulator<>::Configuration::Mode::GateCost)
             .export_values()
             .def(py::init([](const std::string& str) -> PathSimulator<>::Configuration::Mode { return PathSimulator<>::Configuration::modeFromString(str); }));
 
@@ -169,8 +170,10 @@ PYBIND11_MODULE(pyddsim, m) {
                            R"pbdoc(Setting the mode used for determining a simulation path)pbdoc")
             .def_readwrite("bracket_size", &PathSimulator<>::Configuration::bracketSize,
                            R"pbdoc(Size of the brackets one wants to combine)pbdoc")
-            .def_readwrite("alternating_start", &PathSimulator<>::Configuration::alternatingStart,
-                           R"pbdoc(Start of the alternating strategy)pbdoc")
+            .def_readwrite("starting_point", &PathSimulator<>::Configuration::startingPoint,
+                           R"pbdoc(Start of the alternating or gate_cost strategy)pbdoc")
+            .def_readwrite("gate_cost", &PathSimulator<>::Configuration::gateCost,
+                           R"pbdoc(A list that contains the number of gates which are considered in each step)pbdoc")
             .def_readwrite("seed", &PathSimulator<>::Configuration::seed,
                            R"pbdoc(Seed for the simulator)pbdoc")
             .def("json", &PathSimulator<>::Configuration::json)
@@ -179,8 +182,8 @@ PYBIND11_MODULE(pyddsim, m) {
     py::class_<PathSimulator<>>(m, "PathCircuitSimulator")
             .def(py::init<>(&create_simulator_without_seed<PathSimulator<>, PathSimulator<>::Configuration&>),
                  "circ"_a, "config"_a = PathSimulator<>::Configuration())
-            .def(py::init<>(&create_simulator_without_seed<PathSimulator<>, PathSimulator<>::Configuration::Mode&, const std::size_t&, const std::size_t&, const std::size_t&>),
-                 "circ"_a, "mode"_a = PathSimulator<>::Configuration::Mode::Sequential, "bracket_size"_a = 2, "alternating_start"_a = 0, "seed"_a = 0)
+            .def(py::init<>(&create_simulator_without_seed<PathSimulator<>, PathSimulator<>::Configuration::Mode&, const std::size_t&, const std::size_t&, const std::list<std::size_t>&, const std::size_t&>),
+                 "circ"_a, "mode"_a = PathSimulator<>::Configuration::Mode::Sequential, "bracket_size"_a = 2, "starting_point"_a = 0, "gate_cost"_a = std::list<std::size_t>{}, "seed"_a = 0)
             .def("set_simulation_path", py::overload_cast<const PathSimulator<>::SimulationPath::Components&, bool>(&PathSimulator<>::setSimulationPath))
             .def("get_number_of_qubits", &CircuitSimulator<>::getNumberOfQubits)
             .def("get_name", &CircuitSimulator<>::getName)

mqt/ddsim/pathqasmsimulator.py

@@ -122,6 +122,7 @@ def _default_options(cls) -> Options:
             mode=None,
             bracket_size=None,
             alternating_start=None,
+            gate_cost=None,
             seed=None,
             cotengra_max_time=60,
             cotengra_max_repeats=1024,
@@ -217,6 +218,10 @@ def run_experiment(self, qobj_experiment: QasmQobjExperiment, **options):
         if alternating_start is not None:
             pathsim_configuration.alternating_start = alternating_start
 
+        gate_cost = options.get('gate_cost')
+        if gate_cost is not None:
+            pathsim_configuration.gate_cost = gate_cost
+
         seed = options.get('seed')
         if seed is not None:
             pathsim_configuration.seed = seed

src/CircuitSimulator.cpp

@@ -81,7 +81,6 @@ std::map<std::string, std::size_t> CircuitSimulator<Config>::Simulate(std::size_
         }
         m_counter[result_string]++;
     }
-
     return m_counter;
 }
 

src/PathSimulator.cpp

@@ -287,6 +287,66 @@ void PathSimulator<Config>::generateAlternatingSimulationPath(std::size_t starti
     setSimulationPath(components, true);
 }
 
+template<class Config>
+void PathSimulator<Config>::generateGatecostSimulationPath(const std::size_t startingPoint, std::list<std::size_t>& gateCosts) {
+    typename SimulationPath::Components components{};
+    components.reserve(CircuitSimulator<Config>::qc->getNops());
+
+    const std::size_t leftEnd  = 0;
+    const std::size_t rightEnd = CircuitSimulator<Config>::qc->getNops() + 1;
+
+    components.emplace_back(startingPoint, startingPoint + 1);
+
+    std::size_t leftID  = startingPoint - 1;
+    std::size_t rightID = startingPoint + 2;
+    std::size_t nextID  = rightEnd;
+
+    if (leftID != leftEnd && rightID != rightEnd) {
+        for (auto i = 0U; i < gateCosts.front() - 1; ++i) {
+            components.emplace_back(nextID, rightID);
+            ++nextID;
+            ++rightID;
+        }
+        gateCosts.pop_front();
+    }
+
+    while (leftID != leftEnd && rightID != rightEnd) {
+        components.emplace_back(leftID, nextID);
+        ++nextID;
+        --leftID;
+        for (auto i = 0U; i < gateCosts.front(); ++i) {
+            components.emplace_back(nextID, rightID);
+            ++nextID;
+            ++rightID;
+            if (rightID == rightEnd) {
+                break;
+            }
+        }
+        gateCosts.pop_front();
+        if (rightID == rightEnd) {
+            break;
+        }
+    }
+
+    //Finish the left-hand side
+    while (leftID != leftEnd) {
+        components.emplace_back(leftID, nextID);
+        ++nextID;
+        --leftID;
+    }
+
+    //Finish the right-hand side
+    while (rightID != rightEnd) {
+        components.emplace_back(nextID, rightID);
+        ++nextID;
+        ++rightID;
+    }
+
+    //Add the remaining matrix-vector multiplication
+    components.emplace_back(0, nextID);
+    setSimulationPath(components, true);
+}
+
 template<class Config>
 void PathSimulator<Config>::constructTaskGraph() {
     const auto& path  = simulationPath.components;