qiskit 1.1.1__tar.gz → 1.1.2__tar.gz

{qiskit-1.1.1 → qiskit-1.1.2}/Cargo.lock

@@ -1095,7 +1095,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "1.1.1"
+version = "1.1.2"
 dependencies = [
  "ahash 0.8.11",
  "approx",
@@ -1122,7 +1122,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "1.1.1"
+version = "1.1.2"
 dependencies = [
  "hashbrown 0.14.5",
  "pyo3",
@@ -1130,7 +1130,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "1.1.1"
+version = "1.1.2"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1141,16 +1141,17 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "1.1.1"
+version = "1.1.2"
 dependencies = [
  "hashbrown 0.14.5",
+ "num-bigint",
  "pyo3",
  "qiskit-circuit",
 ]
 
 [[package]]
 name = "qiskit-qasm3"
-version = "1.1.1"
+version = "1.1.2"
 dependencies = [
  "hashbrown 0.14.5",
  "indexmap 2.2.6",

{qiskit-1.1.1 → qiskit-1.1.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "1.1.1"
+version = "1.1.2"
 edition = "2021"
 rust-version = "1.70"  # Keep in sync with README.md and rust-toolchain.toml.
 license = "Apache-2.0"
@@ -16,6 +16,8 @@ license = "Apache-2.0"
 [workspace.dependencies]
 indexmap.version = "2.2.6"
 hashbrown.version = "0.14.0"
+num-bigint = "0.4"
+
 # Most of the crates don't need the feature `extension-module`, since only `qiskit-pyext` builds an
 # actual C extension (the feature disables linking in `libpython`, which is forbidden in Python
 # distributions).  We only activate that feature when building the C extension module; we still need

{qiskit-1.1.1 → qiskit-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.1.1
+Version: 1.1.2
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/Cargo.toml

@@ -18,7 +18,7 @@ rand_distr = "0.4.3"
 ahash = "0.8.11"
 num-traits = "0.2"
 num-complex = "0.4"
-num-bigint = "0.4"
+num-bigint.workspace = true
 rustworkx-core = "0.14"
 faer = "0.18.2"
 itertools = "0.12.1"

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/convert_2q_block_matrix.rs

@@ -74,7 +74,6 @@ pub fn change_basis(matrix: ArrayView2<Complex64>) -> Array2<Complex64> {
     trans_matrix
 }
 
-#[pymodule]
 pub fn convert_2q_block_matrix(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(blocks_to_matrix))?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/dense_layout.rs

@@ -223,7 +223,6 @@ pub fn best_subset(
     ))
 }
 
-#[pymodule]
 pub fn dense_layout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(best_subset))?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/error_map.rs

@@ -111,7 +111,6 @@ impl ErrorMap {
     }
 }
 
-#[pymodule]
 pub fn error_map(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<ErrorMap>()?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/euler_one_qubit_decomposer.rs

@@ -883,7 +883,6 @@ pub fn params_zxz(unitary: PyReadonlyArray2<Complex64>) -> [f64; 4] {
     params_zxz_inner(mat)
 }
 
-#[pymodule]
 pub fn euler_one_qubit_decomposer(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(params_zyz))?;
     m.add_wrapped(wrap_pyfunction!(params_xyx))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/isometry.rs

@@ -348,7 +348,6 @@ fn b(k: usize, s: usize) -> usize {
     k - (a(k, s) * 2_usize.pow(s as u32))
 }
 
-#[pymodule]
 pub fn isometry(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(diag_is_identity_up_to_global_phase))?;
     m.add_wrapped(wrap_pyfunction!(find_squs_for_disentangling))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/nlayout.rs

@@ -216,7 +216,6 @@ impl NLayout {
     }
 }
 
-#[pymodule]
 pub fn nlayout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<NLayout>()?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/optimize_1q_gates.rs

@@ -90,7 +90,6 @@ pub fn compose_u3_rust(
     out_angles
 }
 
-#[pymodule]
 pub fn optimize_1q_gates(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(compose_u3_rust))?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/pauli_exp_val.rs

@@ -192,7 +192,6 @@ pub fn density_expval_pauli_with_x(
     }
 }
 
