qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/qasm2/__init__.py

@@ -133,7 +133,10 @@ Exporting examples
 
 Export a simple :class:`.QuantumCircuit` to an OpenQASM 2 string:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context: reset
 
     import qiskit.qasm2
     from qiskit.circuit import QuantumCircuit
@@ -183,7 +186,9 @@ Parsing examples
 
 Use :func:`loads` to import an OpenQASM 2 program in a string into a :class:`.QuantumCircuit`:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
 
     import qiskit.qasm2
     program = """
@@ -259,7 +264,9 @@ Sometimes you may want to influence the :class:`.Gate` objects that the importer
 named instructions.  Gates that are defined by the statement ``include "qelib1.inc";`` will
 automatically be associated with a suitable Qiskit circuit-library gate, but you can extend this:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.circuit import Gate
     from qiskit.qasm2 import loads, CustomInstruction
@@ -292,7 +299,9 @@ defined gates (which are computed on demand).  Here we provide a Python version
 which mathematically is :math:`\arctan(y/x)` but correctly handling angle quadrants and infinities,
 and a custom ``add_one`` function:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
 
     import math
     from qiskit.qasm2 import loads, CustomClassical
@@ -356,7 +365,10 @@ the header file, you can use :class:`CustomInstruction` to override how Qiskit b
 For the standard ``qelib1.inc`` include there is only one point of difference, and so the override
 needed to switch its phase convention is:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context: reset
 
     from qiskit import qasm2
     from qiskit.circuit.library import PhaseGate
@@ -376,7 +388,10 @@ needed to switch its phase convention is:
 This will use Qiskit's :class:`.PhaseGate` class to represent the ``rz`` instruction, which is
 equal (including the phase) to :class:`.U1Gate`:
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     Operator(qasm2.loads(program, custom_instructions=custom))
 

qiskit/qasm2/export.py

@@ -116,10 +116,10 @@ def dump(circuit: QuantumCircuit, filename_or_stream: os.PathLike | io.TextIOBas
         QASM2ExportError: if the circuit cannot be represented by OpenQASM 2.
     """
     if isinstance(filename_or_stream, io.TextIOBase):
-        print(dumps(circuit), file=filename_or_stream)
+        print(dumps(circuit), file=filename_or_stream)  # pylint: disable=bad-builtin
         return
     with open(filename_or_stream, "w") as stream:
-        print(dumps(circuit), file=stream)
+        print(dumps(circuit), file=stream)  # pylint: disable=bad-builtin
 
 
 def dumps(circuit: QuantumCircuit, /) -> str:
@@ -246,14 +246,6 @@ def _instruction_call_site(operation):
     if 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 = (
-            f"if({operation._condition[0].name}=={operation._condition[1]:d}) " + qasm2_call
-        )
     return qasm2_call
 
 

qiskit/qasm2/parse.py

@@ -11,7 +11,6 @@
 # that they have been altered from the originals.
 
 """Python-space bytecode interpreter for the output of the main Rust parser logic."""
-import warnings
 import dataclasses
 import math
 from typing import Iterable, Callable
@@ -255,37 +254,25 @@ def from_bytecode(bytecode, custom_instructions: Iterable[CustomInstruction]):
                 CircuitInstruction(gates[gate_id](*parameters), [qubits[q] for q in op_qubits])
             )
         elif opcode == OpCode.ConditionedGate:
-            warnings.warn(
-                "Conditioned gates in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0",
-                FutureWarning,
-                stacklevel=3,
-            )
             gate_id, parameters, op_qubits, creg, value = op.operands
-            gate = gates[gate_id](*parameters).c_if(qc.cregs[creg], value)
-            qc._append(CircuitInstruction(gate, [qubits[q] for q in op_qubits]))
+            with qc.if_test((qc.cregs[creg], value)):
+                gate = gates[gate_id](*parameters)
+                qc.append(gate, [qubits[q] for q in op_qubits])
         elif opcode == OpCode.Measure:
             qubit, clbit = op.operands
             qc._append(CircuitInstruction(Measure(), (qubits[qubit],), (clbits[clbit],)))
         elif opcode == OpCode.ConditionedMeasure:
-            warnings.warn(
-                "Conditioned measurements in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0",
-                FutureWarning,
-                stacklevel=3,
-            )
             qubit, clbit, creg, value = op.operands
