Add functions to handle multiple cregs and bitcounts (#120)

* Fix registers, add functions to get data by register name

* add releasenote

Author: doichanj

releasenotes/notes/add_support_multiple_cregs-db972b595457f252.yaml

@@ -0,0 +1,10 @@
+---
+features:
+  - |
+    Sampler pub result can return separate `BitArray` for each classical registers.
+
+    `BitArray` adds new functions.
+    `bitcount()` returns number of 1 bits in each bitstrings.
+    `get_counts()` and `get_bitstrings()` can have a list of index which element should be included in the map of counts
+    `get_bitstring` is renamed by `get_bitstrings`
+

samples/sampler_test.cpp

@@ -25,6 +25,7 @@
 #include "service/qiskit_runtime_service.hpp"
 #include "compiler/transpiler.hpp"
 
+using namespace Qiskit;
 using namespace Qiskit::circuit;
 using namespace Qiskit::providers;
 using namespace Qiskit::primitives;
@@ -36,18 +37,21 @@ using Sampler = BackendSamplerV2;
 int main()
 {
     int num_qubits = 10;
-    QuantumCircuit circ(num_qubits, num_qubits);
+    auto qreg = QuantumRegister(num_qubits);
+    auto creg = ClassicalRegister(num_qubits, std::string("meas"));
+    auto ctest = ClassicalRegister(num_qubits, std::string("test"));
+    QuantumCircuit circ(std::vector<QuantumRegister>({qreg,}), std::vector<ClassicalRegister>({creg, ctest}));
+
+    // test measure all
+    circ.measure(qreg, ctest);
 
     // GHZ circuit
     circ.h(0);
     for (int i = 0; i < num_qubits - 1; i++)
     {
         circ.cx(i, i + 1);
     }
-    for (int i = 0; i < num_qubits; i++)
-    {
-        circ.measure(i, i);
-    }
+    circ.measure(qreg, creg);
 
     // set $HONE/.qiskit/qiskit-ibm.json
     // by using Qiskit IBM Runtime
@@ -57,7 +61,7 @@ int main()
     // QISKIT_IBM_TOKEN = "your API key"
     // QISKIT_IBM_INSTANCE = "your CRN"
     auto service = QiskitRuntimeService();
-    auto backend = service.backend("ibm_torino");
+    auto backend = service.backend("ibm_fez");
     auto sampler = Sampler(backend, 100);
 
     auto transpiled_circ = transpile(circ, backend);
@@ -68,16 +72,43 @@ int main()
     auto result = job->result();
 
     auto pub_result = result[0];
-    auto hex = pub_result.data().get_hexstring();
+    auto meas_bits = pub_result.data("meas");
+    auto bits = meas_bits.get_bitstrings();
     std::cout << " ===== samples for pub[0] =====" << std::endl;
-    for (auto h : hex)
+    for (auto b : bits)
+    {
+        std::cout << b << ", ";
+    }
+    std::cout << std::endl;
+
+    std::cout << " --- test bits ---" << std::endl;
+    auto test_bits = pub_result.data("test");
+    bits = test_bits.get_bitstrings();
+    for (auto b : bits)
     {
-        std::cout << h << ", ";
+        std::cout << b << ", ";
     }
     std::cout << std::endl;
 
     std::cout << " ===== counts for pub[0] =====" << std::endl;
-    auto count = pub_result.data().get_counts();
+    auto count = meas_bits.get_counts();
+    for (auto c : count)
+    {
+        std::cout << c.first << " : " << c.second << std::endl;
+    }
+
+
+    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);
+        }
+    }
+
+    std::cout << " ===== counts for pub[0] whose test bit are 0 =====" << std::endl;
+    count = meas_bits.get_counts(zero_index);
     for (auto c : count)
     {
         std::cout << c.first << " : " << c.second << std::endl;

src/circuit/quantumcircuit_def.hpp

@@ -88,7 +88,7 @@ class QuantumCircuit
 	/// @param qregs A list of QuantumRegister
 	/// @param cregs A list of ClassicalRegister
 	/// @param global_phase The global phase of the circuit, measured in radians
-	QuantumCircuit(std::vector<QuantumRegister> &qregs, std::vector<ClassicalRegister> &cregs, const double global_phase = 0.0);
+	QuantumCircuit(std::vector<QuantumRegister> qregs, std::vector<ClassicalRegister> cregs, const double global_phase = 0.0);
 
 	/// @brief Create a new reference to Quantum Circuit
 	/// @details Copy constructor of QuantumCircuit does not copy the circuit,
@@ -122,6 +122,34 @@ class QuantumCircuit
 		return num_clbits_;
 	}
 