-#[pymodule]
 pub fn pauli_expval(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(expval_pauli_no_x))?;
     m.add_wrapped(wrap_pyfunction!(expval_pauli_with_x))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/results/mod.rs

@@ -16,7 +16,6 @@ pub mod marginalization;
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
-#[pymodule]
 pub fn results(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(marginalization::marginal_counts))?;
     m.add_wrapped(wrap_pyfunction!(marginalization::marginal_distribution))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/sabre/mod.rs

@@ -113,7 +113,6 @@ impl BlockResult {
     }
 }
 
-#[pymodule]
 pub fn sabre(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(route::sabre_routing))?;
     m.add_wrapped(wrap_pyfunction!(layout::sabre_layout_and_routing))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/sampled_exp_val.rs

@@ -86,7 +86,6 @@ pub fn sampled_expval_complex(
     Ok(out.re)
 }
 
-#[pymodule]
 pub fn sampled_exp_val(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(sampled_expval_float))?;
     m.add_wrapped(wrap_pyfunction!(sampled_expval_complex))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/sparse_pauli_op.rs

@@ -816,7 +816,6 @@ impl_to_matrix_sparse!(
     u64
 );
 
-#[pymodule]
 pub fn sparse_pauli_op(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(unordered_unique))?;
     m.add_wrapped(wrap_pyfunction!(decompose_dense))?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/stochastic_swap.rs

@@ -335,7 +335,6 @@ pub fn swap_trials(
     Ok((best_edges, best_layout, best_depth))
 }
 
-#[pymodule]
 pub fn stochastic_swap(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(swap_trials))?;
     m.add_class::<EdgeCollection>()?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/two_qubit_decompose.rs

@@ -2042,7 +2042,6 @@ impl TwoQubitBasisDecomposer {
     }
 }
 
-#[pymodule]
 pub fn two_qubit_decompose(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(_num_basis_gates))?;
     m.add_class::<TwoQubitGateSequence>()?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/uc_gate.rs

@@ -156,7 +156,6 @@ pub fn dec_ucg_help(
     )
 }
 
-#[pymodule]
 pub fn uc_gate(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(dec_ucg_help))?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/utils.rs

@@ -41,7 +41,6 @@ pub fn eigenvalues(py: Python, unitary: PyReadonlyArray2<Complex<f64>>) -> PyObj
         .into()
 }
 
-#[pymodule]
 pub fn utils(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(eigenvalues))?;
     Ok(())

{qiskit-1.1.1 → qiskit-1.1.2}/crates/accelerate/src/vf2_layout.rs

@@ -106,7 +106,6 @@ pub fn score_layout(
     Ok(1. - fidelity)
 }
 
-#[pymodule]
 pub fn vf2_layout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(score_layout))?;
     m.add_class::<EdgeList>()?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/circuit/src/lib.rs

@@ -27,8 +27,7 @@ pub enum SliceOrInt<'a> {
     Slice(Bound<'a, PySlice>),
 }
 
