✨ Noise-Aware Simulator Refactor and Backends

apps/noise_aware.cpp

@@ -29,9 +29,8 @@ int main(int argc, char** argv) { // NOLINT(bugprone-exception-escape)
         ("noise_prob", "Probability for applying noise.", cxxopts::value<double>()->default_value("0.001"))
         ("noise_prob_t1", "Probability for applying amplitude damping noise (default:2 x noise_prob)", cxxopts::value<double>())
         ("noise_prob_multi", "Noise factor for multi qubit operations", cxxopts::value<double>()->default_value("2"))
-        ("unoptimized_sim", "Use unoptimized scheme for stochastic/deterministic noise-aware simulation")
-        ("stoch_runs", "Number of stochastic runs. When the value is 0, the deterministic simulator is started. ", cxxopts::value<std::size_t>()->default_value("0"))
-        ("properties", R"(Comma separated list of tracked amplitudes, when conducting a stochastic simulation. The "-" operator can be used to specify a range.)", cxxopts::value<std::string>()->default_value("0-100"))
+        ("use_density_matrix_simulator", "Set this flag to use the density matrix simulator. Per default the stochastic simulator is used")
+        ("shots", "Specify the number of shots that shall be generated", cxxopts::value<std::size_t>()->default_value("0"))
 
     ; // end arguments list
     // clang-format on
@@ -62,23 +61,23 @@ int main(int argc, char** argv) { // NOLINT(bugprone-exception-escape)
         noiseProbT1 = vm["noise_prob_t1"].as<double>();
     }
 
-    if (vm["stoch_runs"].as<std::size_t>() > 0) {
+    if (vm.count("use_density_matrix_simulator") == 0) {
+        const auto              approxSteps  = vm["steps"].as<unsigned int>();
+        const auto              stepFidelity = vm["step_fidelity"].as<double>();
+        const ApproximationInfo approxInfo{stepFidelity, approxSteps, ApproximationInfo::FidelityDriven};
+
         // Using stochastic simulator
-        auto ddsim = std::make_unique<StochasticNoiseSimulator<>>(std::move(quantumComputation),
-                                                                  vm["noise_effects"].as<std::string>(),
-                                                                  vm["noise_prob"].as<double>(),
-                                                                  noiseProbT1,
-                                                                  vm["noise_prob_multi"].as<double>(),
-                                                                  vm["stoch_runs"].as<size_t>(),
-                                                                  vm["properties"].as<std::string>(),
-                                                                  vm.count("unoptimized_sim"),
-                                                                  vm["steps"].as<unsigned int>(),
-                                                                  vm["step_fidelity"].as<double>(),
-                                                                  vm["seed"].as<std::size_t>());
+        auto ddsim = std::make_unique<StochasticNoiseSimulator>(std::move(quantumComputation),
+                                                                approxInfo,
+                                                                vm["seed"].as<std::size_t>(),
+                                                                vm["noise_effects"].as<std::string>(),
+                                                                vm["noise_prob"].as<double>(),
+                                                                noiseProbT1,
+                                                                vm["noise_prob_multi"].as<double>());
 
         auto t1 = std::chrono::steady_clock::now();
 
-        const std::map<std::string, double> measurementResults = ddsim->stochSimulate();
+        const auto measurementResults = ddsim->simulate(vm["shots"].as<size_t>());
 
         auto t2 = std::chrono::steady_clock::now();
 
@@ -92,8 +91,6 @@ int main(int argc, char** argv) { // NOLINT(bugprone-exception-escape)
                     {"benchmark", ddsim->getName()},
                     {"n_qubits", +ddsim->getNumberOfQubits()},
                     {"applied_gates", ddsim->getNumberOfOps()},
-                    {"max_nodes", ddsim->getMaxNodeCount()},
-                    {"max_matrix_nodes", ddsim->getMaxMatrixNodeCount()},
                     {"seed", ddsim->getSeed()},
             };
 
@@ -106,18 +103,21 @@ int main(int argc, char** argv) { // NOLINT(bugprone-exception-escape)
             outputObj["measurement_results"] = measurementResults;
         }
 
-        std::cout << std::setw(2) << outputObj << std::endl;
+        std::cout << std::setw(2) << outputObj << "\n";
 
-    } else if (vm["stoch_runs"].as<std::size_t>() == 0) {
+    } else if (vm.count("use_density_matrix_simulator") > 0) {
         // Using deterministic simulator
-        auto ddsim = std::make_unique<DeterministicNoiseSimulator<>>(std::move(quantumComputation), vm["noise_effects"].as<std::string>(),
-                                                                     vm["noise_prob"].as<double>(),
-                                                                     noiseProbT1,
-                                                                     vm["noise_prob_multi"].as<double>(), vm["seed"].as<std::size_t>());
+        auto ddsim = std::make_unique<DeterministicNoiseSimulator>(std::move(quantumComputation),
+                                                                   ApproximationInfo{},
+                                                                   vm["seed"].as<std::size_t>(),
+                                                                   vm["noise_effects"].as<std::string>(),
+                                                                   vm["noise_prob"].as<double>(),
+                                                                   noiseProbT1,
+                                                                   vm["noise_prob_multi"].as<double>());
 
         auto t1 = std::chrono::steady_clock::now();
 
-        const auto measurementResults = ddsim->deterministicSimulate();
+        const auto measurementResults = ddsim->simulate(vm["shots"].as<size_t>());
 
         auto t2 = std::chrono::steady_clock::now();
 

docs/source/simulators/NoiseAwareSimulator.rst

@@ -28,89 +28,95 @@ The simulator provides a help function which is called in the following way:
 .. code-block:: console
 
     $ ./build/apps/ddsim_noise_aware --help
-	see for more information https://www.cda.cit.tum.de/
-    Usage:
-	MQT DDSIM [OPTION...]
-	-h, --help                  produce help message
-	  --seed arg              seed for random number generator (default zero is possibly directly used as seed!) (default: 0)
-	  --pm                    print measurements
-	  --ps                    print simulation stats (applied gates, sim. time, and maximal size of the DD)
-	  --verbose               Causes some simulators to print additional  information to STDERR
-	  --simulate_file arg     simulate a quantum circuit given by file (detection by the file extension)
-	  --step_fidelity arg     target fidelity for each approximation run (>=1 = disable approximation) (default: 1.0)
-	  --steps arg             number of approximation steps (default: 1)
-	  --noise_effects arg     Noise effects (A (=amplitude damping),D (=depolarization),P (=phase flip)) in the form of a character string describing the noise effects (default: APD)
-	  --noise_prob arg        Probability for applying noise. (default: 0.001)
-	  --noise_prob_t1 arg     Probability for applying amplitude damping noise (default:2 x noise_prob)
-	  --noise_prob_multi arg  Noise factor for multi qubit operations (default: 2)
-	  --unoptimized_sim       Use unoptimized scheme for stochastic/deterministic noise-aware simulation
-	  --stoch_runs arg        Number of stochastic runs. When the value is 0, the deterministic simulator is started. (default: 0)
-	  --properties arg        Comma separated list of tracked amplitudes, when conducting a stochastic simulation. The "-" operator can be used to specify a range. (default: 0-100)
+      see for more information https://www.cda.cit.tum.de/
+      Usage:
+        MQT DDSIM [OPTION...]
+
+        -h, --help                              produce help message
+            --seed arg                          seed for random number generator (default zero is possibly directly used as seed!)(default: 0)
+            --pm                                print measurements
+            --ps                                print simulation stats (applied gates, sim. time, and maximal size of the DD)
+            --verbose                           Causes some simulators to print additional information to STDERR
+            --simulate_file arg                 simulate a quantum circuit given by file (detection by the file extension)
+            --step_fidelity arg                 target fidelity for each approximation run (>=1 = disable approximation) (default: 1.0)
+            --steps arg                         number of approximation steps (default: 1)
+            --noise_effects arg                 Noise effects (A (=amplitude damping),D (=depolarization),P (=phase flip)) in the form of a character string describing the noise effects (default: APD)
+            --noise_prob arg                    Probability for applying noise. (default: 0.001)
+            --noise_prob_t1 arg                 Probability for applying amplitude damping noise (default:2 x noise_prob)
+            --noise_prob_multi arg              Noise factor for multi qubit operations (default: 2)
+            --use_density_matrix_simulator      Set this flag to use the density matrix simulator. Per default the stochastic simulator is used
+            --shots arg                         Specify the number of shots that shall be generated (default: 0)
 
 
 An example run of the stochastic simulator, with 1000 samples, amplitude damping, phase flip, and depolarization error enabled (each with a probability of 0.1% whenever a gate is applied) looks like this:
 
 .. code-block:: console
 
-    $./build/apps/ddsim_noise_aware --noise_effects APD --noise_prob 0.001 --stoch_runs 1000 --simulate_file adder_n4.qasm  --pm --ps
-    {
-      "measurement_results": {
-        "0000": 0.010506209312687873,
-        "0001": 0.011493790687312124,
-        "0010": 0.002500492484500565,
-        "0011": 0.0004995075154994353,
-        "0100": 0.0015015015015015015,
-        "0101": 0.0014984984984984986,
-        "0110": 0.011499960617703234,
-        "0111": 0.0005000393822967641,
-        "1000": 0.04201375737631414,
-        "1001": 0.8969862426236844,
-        "1010": 0.002502502502502502,
-        "1011": 0.0024974974974974976,
-        "1100": 0.004003012087216088,
-        "1101": 0.0049969879127839106,
-        "1110": 0.006500446429090525,
-        "1111": 0.0004995535709094751
-      },
-      "statistics": {
-        "applied_gates": 23,
-        "approximation_runs": "0.000000",
-        "benchmark": "stoch_adder_n4",
-        "max_matrix_nodes": 0,
-        "max_nodes": 0,
-        "mean_stoch_run_time": "0.000000",
-        "n_qubits": 4,
-        "parallel_instances": "8",
-        "perfect_run_time": "0.000000",
-        "seed": "0",
-        "simulation_time": 0.6007186770439148,
-        "step_fidelity": "1.000000",
-        "stoch_runs": "1000",
-        "stoch_wall_time": "0.600710",
-        "threads": "8"
-      }
-    }
-
-The deterministic simulator is run when "stochastic_runs" is set to 0. The same run from above, using the deterministic simulator would look like this:
+    $./build/apps/ddsim_noise_aware ./build/apps/ddsim_noise_aware --noise_effects APD --noise_prob 0.001 --shots 1000 --simulate_file adder_n4.qasm  --pm --ps
+   {
+     "measurement_results": {
+       "0000": 15,
+       "0001": 36,
+       "0010": 3,
+       "0011": 3,
+       "0100": 3,
+       "0110": 4,
+       "0111": 4,
+       "1000": 9,
+       "1001": 915,
+       "1010": 2,
+       "1011": 1,
+       "1101": 4,
+       "1111": 1
+     },
+     "statistics": {
+       "applied_gates": 27,
+       "approximation_runs": "0.000000",
+       "benchmark": "stoch_adder_n4",
+       "max_matrix_nodes": 0,
+       "max_nodes": 0,
+       "mean_stoch_run_time": "0.000000",
+       "n_qubits": 4,
+       "parallel_instances": "8",
+       "perfect_run_time": "0.000000",
+       "seed": "0",
+       "simulation_time": 0.2757418751716614,
+       "step_fidelity": "1.000000",
+       "stoch_runs": "1000",
+       "stoch_wall_time": "0.275722",
+       "threads": "8"
+     }
+   }
+
+The deterministic simulator is run when the flag "--use_density_matrix_simulator" is set. The same run from above, using the deterministic simulator would look like this:
 
 .. code-block:: console
 
-    $ ./build/apps/ddsim_noise_aware --noise_effects APD --noise_prob 0.001 --stoch_runs 0 --simulate_file adder_n4.qasm  --pm --ps
-    {
-      "measurement_results": {
-        "0000": 0.013477634679595526,
-        "0001": 0.013345991328932352,
-        "1000": 0.03746879852829717,
-        "1001": 0.9082983936899753
-      },
-      "statistics": {
-        "active_matrix_nodes": 0,
-        "active_nodes": 22,
-        "applied_gates": 23,
-        "benchmark": "adder_n4",
-        "max_matrix_nodes": 0,
-        "n_qubits": 4,
-        "seed": "0",
-        "simulation_time": 0.003795960918068886
-      }
+    $ ./build/apps/ddsim_noise_aware --noise_effects APD --noise_prob 0.001 --shots 1000 --simulate_file adder_n4.qasm  --pm --ps --use_density_matrix_simulator
+  {
+    "measurement_results": {
+      "0000": 12,
+      "0001": 40,
+      "0010": 1,
+      "0011": 5,
+      "0100": 3,
+      "0101": 1,
+      "0110": 1,
+      "0111": 7,
+      "1000": 12,
+      "1001": 912,
+      "1010": 3,
+      "1011": 1,
+      "1101": 2
+    },
+    "statistics": {
+      "active_matrix_nodes": 0,
+      "active_nodes": 22,
+      "applied_gates": 27,
+      "benchmark": "adder_n4",
+      "max_matrix_nodes": 0,
+      "n_qubits": 4,
+      "seed": "0",
+      "simulation_time": 0.0007002829806879163
     }
+  }

include/CircuitSimulator.hpp

@@ -71,6 +71,10 @@ class CircuitSimulator: public Simulator<Config> {
         Simulator<Config>::dd->resize(qc->getNqubits());
     }
 
+    std::map<std::string, std::size_t> measureAllNonCollapsing(std::size_t shots) override {
+        return Simulator<Config>::measureAllNonCollapsing(shots);
+    }
+
     std::map<std::string, std::size_t> simulate(std::size_t shots) override;
 
     virtual dd::fp expectationValue(const qc::QuantumComputation& observable);
@@ -94,11 +98,24 @@ class CircuitSimulator: public Simulator<Config> {
     std::unique_ptr<qc::QuantumComputation> qc;
     std::size_t                             singleShots{0};
 
-    ApproximationInfo approximationInfo{};
+    ApproximationInfo approximationInfo;
     std::size_t       approximationRuns{0};
     long double       finalFidelity{1.0L};
 
-    std::map<std::size_t, bool> singleShot(bool ignoreNonUnitaries);
+    struct CircuitAnalysis {
+        bool                        isDynamic       = false;
+        bool                        hasMeasurements = false;
+        std::map<qc::Qubit, size_t> measurementMap;
+    };
+
+    CircuitAnalysis analyseCircuit();
+
+    virtual std::map<std::size_t, bool> singleShot(bool ignoreNonUnitaries);
+    virtual void                        initializeSimulation(std::size_t nQubits);
+    virtual char                        measure(dd::Qubit i);
+
+    virtual void reset(qc::NonUnitaryOperation* nonUnitaryOp);
+    virtual void applyOperationToState(std::unique_ptr<qc::Operation>& op);
 };
 
 #endif //DDSIM_CIRCUITSIMULATOR_HPP