+	/// @brief Return number of qregs
+	/// @return number of qregs
+	uint_t num_qregs(void) const
+	{
+		return qregs_.size();
+	}
+
+	/// @brief Return number of cregs
+	/// @return number of cregs
+	uint_t num_cregs(void) const
+	{
+		return cregs_.size();
+	}
+
+	/// @brief Return a list of qregs
+	/// @return reference to a list of qregs
+	const std::vector<QuantumRegister>& qregs(void) const
+	{
+		return qregs_;
+	}
+
+	/// @brief Return a list of cregs
+	/// @return reference to a list of cregs
+	const std::vector<ClassicalRegister>& cregs(void) const
+	{
+		return cregs_;
+	}
+
 	std::shared_ptr<rust_circuit> get_rust_circuit(const bool update = true)
 	{
 		if (update)
@@ -133,9 +161,10 @@ class QuantumCircuit
 	/// @return copied circuit
 	QuantumCircuit copy(void);
 
-	/// @brief set circuit reference of Rust's circuit
+	/// @brief set circuit reference of Qiskit circuit
 	/// @param circ smart pointer to RUst circuit
-	void from_rust_circuit(std::shared_ptr<rust_circuit> circ, const std::vector<uint32_t> &map);
+	/// @param map layout mapping
+	void set_qiskit_circuit(std::shared_ptr<rust_circuit> circ, const std::vector<uint32_t> &map);
 
 	/// @brief set target to this circuit
 	/// @param target smart pointer to target

src/circuit/quantumcircuit_impl.hpp

@@ -47,7 +47,7 @@ QuantumCircuit::QuantumCircuit(const uint_t num_qubits, const uint_t num_clbits,
     qregs_[0] = qr;
     cregs_[0] = cr;
 
-    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new((std::uint32_t)num_qubits_, (std::uint32_t)num_clbits_), qk_circuit_free);
+    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new(0, 0), qk_circuit_free);
     qk_circuit_add_quantum_register(rust_circuit_.get(), qregs_[0].get_register().get());
     qk_circuit_add_classical_register(rust_circuit_.get(), cregs_[0].get_register().get());
 
@@ -69,7 +69,7 @@ QuantumCircuit::QuantumCircuit(QuantumRegister &qreg, ClassicalRegister &creg, c
     qregs_[0] = qreg;
     cregs_[0] = creg;
 
-    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new((std::uint32_t)num_qubits_, (std::uint32_t)num_clbits_), qk_circuit_free);
+    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new(0, 0), qk_circuit_free);
 
     qk_circuit_add_quantum_register(rust_circuit_.get(), qregs_[0].get_register().get());
     qk_circuit_add_classical_register(rust_circuit_.get(), cregs_[0].get_register().get());
@@ -80,7 +80,7 @@ QuantumCircuit::QuantumCircuit(QuantumRegister &qreg, ClassicalRegister &creg, c
     }
 }
 
-QuantumCircuit::QuantumCircuit(std::vector<QuantumRegister> &qregs, std::vector<ClassicalRegister> &cregs, const double global_phase)
+QuantumCircuit::QuantumCircuit(std::vector<QuantumRegister> qregs, std::vector<ClassicalRegister> cregs, const double global_phase)
 {
     num_qubits_ = 0;
     num_clbits_ = 0;
@@ -105,7 +105,7 @@ QuantumCircuit::QuantumCircuit(std::vector<QuantumRegister> &qregs, std::vector<
         num_clbits_ += cregs[i].size();
     }
 
-    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new((std::uint32_t)num_qubits_, (std::uint32_t)num_clbits_), qk_circuit_free);
+    rust_circuit_ = std::shared_ptr<rust_circuit>(qk_circuit_new(0, 0), qk_circuit_free);
 
     for (uint_t i = 0; i < qregs_.size(); i++)
     {
@@ -158,20 +158,14 @@ QuantumCircuit QuantumCircuit::copy(void)
     return copied;
 }
 