-#[pymodule]
-pub fn circuit(m: Bound<PyModule>) -> PyResult<()> {
+pub fn circuit(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<circuit_data::CircuitData>()?;
     m.add_class::<circuit_instruction::CircuitInstruction>()?;
     Ok(())

qiskit-1.1.2/crates/pyext/src/lib.rs

@@ -0,0 +1,59 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use pyo3::prelude::*;
+
+use qiskit_accelerate::{
+    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
+    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
+    sparse_pauli_op::sparse_pauli_op, stochastic_swap::stochastic_swap,
+    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
+    vf2_layout::vf2_layout,
+};
+
+#[inline(always)]
+#[doc(hidden)]
+fn add_submodule<F>(m: &Bound<PyModule>, constructor: F, name: &str) -> PyResult<()>
+where
+    F: FnOnce(&Bound<PyModule>) -> PyResult<()>,
+{
+    let new_mod = PyModule::new_bound(m.py(), name)?;
+    constructor(&new_mod)?;
+    m.add_submodule(&new_mod)
+}
+
+#[pymodule]
+fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
+    add_submodule(m, qiskit_circuit::circuit, "circuit")?;
+    add_submodule(m, qiskit_qasm2::qasm2, "qasm2")?;
+    add_submodule(m, qiskit_qasm3::qasm3, "qasm3")?;
+    add_submodule(m, convert_2q_block_matrix, "convert_2q_block_matrix")?;
+    add_submodule(m, dense_layout, "dense_layout")?;
+    add_submodule(m, error_map, "error_map")?;
+    add_submodule(m, euler_one_qubit_decomposer, "euler_one_qubit_decomposer")?;
+    add_submodule(m, isometry, "isometry")?;
+    add_submodule(m, nlayout, "nlayout")?;
+    add_submodule(m, optimize_1q_gates, "optimize_1q_gates")?;
+    add_submodule(m, pauli_expval, "pauli_expval")?;
+    add_submodule(m, results, "results")?;
+    add_submodule(m, sabre, "sabre")?;
+    add_submodule(m, sampled_exp_val, "sampled_exp_val")?;
+    add_submodule(m, sparse_pauli_op, "sparse_pauli_op")?;
+    add_submodule(m, stochastic_swap, "stochastic_swap")?;
+    add_submodule(m, two_qubit_decompose, "two_qubit_decompose")?;
+    add_submodule(m, uc_gate, "uc_gate")?;
+    add_submodule(m, utils, "utils")?;
+    add_submodule(m, vf2_layout, "vf2_layout")?;
+    Ok(())
+}

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm2/Cargo.toml

@@ -10,6 +10,7 @@ name = "qiskit_qasm2"
 doctest = false
 
 [dependencies]
+num-bigint.workspace = true
 hashbrown.workspace = true
 pyo3.workspace = true
 qiskit-circuit.workspace = true

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm2/src/bytecode.rs

@@ -10,6 +10,7 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use num_bigint::BigUint;
 use pyo3::prelude::*;
 
 use crate::error::QASM2ParseError;
@@ -160,7 +161,7 @@ pub enum InternalBytecode {
         arguments: Vec<f64>,
         qubits: Vec<QubitId>,
         creg: CregId,
-        value: usize,
+        value: BigUint,
     },
     Measure {
         qubit: QubitId,
@@ -170,7 +171,7 @@ pub enum InternalBytecode {
         qubit: QubitId,
         clbit: ClbitId,
         creg: CregId,
-        value: usize,
+        value: BigUint,
     },
     Reset {
         qubit: QubitId,
@@ -178,7 +179,7 @@ pub enum InternalBytecode {
     ConditionedReset {
         qubit: QubitId,
         creg: CregId,
-        value: usize,
+        value: BigUint,
     },
     Barrier {
         qubits: Vec<QubitId>,

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm2/src/lex.rs

@@ -24,6 +24,7 @@
 //! real-number tokenisation.
 
 use hashbrown::HashMap;
+use num_bigint::BigUint;
 use pyo3::prelude::PyResult;
 
 use std::path::Path;
@@ -279,6 +280,15 @@ impl Token {
         context.text[self.index].parse().unwrap()
     }
 
+    /// If the token is an integer (by type, not just by value), this method can be called to
+    /// evaluate its value as a big integer.  Panics if the token is not an integer type.
+    pub fn bigint(&self, context: &TokenContext) -> BigUint {
+        if self.ttype != TokenType::Integer {
+            panic!()
+        }
+        context.text[self.index].parse().unwrap()
+    }
+
     /// If the token is a filename path, this method can be called to get a (regular) string
     /// representing it.  Panics if the token type was not a filename.
     pub fn filename(&self, context: &TokenContext) -> String {

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm2/src/lib.rs

@@ -123,7 +123,6 @@ fn bytecode_from_file(
 /// An interface to the Rust components of the parser stack, and the types it uses to represent the
 /// output.  The principal entry points for Python are :func:`bytecode_from_string` and
 /// :func:`bytecode_from_file`, which produce iterables of :class:`Bytecode` objects.
-#[pymodule]
 pub fn qasm2(module: &Bound<PyModule>) -> PyResult<()> {
     module.add_class::<bytecode::OpCode>()?;
     module.add_class::<bytecode::UnaryOpCode>()?;

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm2/src/parse.rs

@@ -16,6 +16,7 @@
 //! operator-precedence parser.
 
 use hashbrown::{HashMap, HashSet};
+use num_bigint::BigUint;
 use pyo3::prelude::{PyObject, PyResult, Python};
 
 use crate::bytecode::InternalBytecode;
@@ -188,9 +189,10 @@ enum GateParameters {
 
 /// An equality condition from an `if` statement.  These can condition gate applications, measures
 /// and resets, although in practice they're basically only ever used on gates.
+#[derive(Clone)]
 struct Condition {
     creg: CregId,
-    value: usize,
+    value: BigUint,
 }
 
 /// Find the first match for the partial [filename] in the directories along [path].  Returns
@@ -1105,7 +1107,7 @@ impl State {
         } {
             return match parameters {
                 GateParameters::Constant(parameters) => {
-                    self.emit_single_global_gate(bc, gate_id, parameters, qubits, &condition)
+                    self.emit_single_global_gate(bc, gate_id, parameters, qubits, condition)
                 }
                 GateParameters::Expression(parameters) => {
                     self.emit_single_gate_gate(bc, gate_id, parameters, qubits)
@@ -1174,7 +1176,7 @@ impl State {
             }
             return match parameters {
                 GateParameters::Constant(parameters) => {
-                    self.emit_single_global_gate(bc, gate_id, parameters, qubits, &condition)
+                    self.emit_single_global_gate(bc, gate_id, parameters, qubits, condition)
                 }
                 GateParameters::Expression(parameters) => {
                     self.emit_single_gate_gate(bc, gate_id, parameters, qubits)
@@ -1196,7 +1198,7 @@ impl State {
                         gate_id,
                         parameters.clone(),
                         qubits,
-                        &condition,
+                        condition.clone(),
                     )?;
                 }
                 // Gates used in gate-body definitions can't ever broadcast, because their only
@@ -1215,7 +1217,7 @@ impl State {
         gate_id: GateId,
         arguments: Vec<f64>,
         qubits: Vec<QubitId>,
-        condition: &Option<Condition>,
+        condition: Option<Condition>,
     ) -> PyResult<usize> {
         if let Some(condition) = condition {
             bc.push(Some(InternalBytecode::ConditionedGate {
@@ -1262,7 +1264,7 @@ impl State {
         self.expect(TokenType::Equals, "'=='", &if_token)?;
         let value = self
             .expect(TokenType::Integer, "an integer", &if_token)?
-            .int(&self.context);
+            .bigint(&self.context);
         self.expect(TokenType::RParen, "')'", &lparen_token)?;
         let name = name_token.id(&self.context);
         let creg = match self.symbols.get(&name) {
@@ -1408,7 +1410,7 @@ impl State {
                             qubit: q_start + i,
                             clbit: c_start + i,
                             creg,
-                            value,
+                            value: value.clone(),
                         })
                     }));
                     Ok(q_size)
@@ -1477,7 +1479,7 @@ impl State {
                         Some(InternalBytecode::ConditionedReset {
                             qubit: start + offset,
                             creg,
-                            value,
+                            value: value.clone(),
                         })
                     }));
                     Ok(size)

{qiskit-1.1.1 → qiskit-1.1.2}/crates/qasm3/src/lib.rs

@@ -153,7 +153,6 @@ pub fn load(
 
 /// Internal module supplying the OpenQASM 3 import capabilities.  The entries in it should largely
 /// be re-exposed directly to public Python space.
-#[pymodule]
 pub fn qasm3(module: &Bound<PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(loads, module)?)?;
     module.add_function(wrap_pyfunction!(load, module)?)?;

qiskit-1.1.2/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.1.2

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/circuit/classicalfunction/__init__.py

@@ -51,6 +51,14 @@ QuantumCircuit:
 Following Qiskit's little-endian bit ordering convention, the left-most bit (``a``) is the most
 significant bit and the right-most bit (``d``) is the least significant bit.
 
+.. warning::
+
+    The functionality of `qiskit.circuit.classicalfunction` requires `tweedledum`, 
+    which isn't available on all platforms (up to Python version 3.11).
+    See `tweedledum installation guide 
+    <https://github.com/boschmitt/tweedledum/tree/master?tab=readme-ov-file#installation>`_ 
+    for more details.
+
 Supplementary Information
 =========================
 

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/circuit/library/standard_gates/x.py

@@ -21,6 +21,7 @@ from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import _ctrl_state_to_int, with_gate_array, with_controlled_gate_array
 
 _X_ARRAY = [[0, 1], [1, 0]]
+_SX_ARRAY = [[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]
 
 
 @with_gate_array(_X_ARRAY)
@@ -562,6 +563,7 @@ class RCCXGate(SingletonGate):
         return isinstance(other, RCCXGate)
 
 
+@with_controlled_gate_array(_SX_ARRAY, num_ctrl_qubits=3, cached_states=(7,))
 class C3SXGate(SingletonControlledGate):
     """The 3-qubit controlled sqrt-X gate.
 

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/circuit/quantumcircuit.py

@@ -3640,6 +3640,8 @@ class QuantumCircuit:
                 [(ParameterTable.GLOBAL_PHASE, None)]
             )
         cpy._data = CircuitData(self._data.qubits, self._data.clbits)
+        # Invalidate parameters caching.
+        cpy._parameters = None
 
         cpy._calibrations = _copy.deepcopy(self._calibrations)
         cpy._metadata = _copy.deepcopy(self._metadata)

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/dagcircuit/dagcircuit.py

@@ -1343,6 +1343,13 @@ class DAGCircuit:
         block_cargs.sort(key=wire_pos_map.get)
         new_node = DAGOpNode(op, block_qargs, block_cargs, dag=self)
 
+        # check the op to insert matches the number of qubits we put it on
+        if op.num_qubits != len(block_qargs):
+            raise DAGCircuitError(
+                f"Number of qubits in the replacement operation ({op.num_qubits}) is not equal to "
+                f"the number of qubits in the block ({len(block_qargs)})!"
+            )
+
         try:
             new_node._node_id = self._multi_graph.contract_nodes(
                 block_ids, new_node, check_cycle=cycle_check

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/primitives/containers/bit_array.py

@@ -231,7 +231,7 @@ class BitArray(ShapedMixin):
         Args:
             counts: One or more counts-like mappings with the same number of shots.
             num_bits: The desired number of bits per shot. If unset, the biggest value found sets
-                this value.
+                this value, with a minimum of one bit.
 
         Returns:
             A new bit array with shape ``()`` for single input counts, or ``(N,)`` for an iterable
@@ -275,7 +275,7 @@ class BitArray(ShapedMixin):
         Args:
             samples: A list of bitstrings, a list of integers, or a list of hexstrings.
             num_bits: The desired number of bits per sample. If unset, the biggest sample provided
-                is used to determine this value.
+                is used to determine this value, with a minimum of one bit.
 
         Returns:
             A new bit array.
@@ -298,6 +298,9 @@ class BitArray(ShapedMixin):
             # we are forced to prematurely look at every iterand in this case
             ints = list(ints)
             num_bits = max(map(int.bit_length, ints))
+            # convention: if the only value is 0, represent with one bit:
+            if num_bits == 0:
+                num_bits = 1
 
         num_bytes = _min_num_bytes(num_bits)
         data = b"".join(val.to_bytes(num_bytes, "big") for val in ints)

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/providers/fake_provider/generic_backend_v2.py

@@ -375,6 +375,11 @@ class GenericBackendV2(BackendV2):
                     f"in the standard qiskit circuit library."
                 )
             gate = self._supported_gates[name]
+            if self.num_qubits < gate.num_qubits:
+                raise QiskitError(
+                    f"Provided basis gate {name} needs more qubits than {self.num_qubits}, "
+                    f"which is the size of the backend."
+                )
             noise_params = self._get_noise_defaults(name, gate.num_qubits)
             self._add_noisy_instruction_to_target(gate, noise_params, calibration_inst_map)
 

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/pulse/schedule.py

@@ -252,7 +252,7 @@ class Schedule:
 
         Notes:
             Nested schedules are returned as-is. If you want to collect only instructions,
-            use py:meth:`~Schedule.instructions` instead.
+            use :py:meth:`~Schedule.instructions` instead.
 
         Returns:
             A tuple, where each element is a two-tuple containing the initial
@@ -490,7 +490,7 @@ class Schedule:
     ) -> "Schedule":
         """Return a ``Schedule`` with only the instructions from this Schedule *failing*
         at least one of the provided filters.
-        This method is the complement of py:meth:`~self.filter`, so that::
+        This method is the complement of :py:meth:`~Schedule.filter`, so that::
 
             self.filter(args) | self.exclude(args) == self
 
@@ -1309,7 +1309,7 @@ class ScheduleBlock:
     ):
         """Return a new ``ScheduleBlock`` with only the instructions from this ``ScheduleBlock``
         *failing* at least one of the provided filters.
-        This method is the complement of py:meth:`~self.filter`, so that::
+        This method is the complement of :py:meth:`~ScheduleBlock.filter`, so that::
 
             self.filter(args) + self.exclude(args) == self in terms of instructions included.
 

{qiskit-1.1.1 → qiskit-1.1.2}/qiskit/quantum_info/operators/symplectic/pauli.py

@@ -77,7 +77,7 @@ class Pauli(BasePauli):
 
     An :math:`n`-qubit Pauli may be represented by a string consisting of
     :math:`n` characters from ``['I', 'X', 'Y', 'Z']``, and optionally phase
-    coefficient in :math:`['', '-i', '-', 'i']`. For example: ``XYZ`` or
+    coefficient in ``['', '-i', '-', 'i']``. For example: ``'XYZ'`` or
     ``'-iZIZ'``.
 
     In the string representation qubit-0 corresponds to the right-most
@@ -160,21 +160,23 @@ class Pauli(BasePauli):
     _CANONICAL_PHASE_LABEL = {"": 0, "-i": 1, "-": 2, "i": 3}
 
     def __init__(self, data: str | tuple | Pauli | ScalarOp | QuantumCircuit | None = None):
-        """Initialize the Pauli.
+        r"""Initialize the Pauli.
 
         When using the symplectic array input data both z and x arguments must
         be provided, however the first (z) argument can be used alone for string
-        label, Pauli operator, or ScalarOp input data.
+        label, Pauli operator, or :class:`.ScalarOp` input data.
 
         Args:
             data (str or tuple or Pauli or ScalarOp): input data for Pauli. If input is
-                a tuple it must be of the form ``(z, x)`` or (z, x, phase)`` where
-                ``z`` and ``x`` are boolean Numpy arrays, and phase is an integer from Z_4.
+                a tuple it must be of the form ``(z, x)`` or ``(z, x, phase)`` where
+                ``z`` and ``x`` are boolean Numpy arrays, and phase is an integer from
+                :math:`\mathbb{Z}_4`.
                 If input is a string, it must be a concatenation of a phase and a Pauli string
-                (e.g. 'XYZ', '-iZIZ') where a phase string is a combination of at most three
-                characters from ['+', '-', ''], ['1', ''], and ['i', 'j', ''] in this order,
-                e.g. '', '-1j' while a Pauli string is 1 or more characters of 'I', 'X', 'Y' or 'Z',
-                e.g. 'Z', 'XIYY'.
+                (e.g. ``'XYZ', '-iZIZ'``) where a phase string is a combination of at most three
+                characters from ``['+', '-', '']``, ``['1', '']``, and ``['i', 'j', '']`` in this order,
+                e.g. ``''``, ``'-1j'`` while a Pauli string is 1 or more
+                characters of ``'I'``, ``'X'``, ``'Y'``, or ``'Z'``,
+                e.g. ``'Z'``, ``'XIYY'``.
 
         Raises:
             QiskitError: if input array is invalid shape.