Add measuring test bits to select sampling data

CMakeLists.txt

@@ -157,3 +157,4 @@ target_include_directories(capi-demo
         ${QISKIT_CPP_ROOT}/src
 )
 
+target_compile_options(capi-demo PRIVATE "-DQRMI_ROOT=${QRMI_ROOT}")

src/main.cpp

@@ -36,6 +36,7 @@
 #include "primitives/backend_sampler_v2.hpp"
 #include "service/qiskit_runtime_service.hpp"
 
+using namespace Qiskit;
 using namespace Qiskit::circuit;
 using namespace Qiskit::providers;
 using namespace Qiskit::primitives;
@@ -307,10 +308,25 @@ int main(int argc, char *argv[])
             auto instructions = hf_and_ucj_op_spin_balanced_jw(qubits, nelec, ucj_op);
 
             // Quantum circuit with Qiskit C++
-            auto qr = QuantumRegister(2 * norb);   // quantum registers
-            auto cr = ClassicalRegister(2 * norb); // classical registers
-            auto circ =
-                QuantumCircuit(qr, cr); // create a quantum circuits with registers
+            // quantum registers
+            auto qr = QuantumRegister(2 * norb);
+            // classical registers
+            auto cr = ClassicalRegister(2 * norb, "meas");
+            // classical registers for test
+            auto cr_test = ClassicalRegister(2 * norb, "test");
+            std::vector<ClassicalRegister> cregs({cr});
+            if (sqd_data.use_reset_mitigation) {
+                cregs.push_back(cr_test);
+            }
+            // create a quantum circuits with registers
+            auto circ = QuantumCircuit(std::vector<QuantumRegister>({qr}), cregs);
+
+            if (sqd_data.use_reset_mitigation) {
+                // add measure to all qubits and store to test bits
+                circ.measure(qr, cr_test);
+                for (int i = 0; i < 2 * norb; i++)
+                    circ.barrier(i);
+            }
 
             // add gates from instruction list from hf_and_ucj_op_spin_balanced_jw
             //   for demo: calling Qiskit C++ circuit functions to make quantum circuit
@@ -370,7 +386,26 @@ int main(int argc, char *argv[])
 
             // Extract classical counts from the execution result.
             // These form the classical distribution for downstream recovery/selection.
-            counts = pub_result.data().get_counts();
+            if (sqd_data.use_reset_mitigation) {
+                auto meas_bits = pub_result.data("meas");
+                auto test_bits = pub_result.data("test");
+
+                // get index whose bitcout is zero
+                auto bitcounts = test_bits.bitcount();
+                reg_t zero_index;
+                zero_index.reserve(bitcounts.size());
+                for (uint_t i = 0; i < bitcounts.size(); i++) {
+                    if (bitcounts[i] == 0) {
+                        zero_index.push_back(i);
+                    }
+                }
+
+                // return bits only whose bitcount are zero
+                counts = meas_bits.get_counts(zero_index);
+            } else {
+                counts = pub_result.data().get_counts();
+            }
+
 #endif // USE_RANDOM_SHOTS
         }
 
@@ -435,7 +470,7 @@ int main(int argc, char *argv[])
                 // per iteration.
                 Qiskit::addon::sqd::subsample(
                     batch, postselected_bitstrings, postselected_probs,
-                    samples_per_batch, rng
+                    std::min(samples_per_batch, postselected_bitstrings.size()), rng
                 );
                 // Write alpha-determinants file for SBD input (includes run id /
                 // iteration for traceability).

src/sqd_helper.hpp

@@ -293,6 +293,7 @@ struct SQD {
     uint64_t samples_per_batch = 1000; // number of samples per batch
     bool verbose = false;              // print messages to stdout
     bool with_hf = true;               // use Hartree-Fock as a reference state
+    bool use_reset_mitigation = false;
 
     std::string backend_name = "";
     uint64_t num_shots = 10000;
@@ -358,6 +359,9 @@ SQD generate_sqd_data(int argc, char *argv[])
         if (std::string(argv[i]) == "-v") {
             sqd.verbose = true;
         }
+        if (std::string(argv[i]) == "--use_reset_mitigation") {
+            sqd.use_reset_mitigation = true;
+        }
     }
     return sqd;
 }