-            measure = Measure().c_if(qc.cregs[creg], value)
-            qc._append(CircuitInstruction(measure, (qubits[qubit],), (clbits[clbit],)))
+            with qc.if_test((qc.cregs[creg], value)):
+                measure = Measure()
+                qc.append(measure, (qubits[qubit],), (clbits[clbit],))
         elif opcode == OpCode.Reset:
             qc._append(CircuitInstruction(Reset(), (qubits[op.operands[0]],)))
         elif opcode == OpCode.ConditionedReset:
-            warnings.warn(
-                "Conditioned resets in qasm2 will be loaded as an IfElseOp starting in Qiskit 2.0",
-                FutureWarning,
-                stacklevel=3,
-            )
             qubit, creg, value = op.operands
-            reset = Reset().c_if(qc.cregs[creg], value)
-            qc._append(CircuitInstruction(reset, (qubits[qubit],)))
+            with qc.if_test((qc.cregs[creg], value)):
+                reset = Reset()
+                qc.append(reset, (qubits[qubit],))
         elif opcode == OpCode.Barrier:
             op_qubits = op.operands[0]
             qc._append(CircuitInstruction(Barrier(len(op_qubits)), [qubits[q] for q in op_qubits]))
@@ -371,15 +358,14 @@ class _DefinedGate(Gate):
     # to pickle ourselves, we just eagerly create the definition and pickle that.
 
     def __getstate__(self):
-        return (self.name, self.num_qubits, self.params, self.definition, self._condition)
+        return (self.name, self.num_qubits, self.params, self.definition)
 
     def __setstate__(self, state):
-        name, num_qubits, params, definition, condition = state
+        name, num_qubits, params, definition = state
         super().__init__(name, num_qubits, params)
         self._gates = ()
         self._bytecode = ()
         self._definition = definition
-        self._condition = condition
 
 
 def _gate_builder(name, num_qubits, known_gates, bytecode):

qiskit/qasm3/__init__.py

@@ -59,7 +59,11 @@ are:
 If you want to enable multiple experimental features, you should combine the flags using the ``|``
 operator, such as ``flag1 | flag2``.
 
-For example, to perform an export using the early semantics of ``switch`` support::
+For example, to perform an export using the early semantics of ``switch`` support:
+
+.. plot::
+    :include-source:
+    :nofigs:
 
     from qiskit import qasm3, QuantumCircuit, QuantumRegister, ClassicalRegister
 

qiskit/qasm3/ast.py

@@ -14,6 +14,8 @@
 
 """QASM3 AST Nodes"""
 
+from __future__ import annotations
+
 import enum
 from typing import Optional, List, Union, Iterable, Tuple, Sequence
 
@@ -173,6 +175,12 @@ class BitType(ClassicalType):
     __slots__ = ()
 
 
+class DurationType(ClassicalType):
+    """Type information for a duration."""
+
+    __slots__ = ()
+
+
 class BitArrayType(ClassicalType):
     """Type information for a sized number of classical bits."""
 
@@ -242,6 +250,13 @@ class IntegerLiteral(Expression):
         self.value = value
 
 
+class FloatLiteral(Expression):
+    __slots__ = ("value",)
+
+    def __init__(self, value):
+        self.value = value
+
+
 class BooleanLiteral(Expression):
     __slots__ = ("value",)
 
@@ -304,6 +319,10 @@ class Binary(Expression):
         NOT_EQUAL = "!="
         SHIFT_LEFT = "<<"
         SHIFT_RIGHT = ">>"
+        ADD = "+"
+        SUB = "-"
+        MUL = "*"
+        DIV = "/"
 
     def __init__(self, op: Op, left: Expression, right: Expression):
         self.op = op
@@ -389,6 +408,17 @@ class ClassicalDeclaration(Statement):
         self.initializer = initializer
 
 
+class StretchDeclaration(Statement):
+    """Declaration of a stretch variable, optionally with a lower bound
+    expression."""
+
+    __slots__ = ("identifier", "bound")
+
+    def __init__(self, identifier: Identifier, bound=None):
+        self.identifier = identifier
+        self.bound = bound
+
+
 class AssignmentStatement(Statement):
     """Assignment of an expression to an l-value."""
 
