qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0rc1__cp38-abi3-win32.whl

qiskit/pulse/library/waveform.py

@@ -130,8 +130,5 @@ class Waveform(Pulse):
         opt = np.get_printoptions()
         np.set_printoptions(threshold=50)
         np.set_printoptions(**opt)
-        return "{}({}{})".format(
-            self.__class__.__name__,
-            repr(self.samples),
-            f", name='{self.name}'" if self.name is not None else "",
-        )
+        name_repr = f", name='{self.name}'" if self.name is not None else ""
+        return f"{self.__class__.__name__}({repr(self.samples)}{name_repr})"

qiskit/pulse/macros.py

@@ -124,16 +124,21 @@ def _measure_v1(
     for qubit in qubits:
         measure_groups.add(tuple(meas_map[qubit]))
     for measure_group_qubits in measure_groups:
-        if qubit_mem_slots is not None:
-            unused_mem_slots = set(measure_group_qubits) - set(qubit_mem_slots.values())
+
+        unused_mem_slots = (
+            set()
+            if qubit_mem_slots is None
+            else set(measure_group_qubits) - set(qubit_mem_slots.values())
+        )
+
         try:
             default_sched = inst_map.get(measure_name, measure_group_qubits)
         except exceptions.PulseError as ex:
             raise exceptions.PulseError(
-                "We could not find a default measurement schedule called '{}'. "
+                f"We could not find a default measurement schedule called '{measure_name}'. "
                 "Please provide another name using the 'measure_name' keyword "
                 "argument. For assistance, the instructions which are defined are: "
-                "{}".format(measure_name, inst_map.instructions)
+                f"{inst_map.instructions}"
             ) from ex
         for time, inst in default_sched.instructions:
             if inst.channel.index not in qubits:
@@ -198,10 +203,10 @@ def _measure_v2(
                 schedule += _schedule_remapping_memory_slot(default_sched, qubit_mem_slots)
         except KeyError as ex:
             raise exceptions.PulseError(
-                "We could not find a default measurement schedule called '{}'. "
+                f"We could not find a default measurement schedule called '{measure_name}'. "
                 "Please provide another name using the 'measure_name' keyword "
                 "argument. For assistance, the instructions which are defined are: "
-                "{}".format(measure_name, target.instructions)
+                f"{target.instructions}"
             ) from ex
     return schedule
 

qiskit/pulse/parser.py

@@ -120,17 +120,15 @@ class PulseExpression(ast.NodeTransformer):
         if kwargs:
             for key, val in kwargs.items():
                 if key in self.params:
-                    if key not in self._locals_dict.keys():
+                    if key not in self._locals_dict:
                         self._locals_dict[key] = val
                     else:
                         raise PulseError(
-                            "%s got multiple values for argument '%s'"
-                            % (self.__class__.__name__, key)
+                            f"{self.__class__.__name__} got multiple values for argument '{key}'"
                         )
                 else:
                     raise PulseError(
-                        "%s got an unexpected keyword argument '%s'"
-                        % (self.__class__.__name__, key)
+                        f"{self.__class__.__name__} got an unexpected keyword argument '{key}'"
                     )
 
         expr = self.visit(self._tree)
@@ -139,7 +137,7 @@ class PulseExpression(ast.NodeTransformer):
             if self._partial_binding:
                 return PulseExpression(expr, self._partial_binding)
             else:
-                raise PulseError("Parameters %s are not all bound." % self.params)
+                raise PulseError(f"Parameters {self.params} are not all bound.")
         return expr.body.value
 
     @staticmethod
@@ -160,7 +158,7 @@ class PulseExpression(ast.NodeTransformer):
         for op_type, op_func in opr_dict.items():
             if isinstance(opr, op_type):
                 return op_func(*args)
-        raise PulseError("Operator %s is not supported." % opr.__class__.__name__)
+        raise PulseError(f"Operator {opr.__class__.__name__} is not supported.")
 
     def visit_Expression(self, node: ast.Expression) -> ast.Expression:
         """Evaluate children nodes of expression.
@@ -272,8 +270,8 @@ class PulseExpression(ast.NodeTransformer):
         node = copy.copy(node)
         node.args = [self.visit(arg) for arg in node.args]
         if all(isinstance(arg, ast.Constant) for arg in node.args):
-            if node.func.id not in self._math_ops.keys():
-                raise PulseError("Function %s is not supported." % node.func.id)
+            if node.func.id not in self._math_ops:
+                raise PulseError(f"Function {node.func.id} is not supported.")
             _args = [arg.value for arg in node.args]
             _val = self._math_ops[node.func.id](*_args)
             if not _val.imag:
@@ -283,7 +281,7 @@ class PulseExpression(ast.NodeTransformer):
         return node
 
     def generic_visit(self, node):
-        raise PulseError("Unsupported node: %s" % node.__class__.__name__)
+        raise PulseError(f"Unsupported node: {node.__class__.__name__}")
 
 
 def parse_string_expr(source: str, partial_binding: bool = False) -> PulseExpression:

qiskit/pulse/schedule.py

@@ -553,17 +553,10 @@ class Schedule:
                     self._timeslots[channel].insert(index, interval)
                 except PulseError as ex:
                     raise PulseError(
-                        "Schedule(name='{new}') cannot be inserted into Schedule(name='{old}') at "
-                        "time {time} because its instruction on channel {ch} scheduled from time "
-                        "{t0} to {tf} overlaps with an existing instruction."
-                        "".format(
-                            new=schedule.name or "",
-                            old=self.name or "",
-                            time=time,
-                            ch=channel,
-                            t0=interval[0],
-                            tf=interval[1],
-                        )
+                        f"Schedule(name='{schedule.name or ''}') cannot be inserted into "
+                        f"Schedule(name='{self.name or ''}') at "
+                        f"time {time} because its instruction on channel {channel} scheduled from time "
+                        f"{interval[0]} to {interval[1]} overlaps with an existing instruction."
                     ) from ex
 
         _check_nonnegative_timeslot(self._timeslots)
@@ -598,10 +591,8 @@ class Schedule:
                         continue
 
                 raise PulseError(
-                    "Cannot find interval ({t0}, {tf}) to remove from "
-                    "channel {ch} in Schedule(name='{name}').".format(
-                        ch=channel, t0=interval[0], tf=interval[1], name=schedule.name
-                    )
+                    f"Cannot find interval ({interval[0]}, {interval[1]}) to remove from "
+                    f"channel {channel} in Schedule(name='{schedule.name}')."
                 )
 
             if not channel_timeslots:
@@ -1615,8 +1606,9 @@ class ScheduleBlock:
         blocks = ", ".join([repr(instr) for instr in self.blocks[:50]])
         if len(self.blocks) > 25:
             blocks += ", ..."
-        return '{}({}, name="{}", transform={})'.format(
-            self.__class__.__name__, blocks, name, repr(self.alignment_context)
+        return (
+            f'{self.__class__.__name__}({blocks}, name="{name}",'
+            f" transform={repr(self.alignment_context)})"
         )
 
     def __add__(self, other: "BlockComponent") -> "ScheduleBlock":

qiskit/pulse/transforms/alignments.py

@@ -398,9 +398,7 @@ class AlignFunc(AlignmentKind):
             _t_center = self.duration * self.func(ind + 1)
             _t0 = int(_t_center - 0.5 * child.duration)
             if _t0 < 0 or _t0 > self.duration:
-                raise PulseError(
-                    "Invalid schedule position t=%d is specified at index=%d" % (_t0, ind)
-                )
+                raise PulseError(f"Invalid schedule position t={_t0} is specified at index={ind}")
             aligned.insert(_t0, child, inplace=True)
 
         return aligned

qiskit/pulse/utils.py

@@ -108,10 +108,9 @@ def instruction_duration_validation(duration: int):
     """
     if isinstance(duration, ParameterExpression):
         raise UnassignedDurationError(
-            "Instruction duration {} is not assigned. "
+            f"Instruction duration {repr(duration)} is not assigned. "
             "Please bind all durations to an integer value before playing in the Schedule, "
             "or use ScheduleBlock to align instructions with unassigned duration."
-            "".format(repr(duration))
         )
 
     if not isinstance(duration, (int, np.integer)) or duration < 0:

qiskit/qasm/libs/stdgates.inc

@@ -1,51 +1,58 @@
-// OpenQASM 3 standard gate library
+// OpenQASM 3.0 standard gate library
+//
+// Vendored from the OpenQASM 3.0 project at commit 4ca1d793833b24a1 of
+// https://github.com/openqasm/openqasm.
+//
+// Used under the terms of its Apache-2.0 license.
+// Copyright 2017-2024 OpenQASM Contributors.
+
 
 // phase gate
-gate p(lambda) a { ctrl @ gphase(lambda) a; }
+gate p(λ) a { ctrl @ gphase(λ) a; }
 
 // Pauli gate: bit-flip or NOT gate
-gate x a { U(pi, 0, pi) a; }
+gate x a { U(π, 0, π) a; gphase(-π/2);}
 // Pauli gate: bit and phase flip
-gate y a { U(pi, pi/2, pi/2) a; }
-// Pauli gate: phase flip
-gate z a { p(pi) a; }
+gate y a { U(π, π/2, π/2) a; gphase(-π/2);}
+ // Pauli gate: phase flip
+gate z a { p(π) a; }
 
 // Clifford gate: Hadamard
-gate h a { U(pi/2, 0, pi) a; }
+gate h a { U(π/2, 0, π) a; gphase(-π/4);}
 // Clifford gate: sqrt(Z) or S gate
-gate s a { pow(1/2) @ z a; }
+gate s a { pow(0.5) @ z a; }
 // Clifford gate: inverse of sqrt(Z)
-gate sdg a { inv @ pow(1/2) @ z a; }
+gate sdg a { inv @ pow(0.5) @ z a; }
 
 // sqrt(S) or T gate
-gate t a { pow(1/2) @ s a; }
+gate t a { pow(0.5) @ s a; }
 // inverse of sqrt(S)
-gate tdg a { inv @ pow(1/2) @ s a; }
+gate tdg a { inv @ pow(0.5) @ s a; }
 
 // sqrt(NOT) gate
-gate sx a { pow(1/2) @ x a; }
+gate sx a { pow(0.5) @ x a; }
 
 // Rotation around X-axis
-gate rx(theta) a { U(theta, -pi/2, pi/2) a; }
+gate rx(θ) a { U(θ, -π/2, π/2) a; gphase(-θ/2);}
 // rotation around Y-axis
-gate ry(theta) a { U(theta, 0, 0) a; }
+gate ry(θ) a { U(θ, 0, 0) a; gphase(-θ/2);}
 // rotation around Z axis
-gate rz(lambda) a { gphase(-lambda/2); U(0, 0, lambda) a; }
+gate rz(λ) a { gphase(-λ/2); U(0, 0, λ) a; }
 
 // controlled-NOT
-gate cx c, t { ctrl @ x c, t; }
+gate cx a, b { ctrl @ x a, b; }
 // controlled-Y
 gate cy a, b { ctrl @ y a, b; }
 // controlled-Z
 gate cz a, b { ctrl @ z a, b; }
 // controlled-phase
-gate cp(lambda) a, b { ctrl @ p(lambda) a, b; }
+gate cp(λ) a, b { ctrl @ p(λ) a, b; }
 // controlled-rx
-gate crx(theta) a, b { ctrl @ rx(theta) a, b; }
+gate crx(θ) a, b { ctrl @ rx(θ) a, b; }
 // controlled-ry
-gate cry(theta) a, b { ctrl @ ry(theta) a, b; }
+gate cry(θ) a, b { ctrl @ ry(θ) a, b; }
 // controlled-rz
-gate crz(theta) a, b { ctrl @ rz(theta) a, b; }
+gate crz(θ) a, b { ctrl @ rz(θ) a, b; }
 // controlled-H
 gate ch a, b { ctrl @ h a, b; }
 
@@ -57,19 +64,19 @@ gate ccx a, b, c { ctrl @ ctrl @ x a, b, c; }
 // controlled-swap
 gate cswap a, b, c { ctrl @ swap a, b, c; }
 
-// four parameter controlled-U gate with relative phase
-gate cu(theta, phi, lambda, gamma) c, t { p(gamma) c; ctrl @ U(theta, phi, lambda) c, t; }
+// four parameter controlled-U gate with relative phase γ
+gate cu(θ, φ, λ, γ) a, b { p(γ-θ/2) a; ctrl @ U(θ, φ, λ) a, b; }
 
 // Gates for OpenQASM 2 backwards compatibility
 // CNOT
-gate CX c, t { ctrl @ U(pi, 0, pi) c, t; }
+gate CX a, b { ctrl @ U(π, 0, π) a, b; }
 // phase gate
-gate phase(lambda) q { U(0, 0, lambda) q; }
+gate phase(λ) q { U(0, 0, λ) q; }
 // controlled-phase
-gate cphase(lambda) a, b { ctrl @ phase(lambda) a, b; }
+gate cphase(λ) a, b { ctrl @ phase(λ) a, b; }
 // identity or idle gate
 gate id a { U(0, 0, 0) a; }
 // IBM Quantum experience gates
-gate u1(lambda) q { U(0, 0, lambda) q; }
-gate u2(phi, lambda) q { gphase(-(phi+lambda)/2); U(pi/2, phi, lambda) q; }
-gate u3(theta, phi, lambda) q { gphase(-(phi+lambda)/2); U(theta, phi, lambda) q; }
+gate u1(λ) q { U(0, 0, λ) q; }
+gate u2(φ, λ) q { gphase(-(φ+λ+π/2)/2); U(π/2, φ, λ) q; }
+gate u3(θ, φ, λ) q { gphase(-(φ+λ+θ)/2); U(θ, φ, λ) q; }

qiskit/qasm2/__init__.py

@@ -20,7 +20,7 @@ formats <qasm2-parse>` and :ref:`exporting back to OpenQASM 2 <qasm2-export>`.
 
 .. note::
 
-    OpenQASM 2 is a simple language, and not suitable for general serialisation of Qiskit objects.
+    OpenQASM 2 is a simple language, and not suitable for general serialization of Qiskit objects.
     See :ref:`some discussion of alternatives below <qasm2-alternatives>`, if that is what you are
     looking for.
 
@@ -95,7 +95,7 @@ letter-of-the-spec mode with ``strict=True``.
 Exporting API
 =============
 
-Similar to other serialisation modules in Python, this module offers two public functions:
+Similar to other serialization modules in Python, this module offers two public functions:
 :func:`dump` and :func:`dumps`, which take a :class:`.QuantumCircuit` and write out a representative
 OpenQASM 2 program to a file-like object or return a string, respectively.
 
@@ -394,7 +394,7 @@ Legacy Compatibility
 
 :meth:`.QuantumCircuit.from_qasm_str` and :meth:`~.QuantumCircuit.from_qasm_file` used to make a few
 additions on top of the raw specification. Qiskit originally tried to use OpenQASM 2 as a sort of
-serialisation format, and expanded its behaviour as Qiskit expanded.  The new parser under all its
+serialization format, and expanded its behavior as Qiskit expanded.  The new parser under all its
 defaults implements the specification more strictly.
 
 In particular, in the legacy importers:
@@ -445,11 +445,11 @@ In particular, in the legacy importers:
 * the parsed grammar is effectively the same as :ref:`the strict mode of the new importers
   <qasm2-strict-mode>`.
 
-You can emulate this behaviour in :func:`load` and :func:`loads` by setting `include_path`
+You can emulate this behavior in :func:`load` and :func:`loads` by setting `include_path`
 appropriately (try inspecting the variable ``qiskit.__file__`` to find the installed location), and
 by passing a list of :class:`CustomInstruction` instances for each of the custom gates you care
 about.  To make things easier we make three tuples available, which each contain one component of
-a configuration that is equivalent to Qiskit's legacy converter behaviour.
+a configuration that is equivalent to Qiskit's legacy converter behavior.
 
 .. py:data:: LEGACY_CUSTOM_INSTRUCTIONS
 
@@ -473,7 +473,7 @@ On *all* the gates defined in Qiskit's legacy version of ``qelib1.inc`` and the
 instruction, it does not matter how the gates are actually defined and used, the legacy importer
 will always attempt to output its custom objects for them.  This can result in errors during the
 circuit construction, even after a successful parse.  There is no way to emulate this buggy
-behaviour with :mod:`qiskit.qasm2`; only an ``include "qelib1.inc";`` statement or the
+behavior with :mod:`qiskit.qasm2`; only an ``include "qelib1.inc";`` statement or the
 `custom_instructions` argument can cause built-in Qiskit instructions to be used, and the signatures
 of these match each other.
 
@@ -549,7 +549,7 @@ LEGACY_INCLUDE_PATH = (
 
 
 def _normalize_path(path: Union[str, os.PathLike]) -> str:
-    """Normalise a given path into a path-like object that can be passed to Rust.
+    """Normalize a given path into a path-like object that can be passed to Rust.
 
     Ideally this would be something that we can convert to Rust's `OSString`, but in practice,
     Python uses `os.fsencode` to produce a `bytes` object, but this doesn't map especially well.

qiskit/qasm2/export.py

@@ -157,7 +157,7 @@ def dumps(circuit: QuantumCircuit, /) -> str:
                 _make_unique(_escape_name(reg.name, "reg_"), register_escaped_names)
             ] = reg
     bit_labels: dict[Qubit | Clbit, str] = {
-        bit: "%s[%d]" % (name, idx)
+        bit: f"{name}[{idx}]"
         for name, register in register_escaped_names.items()
         for (idx, bit) in enumerate(register)
     }
@@ -244,18 +244,14 @@ def _instruction_call_site(operation):
     else:
         qasm2_call = operation.name
     if operation.params:
-        qasm2_call = "{}({})".format(
-            qasm2_call,
-            ",".join([pi_check(i, output="qasm", eps=1e-12) for i in operation.params]),
-        )
+        params = ",".join([pi_check(i, output="qasm", eps=1e-12) for i in operation.params])
+        qasm2_call = f"{qasm2_call}({params})"
     if operation.condition is not None:
         if not isinstance(operation.condition[0], ClassicalRegister):
             raise QASM2ExportError(
                 "OpenQASM 2 can only condition on registers, but got '{operation.condition[0]}'"
             )
-        qasm2_call = (
-            "if(%s==%d) " % (operation.condition[0].name, operation.condition[1]) + qasm2_call
-        )
+        qasm2_call = f"if({operation.condition[0].name}=={operation.condition[1]:d}) " + qasm2_call
     return qasm2_call
 
 
@@ -312,7 +308,7 @@ def _define_custom_operation(operation, gates_to_define):
         lib.U3Gate,
     }
 
-    # In known-good situations we want to use a manually parametrised object as the source of the
+    # In known-good situations we want to use a manually parametrized object as the source of the
     # definition, but still continue to return the given object as the call-site object.
     if operation.base_class in known_good_parameterized:
         parameterized_operation = type(operation)(*_FIXED_PARAMETERS[: len(operation.params)])

qiskit/qasm2/parse.py

@@ -287,7 +287,7 @@ def from_bytecode(bytecode, custom_instructions: Iterable[CustomInstruction]):
 
 class _DefinedGate(Gate):
     """A gate object defined by a `gate` statement in an OpenQASM 2 program.  This object lazily
-    binds its parameters to its definition, so it is only synthesised when required."""
+    binds its parameters to its definition, so it is only synthesized when required."""
 
     def __init__(self, name, num_qubits, params, gates, bytecode):
         self._gates = gates

qiskit/qasm3/ast.py

@@ -317,7 +317,7 @@ class Designator(ASTNode):
 
 
 class ClassicalDeclaration(Statement):
-    """Declaration of a classical type, optionally initialising it to a value."""
+    """Declaration of a classical type, optionally initializing it to a value."""
 
     def __init__(self, type_: ClassicalType, identifier: Identifier, initializer=None):
         self.type = type_
@@ -456,39 +456,23 @@ class SubroutineBlock(ProgramBlock):
     pass
 
 
-class QuantumArgument(QuantumDeclaration):
-    """
-    quantumArgument
-        : 'qreg' Identifier designator? | 'qubit' designator? Identifier
-    """
-
-
-class QuantumGateSignature(ASTNode):
+class QuantumGateDefinition(Statement):
     """
-    quantumGateSignature
-        : quantumGateName ( LPAREN identifierList? RPAREN )? identifierList
+    quantumGateDefinition
+        : 'gate' quantumGateSignature quantumBlock
     """
 
     def __init__(
         self,
         name: Identifier,
-        qargList: List[Identifier],
-        params: Optional[List[Expression]] = None,
+        params: Tuple[Identifier, ...],
+        qubits: Tuple[Identifier, ...],
+        body: QuantumBlock,
     ):
         self.name = name
-        self.qargList = qargList
         self.params = params
-
-
-class QuantumGateDefinition(Statement):
-    """
-    quantumGateDefinition
-        : 'gate' quantumGateSignature quantumBlock
-    """
-
-    def __init__(self, quantumGateSignature: QuantumGateSignature, quantumBlock: QuantumBlock):
-        self.quantumGateSignature = quantumGateSignature
-        self.quantumBlock = quantumBlock
+        self.qubits = qubits
+        self.body = body
 
 
 class SubroutineDefinition(Statement):