-void QuantumCircuit::from_rust_circuit(std::shared_ptr<rust_circuit> circ, const std::vector<uint32_t> &map)
+void QuantumCircuit::set_qiskit_circuit(std::shared_ptr<rust_circuit> circ, const std::vector<uint32_t> &map)
 {
     if (rust_circuit_)
         rust_circuit_.reset();
     rust_circuit_ = circ;
     num_qubits_ = qk_circuit_num_qubits(circ.get());
     num_clbits_ = qk_circuit_num_clbits(circ.get());
 
-    qregs_.resize(1);
-    cregs_.resize(1);
-
-    qregs_[0].resize(num_qubits_);
-    cregs_[0].resize(num_clbits_);
-
     qubit_map_.resize(map.size());
     for (int i = 0; i < map.size(); i++)
     {

src/circuit/register.hpp

@@ -150,7 +150,7 @@ class Register
 
     /// @brief Return the name of this register
     /// @return the name of this register
-    std::string name() { return name_; }
+    const std::string& name() const { return name_; }
 
     void set_base_index(uint_t base)
     {

src/compiler/transpiler.hpp

@@ -59,8 +59,8 @@ circuit::QuantumCircuit transpile(circuit::QuantumCircuit &circ, providers::Back
     std::vector<uint32_t> layout_map(qk_transpile_layout_num_output_qubits(result.layout));
     qk_transpile_layout_final_layout(result.layout, false, layout_map.data());
 
-    circuit::QuantumCircuit transpiled;
-    transpiled.from_rust_circuit(std::shared_ptr<rust_circuit>(result.circuit, qk_circuit_free), layout_map);
+    circuit::QuantumCircuit transpiled = circ;
+    transpiled.set_qiskit_circuit(std::shared_ptr<rust_circuit>(result.circuit, qk_circuit_free), layout_map);
     transpiled.set_target(target);
 
     qk_transpile_layout_free(result.layout);

src/primitives/containers/bit_array.hpp

@@ -83,18 +83,39 @@ class BitArray {
     // from bitstring
     void from_bitstring(const std::vector<std::string>& samples);
 
+    /// @brief Return subsets of the BitArray
+    /// @param start_bit start bit index of subset
+    /// @param num_bits number of bits in a subset
+    /// @return A new BitArray
+    BitArray get_subset(const uint_t start_bit, const uint_t num_bits);
+
+    /// @brief Return a list of bitstrings.
+    /// @return A list of bitstrings.
+    std::vector<std::string> get_bitstrings(void);
+
     /// @brief Return a list of bitstrings.
+    /// @param index a list of index to be stored in the output list
     /// @return A list of bitstrings.
-    std::vector<std::string> get_bitstring(void);
+    std::vector<std::string> get_bitstrings(reg_t& index);
 
     /// @brief Return a list of hex string
     /// @return A list of hex string.
-    std::vector<std::string> get_hexstring(void);
+    std::vector<std::string> get_hexstrings(void);
+
+    /// @brief Return a list of hex string.
+    /// @param index a list of index to be stored in the output list
+    /// @return A list of hex string.
+    std::vector<std::string> get_hexstrings(reg_t& index);
 
     /// @brief Return a counts dictionary with bitstring keys.
     /// @return A counts dictionary with bitstring keys.
     std::unordered_map<std::string, uint_t> get_counts(void);
 
+    /// @brief Return a counts dictionary with bitstring keys.
+    /// @param index a list of index to be stored in the output map
+    /// @return A counts dictionary with bitstring keys.
+    std::unordered_map<std::string, uint_t> get_counts(reg_t& index);
+
     /// @brief Set pub samples from json
     /// @param input JSON input
     void from_json(nlohmann::ordered_json& input);
@@ -103,6 +124,11 @@ class BitArray {
     /// @param index an index to be set
     /// @param input a sample in a hex string format
     void set_hexstring(uint_t index, std::string& input);
+
+    /// @brief Return a list of bit counts
+    /// @return A list of interger counts of bits appears in each shot
+    reg_t bitcount(void);
+
 };
 
 void BitArray::from_samples(const reg_t& samples, uint_t num_bits)
@@ -132,7 +158,7 @@ void BitArray::from_bitstring(const std::vector<std::string>& samples)
     num_bits_ = array_[0].size();
 }
 
-std::vector<std::string> BitArray::get_bitstring(void)
+std::vector<std::string> BitArray::get_bitstrings(void)
 {
     std::vector<std::string> ret(array_.size());
     for (uint_t i = 0; i < array_.size(); i++) {
@@ -141,7 +167,20 @@ std::vector<std::string> BitArray::get_bitstring(void)
     return ret;
 }
 
-std::vector<std::string> BitArray::get_hexstring(void)
+std::vector<std::string> BitArray::get_bitstrings(reg_t& index)
+{
+    uint_t size = std::min(array_.size(), index.size());
+    std::vector<std::string> ret(size);
+
+    for (uint_t i = 0; i < size; i++) {
+        uint_t pos = index[i];
+        if (pos < array_.size())
+            ret[i] = array_[pos].to_string();
+    }
+    return ret;
+}
+
+std::vector<std::string> BitArray::get_hexstrings(void)
 {
     std::vector<std::string> ret(array_.size());
     for (uint_t i = 0; i < array_.size(); i++) {
@@ -150,6 +189,20 @@ std::vector<std::string> BitArray::get_hexstring(void)
     return ret;
 }
 
+std::vector<std::string> BitArray::get_hexstrings(reg_t& index)
+{
+    uint_t size = std::min(array_.size(), index.size());
+    std::vector<std::string> ret(size);
+
+    for (uint_t i = 0; i < size; i++) {
+        uint_t pos = index[i];
+        if (pos < array_.size())
+            ret[i] = array_[pos].to_hex_string();
+    }
+    return ret;
+}
+
+
 std::unordered_map<std::string, uint_t> BitArray::get_counts(void)
 {
     std::unordered_map<std::string, uint_t> ret;
@@ -159,10 +212,23 @@ std::unordered_map<std::string, uint_t> BitArray::get_counts(void)
     return ret;
 }
 
+std::unordered_map<std::string, uint_t> BitArray::get_counts(reg_t& index)
+{
+    uint_t size = std::min(array_.size(), index.size());
+    std::unordered_map<std::string, uint_t> ret;
+
+    for (uint_t i = 0; i < size; i++) {
+        uint_t pos = index[i];
+        if (pos < array_.size())
+            ret[array_[pos].to_string()]++;
+    }
+    return ret;
+}
+
 void BitArray::from_json(nlohmann::ordered_json& input)
 {
-    auto samples = input["data"]["c"]["samples"];
-    auto num_bits = input["data"]["c"]["num_bits"];
+    auto samples = input["samples"];
+    auto num_bits = input["num_bits"];
     auto num_shots = samples.size();
     if (num_bits_ == 0)
         num_bits_ = num_bits;
@@ -178,6 +244,27 @@ void BitArray::set_hexstring(uint_t index, std::string& input)
         array_[index].from_hex_string(input);
 }
 
+BitArray BitArray::get_subset(const uint_t start_bit, const uint_t num_bits)
+{
+    BitArray ret;
+    ret.allocate(array_.size(), num_bits);
+
+    for (uint_t i = 0; i < array_.size(); i++) {
+        ret.array_[i] = array_[i].get_subset(start_bit, num_bits);
+    }
+
+    return ret;
+}
+
+reg_t BitArray::bitcount(void)
+{
+    reg_t count(array_.size());
+    for (uint_t i = 0; i < array_.size(); i++) {
+        count[i] = array_[i].popcount();
+    }
+    return count;
+}
+
 
 
 } // namespace primitives