@@ -668,6 +698,20 @@ class WhileLoopStatement(Statement):
         self.body = body
 
 
+class BoxStatement(Statement):
+    """Like ``box[duration] { statements* }``."""
+
+    __slots__ = ("duration", "body")
+
+    def __init__(
+        self,
+        body: ProgramBlock,
+        duration: Expression | None = None,
+    ):
+        self.body = body
+        self.duration = duration
+
+
 class BreakStatement(Statement):
     """AST node for ``break`` statements.  Has no associated information."""
 

qiskit/qasm3/exporter.py

@@ -39,10 +39,12 @@ from qiskit.circuit import (
     Reset,
     Delay,
     Store,
+    Bit,
+    Register,
 )
-from qiskit.circuit.bit import Bit
 from qiskit.circuit.classical import expr, types
 from qiskit.circuit.controlflow import (
+    BoxOp,
     IfElseOp,
     ForLoopOp,
     WhileLoopOp,
@@ -52,7 +54,6 @@ from qiskit.circuit.controlflow import (
     ContinueLoopOp,
     CASE_DEFAULT,
 )
-from qiskit.circuit.register import Register
 from qiskit.circuit.tools import pi_check
 
 from . import ast
@@ -60,7 +61,6 @@ from .experimental import ExperimentalFeatures
 from .exceptions import QASM3ExporterError
 from .printer import BasicPrinter
 
-
 # Reserved keywords that gates and variables cannot be named.  It is possible that some of these
 # _could_ be accepted as variable names by OpenQASM 3 parsers, but it's safer for us to just be very
 # conservative.
@@ -626,7 +626,7 @@ class QASM3Builder:
     def build_program(self):
         """Builds a Program"""
         circuit = self.scope.circuit
-        if circuit.num_captured_vars:
+        if circuit.num_captured_vars or circuit.num_captured_stretches:
             raise QASM3ExporterError(
                 "cannot export an inner scope with captured variables as a top-level program"
             )
@@ -958,6 +958,14 @@ class QASM3Builder:
             )
             for var in self.scope.circuit.iter_declared_vars()
         ]
+
+        for stretch in self.scope.circuit.iter_declared_stretches():
+            statements.append(
+                ast.StretchDeclaration(
+                    self.symbols.register_variable(stretch.name, stretch, allow_rename=True),
+                )
+            )
+
         for instruction in self.scope.circuit.data:
             if isinstance(instruction.operation, ControlFlowOp):
                 if isinstance(instruction.operation, ForLoopOp):
@@ -968,6 +976,8 @@ class QASM3Builder:
                     statements.append(self.build_if_statement(instruction))
                 elif isinstance(instruction.operation, SwitchCaseOp):
                     statements.extend(self.build_switch_statement(instruction))
+                elif isinstance(instruction.operation, BoxOp):
+                    statements.append(self.build_box(instruction))
                 else:
                     raise RuntimeError(f"unhandled control-flow construct: {instruction.operation}")
                 continue
@@ -1006,16 +1016,7 @@ class QASM3Builder:
                     f" but received '{instruction.operation}'"
                 )
 
-            if instruction.operation._condition is None:
-                statements.extend(nodes)
-            else:
-                body = ast.ProgramBlock(nodes)
-                statements.append(
-                    ast.BranchingStatement(
-                        self.build_expression(_lift_condition(instruction.operation._condition)),
-                        body,
-                    )
-                )
+            statements.extend(nodes)
         return statements
 
     def build_if_statement(self, instruction: CircuitInstruction) -> ast.BranchingStatement:
@@ -1085,6 +1086,15 @@ class QASM3Builder:
             ast.SwitchStatement(target, cases, default=default),
         ]
 
+    def build_box(self, instruction: CircuitInstruction) -> ast.BoxStatement:
+        """Build a :class:`.BoxOp` into a :class:`.ast.BoxStatement`."""
+        duration = self.build_duration(instruction.operation.duration, instruction.operation.unit)
+        body_circuit = instruction.operation.blocks[0]
+        with self.new_scope(body_circuit, instruction.qubits, instruction.clbits):
+            # TODO: handle no-op qubits (see https://github.com/openqasm/openqasm/issues/584).
+            body = ast.ProgramBlock(self.build_current_scope())
+        return ast.BoxStatement(body, duration)
+
     def build_while_loop(self, instruction: CircuitInstruction) -> ast.WhileLoopStatement:
         """Build a :obj:`.WhileLoopOp` into a :obj:`.ast.WhileLoopStatement`."""
         condition = self.build_expression(_lift_condition(instruction.operation.condition))
@@ -1134,20 +1144,26 @@ class QASM3Builder:
             raise QASM3ExporterError(
                 f"Found a delay instruction acting on classical bits: {instruction}"
             )
-        duration_value, unit = instruction.operation.duration, instruction.operation.unit
-        if unit == "ps":
-            duration = ast.DurationLiteral(1000 * duration_value, ast.DurationUnit.NANOSECOND)
-        else:
-            unit_map = {
-                "ns": ast.DurationUnit.NANOSECOND,
-                "us": ast.DurationUnit.MICROSECOND,
-                "ms": ast.DurationUnit.MILLISECOND,
-                "s": ast.DurationUnit.SECOND,
-                "dt": ast.DurationUnit.SAMPLE,
-            }
-            duration = ast.DurationLiteral(duration_value, unit_map[unit])
+        duration = self.build_duration(instruction.operation.duration, instruction.operation.unit)
         return ast.QuantumDelay(duration, [self._lookup_bit(qubit) for qubit in instruction.qubits])
 
+    def build_duration(self, duration, unit) -> ast.Expression | None:
+        """Build the expression of a given duration (if not ``None``)."""
+        if duration is None:
+            return None
+        if unit == "expr":
+            return self.build_expression(duration)
+        if unit == "ps":
+            return ast.DurationLiteral(1000 * duration, ast.DurationUnit.NANOSECOND)
+        unit_map = {
+            "ns": ast.DurationUnit.NANOSECOND,
+            "us": ast.DurationUnit.MICROSECOND,
+            "ms": ast.DurationUnit.MILLISECOND,
+            "s": ast.DurationUnit.SECOND,
+            "dt": ast.DurationUnit.SAMPLE,
+        }
+        return ast.DurationLiteral(duration, unit_map[unit])
+
     def build_integer(self, value) -> ast.IntegerLiteral:
         """Build an integer literal, raising a :obj:`.QASM3ExporterError` if the input is not
         actually an
@@ -1262,6 +1278,10 @@ def _build_ast_type(type_: types.Type) -> ast.ClassicalType:
         return ast.BoolType()
     if type_.kind is types.Uint:
         return ast.UintType(type_.width)
+    if type_.kind is types.Float:
+        return ast.FloatType.DOUBLE
+    if type_.kind is types.Duration:
+        return ast.DurationType()
     raise RuntimeError(f"unhandled expr type '{type_}'")
 
 
@@ -1269,7 +1289,7 @@ class _ExprBuilder(expr.ExprVisitor[ast.Expression]):
     __slots__ = ("lookup",)
 
     # This is a very simple, non-contextual converter.  As the type system expands, we may well end
-    # up with some places where Terra's abstract type system needs to be lowered to OQ3 rather than
+    # up with some places where Qiskit's abstract type system needs to be lowered to OQ3 rather than
     # mapping 100% directly, which might need a more contextual visitor.
 
     def __init__(self, lookup):
@@ -1278,11 +1298,29 @@ class _ExprBuilder(expr.ExprVisitor[ast.Expression]):
     def visit_var(self, node, /):
         return self.lookup(node) if node.standalone else self.lookup(node.var)
 
+    def visit_stretch(self, node, /):
+        return self.lookup(node)
+
+    # pylint: disable=too-many-return-statements
     def visit_value(self, node, /):
         if node.type.kind is types.Bool:
             return ast.BooleanLiteral(node.value)
         if node.type.kind is types.Uint:
             return ast.IntegerLiteral(node.value)
+        if node.type.kind is types.Float:
+            return ast.FloatLiteral(node.value)
+        if node.type.kind is types.Duration:
+            unit = node.value.unit()
+            if unit == "dt":
+                return ast.DurationLiteral(node.value.value(), ast.DurationUnit.SAMPLE)
+            if unit == "ns":
+                return ast.DurationLiteral(node.value.value(), ast.DurationUnit.NANOSECOND)
+            if unit == "us":
+                return ast.DurationLiteral(node.value.value(), ast.DurationUnit.MICROSECOND)
+            if unit == "ms":
+                return ast.DurationLiteral(node.value.value(), ast.DurationUnit.MILLISECOND)
+            if unit == "s":
+                return ast.DurationLiteral(node.value.value(), ast.DurationUnit.SECOND)
         raise RuntimeError(f"unhandled Value type '{node}'")
 
     def visit_cast(self, node, /):

qiskit/qasm3/printer.py

@@ -39,8 +39,12 @@ _BINDING_POWER = {
     ast.Unary.Op.LOGIC_NOT: _BindingPower(right=22),
     ast.Unary.Op.BIT_NOT: _BindingPower(right=22),
     #
-    # Multiplication/division/modulo: (19, 20)
-    # Addition/subtraction: (17, 18)
+    # Modulo: (19, 20)
+    ast.Binary.Op.MUL: _BindingPower(19, 20),
+    ast.Binary.Op.DIV: _BindingPower(19, 20),
+    #
+    ast.Binary.Op.ADD: _BindingPower(17, 18),
+    ast.Binary.Op.SUB: _BindingPower(17, 18),
     #
     ast.Binary.Op.SHIFT_LEFT: _BindingPower(15, 16),
     ast.Binary.Op.SHIFT_RIGHT: _BindingPower(15, 16),
@@ -78,7 +82,7 @@ class BasicPrinter:
         ast.QuantumGateModifierName.POW: "pow",
     }
 
-    _FLOAT_WIDTH_LOOKUP = {type: str(type.value) for type in ast.FloatType}
+    _FLOAT_TYPE_LOOKUP = {type: f"float[{type.value}]" for type in ast.FloatType}
 
     # The visitor names include the class names, so they mix snake_case with PascalCase.
     # pylint: disable=invalid-name
@@ -205,11 +209,14 @@ class BasicPrinter:
         self._write_statement(f'defcalgrammar "{node.name}"')
 
     def _visit_FloatType(self, node: ast.FloatType) -> None:
-        self.stream.write(f"float[{self._FLOAT_WIDTH_LOOKUP[node]}]")
+        self.stream.write(self._FLOAT_TYPE_LOOKUP[node])
 
     def _visit_BoolType(self, _node: ast.BoolType) -> None:
         self.stream.write("bool")
 
+    def _visit_DurationType(self, _node: ast.DurationType) -> None:
+        self.stream.write("duration")
+
     def _visit_IntType(self, node: ast.IntType) -> None:
         self.stream.write("int")
         if node.size is not None:
@@ -282,6 +289,9 @@ class BasicPrinter:
     def _visit_IntegerLiteral(self, node: ast.IntegerLiteral) -> None:
         self.stream.write(str(node.value))
 
+    def _visit_FloatLiteral(self, node: ast.FloatLiteral) -> None:
+        self.stream.write(str(node.value))
+
     def _visit_BooleanLiteral(self, node: ast.BooleanLiteral):
         self.stream.write("true" if node.value else "false")
 
@@ -356,6 +366,16 @@ class BasicPrinter:
             self.visit(node.initializer)
         self._end_statement()
 
+    def _visit_StretchDeclaration(self, node: ast.StretchDeclaration) -> None:
+        self._start_line()
+        self.stream.write("stretch")
+        self.stream.write(" ")
+        self.visit(node.identifier)
+        if node.bound is not None:
+            self.stream.write(" = ")
+            self.visit(node.bound)
+        self._end_statement()
+
     def _visit_AssignmentStatement(self, node: ast.AssignmentStatement) -> None:
         self._start_line()
         self.visit(node.lvalue)
@@ -575,3 +595,14 @@ class BasicPrinter:
 
     def _visit_DefaultCase(self, _node: ast.DefaultCase) -> None:
         self.stream.write("default")
+
+    def _visit_BoxStatement(self, node: ast.BoxStatement) -> None:
+        self._start_line()
+        self.stream.write("box")
+        if node.duration is not None:
+            self.stream.write("[")
+            self.visit(node.duration)
+            self.stream.write("]")
+        self.stream.write(" ")
+        self.visit(node.body)
+        self._end_line()