bloqade-circuit 0.4.5__py3-none-any.whl → 0.5.1__py3-none-any.whl

bloqade/stim/rewrite/ifs_to_stim.py

@@ -0,0 +1,203 @@
+from dataclasses import field, dataclass
+
+from kirin import ir
+from kirin.dialects import py, scf, func
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import op, qubit
+from bloqade.rewrite.rules import LiftThenBody, SplitIfStmts
+from bloqade.squin.rewrite import AddressAttribute
+from bloqade.stim.rewrite.util import (
+    SQUIN_STIM_CONTROL_GATE_MAPPING,
+    insert_qubit_idx_from_address,
+)
+from bloqade.stim.dialects.auxiliary import GetRecord
+from bloqade.analysis.measure_id.lattice import (
+    MeasureId,
+    MeasureIdBool,
+)
+
+
+@dataclass
+class IfElseSimplification:
+
+    # Might be better to just do a rewrite_Region?
+    def is_rewriteable(self, node: scf.IfElse) -> bool:
+        return not (
+            self.contains_ifelse(node)
+            or self.is_nested_ifelse(node)
+            or self.has_else_body(node)
+        )
+
+    # A preliminary check to reject an IfElse from the "top down"
+    # use in conjunction with is_nested_ifelse
+    # to completely cover cases of nested IfElse statements
+    def contains_ifelse(self, stmt: scf.IfElse) -> bool:
+        """Check if the IfElse statement contains another IfElse statement."""
+        for child in stmt.walk(include_self=False):
+            if isinstance(child, scf.IfElse):
+                return True
+        return False
+
+    # because rewrite latches onto ANY scf.IfElse,
+    # you need a way to determine if you're touching an
+    # IfElse that's inside another IfElse
+    def is_nested_ifelse(self, stmt: scf.IfElse) -> bool:
+        """Check if the IfElse statement is nested."""
+        if stmt.parent_stmt is not None:
+            if isinstance(stmt.parent_stmt, scf.IfElse) or isinstance(
+                stmt.parent_stmt.parent_stmt, scf.IfElse
+            ):
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    def has_else_body(self, stmt: scf.IfElse) -> bool:
+        """Check if the IfElse statement has an else body."""
+        if stmt.else_body.blocks and not (
+            len(stmt.else_body.blocks[0].stmts) == 1
+            and isinstance(else_term := stmt.else_body.blocks[0].last_stmt, scf.Yield)
+            and not else_term.values  # empty yield
+        ):
+            return True
+
+        return False
+
+
+DontLiftType = (
+    qubit.Apply,
+    qubit.Broadcast,
+    scf.Yield,
+    func.Return,
+    func.Invoke,
+    scf.IfElse,
+)
+
+
+@dataclass
+class StimLiftThenBody(IfElseSimplification, LiftThenBody):
+    exclude_stmts: tuple[type[ir.Statement], ...] = field(default=DontLiftType)
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        if not isinstance(node, scf.IfElse):
+            return RewriteResult()
+
+        if not self.is_rewriteable(node):
+            return RewriteResult()
+
+        return super().rewrite_Statement(node)
+
+
+# Only run this after everything other than qubit.Apply/qubit.Broadcast has been
+# lifted out!
+class StimSplitIfStmts(IfElseSimplification, SplitIfStmts):
+    """Splits the then body of an if-else statement into multiple if statements
+
+    Given an IfElse with multiple valid statements in the then-body:
+
+    if measure_result:
+        squin.qubit.apply(op.X, q0)
+        squin.qubit.apply(op.Y, q1)
+
+    this should be rewritten to:
+
+    if measure_result:
+        squin.qubit.apply(op.X, q0)
+
+    if measure_result:
+        squin.qubit.apply(op.Y, q1)
+    """
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        if not isinstance(node, scf.IfElse):
+            return RewriteResult()
+
+        if not self.is_rewriteable(node):
+            return RewriteResult()
+
+        return super().rewrite_Statement(node)
+
+
+@dataclass
+class IfToStim(IfElseSimplification, RewriteRule):
+    """
+    Rewrite if statements to stim equivalent statements.
+    """
+
+    measure_analysis: dict[ir.SSAValue, MeasureId]
+    measure_count: int
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        match node:
+            case scf.IfElse():
+                return self.rewrite_IfElse(node)
+            case _:
+                return RewriteResult()
+
+    def rewrite_IfElse(self, stmt: scf.IfElse) -> RewriteResult:
+
+        if not isinstance(self.measure_analysis[stmt.cond], MeasureIdBool):
+            return RewriteResult()
+
+        # check that there is only qubit.Apply in the then-body,
+        # if there's more than that, we can't do a valid rewrite.
+        # Can reuse logic from SplitIf
+        *stmts, _ = stmt.then_body.stmts()
+        if len(stmts) != 1 or not isinstance(stmts[0], (qubit.Apply, qubit.Broadcast)):
+            return RewriteResult()
+
+        apply_or_broadcast = stmts[0]
+        # Check that the gate being applied/broadcasted can be converted to a stim
+        # controlled gate.
+        ctrl_op_target_gate = apply_or_broadcast.operator.owner
+        assert isinstance(ctrl_op_target_gate, op.stmts.Operator)
+
+        stim_gate = SQUIN_STIM_CONTROL_GATE_MAPPING.get(type(ctrl_op_target_gate))
+        if stim_gate is None:
+            return RewriteResult()
+
+        # get necessary measurement ID type from analysis
+        measure_id_bool = self.measure_analysis[stmt.cond]
+        assert isinstance(measure_id_bool, MeasureIdBool)
+
+        # generate get record statement
+        measure_id_idx_stmt = py.Constant(
+            (measure_id_bool.idx - 1) - self.measure_count
+        )
+        get_record_stmt = GetRecord(id=measure_id_idx_stmt.result)  # noqa: F841
+
+        # get address attribute and generate qubit idx statements
+        address_attr = apply_or_broadcast.qubits.hints.get("address")
+        if address_attr is None:
+            return RewriteResult()
+        assert isinstance(address_attr, AddressAttribute)
+
+        # note: insert things before (literally above/outside) the If
+        qubit_idx_ssas = insert_qubit_idx_from_address(
+            address=address_attr, stmt_to_insert_before=stmt
+        )
+        if qubit_idx_ssas is None:
+            return RewriteResult()
+
+        # Assemble the stim statement
+        # let GetRecord's SSA be repeated per each get qubit
+        ctrl_records = tuple(get_record_stmt.result for _ in qubit_idx_ssas)
+
+        stim_stmt = stim_gate(
+            targets=tuple(qubit_idx_ssas),
+            controls=ctrl_records,
+        )
+
+        # Insert the necessary SSA Values, then get rid of the scf.IfElse.
+        # The qubit indices have been successfully added,
+        # that just leaves the GetRecord statement and measurement ID index statement
+
+        measure_id_idx_stmt.insert_before(stmt)
+        get_record_stmt.insert_before(stmt)
+        stmt.replace_by(stim_stmt)
+
+        return RewriteResult(has_done_something=True)

bloqade/stim/rewrite/qubit_to_stim.py

@@ -1,17 +1,21 @@
 from kirin import ir
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
-from bloqade.squin import op, qubit
+from bloqade.squin import op, noise, qubit
 from bloqade.squin.rewrite import AddressAttribute
 from bloqade.stim.dialects import gate
 from bloqade.stim.rewrite.util import (
-    SQUIN_STIM_GATE_MAPPING,
+    SQUIN_STIM_OP_MAPPING,
     rewrite_Control,
+    rewrite_QubitLoss,
     insert_qubit_idx_from_address,
 )
 
 
 class SquinQubitToStim(RewriteRule):
+    """
+    NOTE this require address analysis result to be wrapped before using this rule.
+    """
 
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
 
@@ -30,11 +34,17 @@ class SquinQubitToStim(RewriteRule):
 
         # this is an SSAValue, need it to be the actual operator
         applied_op = stmt.operator.owner
+
+        if isinstance(applied_op, noise.stmts.QubitLoss):
+            return rewrite_QubitLoss(stmt)
+
         assert isinstance(applied_op, op.stmts.Operator)
 
         if isinstance(applied_op, op.stmts.Control):
             return rewrite_Control(stmt)
 
+        # need to handle Control through separate means
+
         # check if its adjoint, assume its canonicalized so no nested adjoints.
         is_conj = False
         if isinstance(applied_op, op.stmts.Adjoint):
@@ -44,9 +54,7 @@ class SquinQubitToStim(RewriteRule):
             is_conj = True
             applied_op = applied_op.op.owner
 
-        # need to handle Control through separate means
-        # but we can handle X, Y, Z, H, and S here just fine
-        stim_1q_op = SQUIN_STIM_GATE_MAPPING.get(type(applied_op))
+        stim_1q_op = SQUIN_STIM_OP_MAPPING.get(type(applied_op))
         if stim_1q_op is None:
             return RewriteResult()
 
@@ -55,7 +63,6 @@ class SquinQubitToStim(RewriteRule):
         if address_attr is None:
             return RewriteResult()
 
-        # sometimes you can get a whole AddressReg...
         assert isinstance(address_attr, AddressAttribute)
         qubit_idx_ssas = insert_qubit_idx_from_address(
             address=address_attr, stmt_to_insert_before=stmt

bloqade/stim/rewrite/squin_measure.py

@@ -1,22 +1,59 @@
 # create rewrite rule name SquinMeasureToStim using kirin
+from dataclasses import dataclass
+
 from kirin import ir
-from kirin.dialects import py
+from kirin.dialects import py, ilist
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
 from bloqade.squin import wire, qubit
 from bloqade.squin.rewrite import AddressAttribute
-from bloqade.stim.dialects import collapse
+from bloqade.stim.dialects import collapse, auxiliary
 from bloqade.stim.rewrite.util import (
     is_measure_result_used,
     insert_qubit_idx_from_address,
 )
+from bloqade.analysis.measure_id.lattice import MeasureId, MeasureIdBool, MeasureIdTuple
+
+
+def replace_get_record(
+    node: ir.Statement, measure_id_bool: MeasureIdBool, meas_count: int
+):
+    assert isinstance(measure_id_bool, MeasureIdBool)
+    target_rec_idx = (measure_id_bool.idx - 1) - meas_count
+    idx_stmt = py.constant.Constant(target_rec_idx)
+    idx_stmt.insert_before(node)
+    get_record_stmt = auxiliary.GetRecord(idx_stmt.result)
+    node.replace_by(get_record_stmt)
+
+
+def insert_get_record_list(
+    node: ir.Statement, measure_id_tuple: MeasureIdTuple, meas_count: int
+):
+    """
+    Insert GetRecord statements before the given node
+    """
+    get_record_ssas = []
+    for measure_id_bool in measure_id_tuple.data:
+        assert isinstance(measure_id_bool, MeasureIdBool)
+        target_rec_idx = (measure_id_bool.idx - 1) - meas_count
+        idx_stmt = py.constant.Constant(target_rec_idx)
+        idx_stmt.insert_before(node)
+        get_record_stmt = auxiliary.GetRecord(idx_stmt.result)
+        get_record_stmt.insert_before(node)
+        get_record_ssas.append(get_record_stmt.result)
 
+    node.replace_by(ilist.New(values=get_record_ssas))
 
+
+@dataclass
 class SquinMeasureToStim(RewriteRule):
     """
     Rewrite squin measure-related statements to stim statements.
     """
 
+    measure_id_result: dict[ir.SSAValue, MeasureId]
+    total_measure_count: int
+
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
 
         match node:
@@ -28,20 +65,46 @@ class SquinMeasureToStim(RewriteRule):
     def rewrite_Measure(
         self, measure_stmt: qubit.MeasureQubit | qubit.MeasureQubitList | wire.Measure
     ) -> RewriteResult:
-        if is_measure_result_used(measure_stmt):
-            return RewriteResult()
 
         qubit_idx_ssas = self.get_qubit_idx_ssas(measure_stmt)
         if qubit_idx_ssas is None:
             return RewriteResult()
 
+        measure_id = self.measure_id_result[measure_stmt.result]
+        if not isinstance(measure_id, (MeasureIdBool, MeasureIdTuple)):
+            return RewriteResult()
+
         prob_noise_stmt = py.constant.Constant(0.0)
         stim_measure_stmt = collapse.MZ(
             p=prob_noise_stmt.result,
             targets=qubit_idx_ssas,
         )
         prob_noise_stmt.insert_before(measure_stmt)
-        measure_stmt.replace_by(stim_measure_stmt)
+        stim_measure_stmt.insert_before(measure_stmt)
+
+        if not is_measure_result_used(measure_stmt):
+            measure_stmt.delete()
+            return RewriteResult(has_done_something=True)
+
+        # replace dataflow with new stmt!
+        measure_id = self.measure_id_result[measure_stmt.result]
+        if isinstance(measure_id, MeasureIdBool):
+            replace_get_record(
+                node=measure_stmt,
+                measure_id_bool=measure_id,
+                meas_count=self.total_measure_count,
+            )
+        elif isinstance(measure_id, MeasureIdTuple):
+            insert_get_record_list(
+                node=measure_stmt,
+                measure_id_tuple=measure_id,
+                meas_count=self.total_measure_count,
+            )
+        else:
+            # already checked before, so this should not happen
+            raise ValueError(
+                f"Unexpected measure ID type: {type(measure_id)} for measure statement {measure_stmt}"
+            )
 
         return RewriteResult(has_done_something=True)
 

bloqade/stim/rewrite/squin_noise.py

@@ -0,0 +1,120 @@
+from typing import Dict, Tuple
+from dataclasses import dataclass
+
+from kirin.ir import SSAValue, Statement
+from kirin.analysis import const
+from kirin.dialects import py
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import wire, noise as squin_noise, qubit
+from bloqade.stim.dialects import noise as stim_noise
+from bloqade.stim.rewrite.util import (
+    create_wire_passthrough,
+    insert_qubit_idx_after_apply,
+)
+
+
+@dataclass
+class SquinNoiseToStim(RewriteRule):
+
+    cp_results: Dict[SSAValue, const.Result]
+
+    def rewrite_Statement(self, node: Statement) -> RewriteResult:
+        match node:
+            case qubit.Apply() | qubit.Broadcast():
+                return self.rewrite_Apply_and_Broadcast(node)
+            case _:
+                return RewriteResult()
+
+    def rewrite_Apply_and_Broadcast(
+        self, stmt: qubit.Apply | qubit.Broadcast
+    ) -> RewriteResult:
+        """Rewrite Apply and Broadcast to their stim statements."""
+
+        # this is an SSAValue, need it to be the actual operator
+        applied_op = stmt.operator.owner
+
+        if isinstance(applied_op, squin_noise.stmts.NoiseChannel):
+
+            qubit_idx_ssas = insert_qubit_idx_after_apply(stmt=stmt)
+            if qubit_idx_ssas is None:
+                return RewriteResult()
+
+            stim_stmt = None
+            if isinstance(applied_op, squin_noise.stmts.SingleQubitPauliChannel):
+                stim_stmt = self.rewrite_SingleQubitPauliChannel(stmt, qubit_idx_ssas)
+            elif isinstance(applied_op, squin_noise.stmts.TwoQubitPauliChannel):
+                stim_stmt = self.rewrite_TwoQubitPauliChannel(stmt, qubit_idx_ssas)
+
+            if isinstance(stmt, (wire.Apply, wire.Broadcast)):
+                create_wire_passthrough(stmt)
+
+            if stim_stmt is not None:
+                stmt.replace_by(stim_stmt)
+            if len(stmt.operator.owner.result.uses) == 0:
+                stmt.operator.owner.delete()
+
+            return RewriteResult(has_done_something=True)
+        return RewriteResult()
+
+    def rewrite_SingleQubitPauliChannel(
+        self,
+        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        qubit_idx_ssas: Tuple[SSAValue],
+    ) -> Statement:
+        """Rewrite squin.noise.SingleQubitPauliChannel to stim.PauliChannel1."""
+
+        squin_channel = stmt.operator.owner
+        assert isinstance(squin_channel, squin_noise.stmts.SingleQubitPauliChannel)
+
+        params = self.cp_results.get(squin_channel.params).data
+        new_stmts = [
+            p_x := py.Constant(params[0]),
+            p_y := py.Constant(params[1]),
+            p_z := py.Constant(params[2]),
+        ]
+        for new_stmt in new_stmts:
+            new_stmt.insert_before(stmt)
+
+        stim_stmt = stim_noise.PauliChannel1(
+            targets=qubit_idx_ssas,
+            px=p_x.result,
+            py=p_y.result,
+            pz=p_z.result,
+        )
+        return stim_stmt
+
+    def rewrite_TwoQubitPauliChannel(
+        self,
+        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        qubit_idx_ssas: Tuple[SSAValue],
+    ) -> Statement:
+        """Rewrite squin.noise.SingleQubitPauliChannel to stim.PauliChannel1."""
+
+        squin_channel = stmt.operator.owner
+        assert isinstance(squin_channel, squin_noise.stmts.TwoQubitPauliChannel)
+
+        params = self.cp_results.get(squin_channel.params).data
+        param_stmts = [py.Constant(p) for p in params]
+        for param_stmt in param_stmts:
+            param_stmt.insert_before(stmt)
+
+        stim_stmt = stim_noise.PauliChannel2(
+            targets=qubit_idx_ssas,
+            pix=param_stmts[0].result,
+            piy=param_stmts[1].result,
+            piz=param_stmts[2].result,
+            pxi=param_stmts[3].result,
+            pxx=param_stmts[4].result,
+            pxy=param_stmts[5].result,
+            pxz=param_stmts[6].result,
+            pyi=param_stmts[7].result,
+            pyx=param_stmts[8].result,
+            pyy=param_stmts[9].result,
+            pyz=param_stmts[10].result,
+            pzi=param_stmts[11].result,
+            pzx=param_stmts[12].result,
+            pzy=param_stmts[13].result,
+            pzz=param_stmts[14].result,
+        )
+        return stim_stmt

bloqade/stim/rewrite/util.py

@@ -2,12 +2,12 @@ from kirin import ir
 from kirin.dialects import py
 from kirin.rewrite.abc import RewriteResult
 
-from bloqade.squin import op, wire, qubit
+from bloqade.squin import op, wire, noise as squin_noise, qubit
 from bloqade.squin.rewrite import AddressAttribute
-from bloqade.stim.dialects import gate, collapse
+from bloqade.stim.dialects import gate, noise as stim_noise, collapse
 from bloqade.analysis.address import AddressReg, AddressWire, AddressQubit, AddressTuple
 
-SQUIN_STIM_GATE_MAPPING = {
+SQUIN_STIM_OP_MAPPING = {
     op.stmts.X: gate.X,
     op.stmts.Y: gate.Y,
     op.stmts.Z: gate.Z,
@@ -17,6 +17,7 @@ SQUIN_STIM_GATE_MAPPING = {
     op.stmts.SqrtY: gate.SqrtY,
     op.stmts.Identity: gate.Identity,
     op.stmts.Reset: collapse.RZ,
+    squin_noise.stmts.QubitLoss: stim_noise.QubitLoss,
 }
 
 # Squin allows creation of control gates where the gate can be any operator,
@@ -151,18 +152,48 @@ def rewrite_Control(
     stim_stmt = stim_gate(controls=ctrl_qubits, targets=target_qubits)
 
     if isinstance(stmt_with_ctrl, (wire.Apply, wire.Broadcast)):
-        # have to "reroute" the input of these statements to directly plug in
-        # to subsequent statements, remove dependency on the current statement
-        for input_wire, output_wire in zip(
-            stmt_with_ctrl.inputs, stmt_with_ctrl.results
-        ):
-            output_wire.replace_by(input_wire)
+        create_wire_passthrough(stmt_with_ctrl)
 
     stmt_with_ctrl.replace_by(stim_stmt)
 
     return RewriteResult(has_done_something=True)
 
 
+def rewrite_QubitLoss(
+    stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+) -> RewriteResult:
+    """
+    Rewrite QubitLoss statements to Stim's TrivialError.
+    """
+
+    squin_loss_op = stmt.operator.owner
+    assert isinstance(squin_loss_op, squin_noise.stmts.QubitLoss)
+
+    qubit_idx_ssas = insert_qubit_idx_after_apply(stmt=stmt)
+    if qubit_idx_ssas is None:
+        return RewriteResult()
+
+    stim_loss_stmt = stim_noise.QubitLoss(
+        targets=qubit_idx_ssas,
+        probs=(squin_loss_op.p,),
+    )
+
+    if isinstance(stmt, (wire.Apply, wire.Broadcast)):
+        create_wire_passthrough(stmt)
+
+    stmt.replace_by(stim_loss_stmt)
+
+    return RewriteResult(has_done_something=True)
+
+
+def create_wire_passthrough(stmt: wire.Apply | wire.Broadcast) -> None:
+
+    for input_wire, output_wire in zip(stmt.inputs, stmt.results):
+        # have to "reroute" the input of these statements to directly plug in
+        # to subsequent statements, remove dependency on the current statement
+        output_wire.replace_by(input_wire)
+
+
 def is_measure_result_used(
     stmt: qubit.MeasureQubit | qubit.MeasureQubitList | wire.Measure,
 ) -> bool:

bloqade/stim/rewrite/wire_to_stim.py

@@ -1,10 +1,11 @@
 from kirin import ir
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
-from bloqade.squin import op, wire
+from bloqade.squin import op, wire, noise
 from bloqade.stim.rewrite.util import (
-    SQUIN_STIM_GATE_MAPPING,
+    SQUIN_STIM_OP_MAPPING,
     rewrite_Control,
+    rewrite_QubitLoss,
     insert_qubit_idx_from_wire_ssa,
 )
 
@@ -24,12 +25,16 @@ class SquinWireToStim(RewriteRule):
 
         # this is an SSAValue, need it to be the actual operator
         applied_op = stmt.operator.owner
+
+        if isinstance(applied_op, noise.stmts.QubitLoss):
+            return rewrite_QubitLoss(stmt)
+
         assert isinstance(applied_op, op.stmts.Operator)
 
         if isinstance(applied_op, op.stmts.Control):
             return rewrite_Control(stmt)
 
-        stim_1q_op = SQUIN_STIM_GATE_MAPPING.get(type(applied_op))
+        stim_1q_op = SQUIN_STIM_OP_MAPPING.get(type(applied_op))
         if stim_1q_op is None:
             return RewriteResult()
 

bloqade/stim/upstream/__init__.py

@@ -0,0 +1 @@
+from .from_squin import squin_to_stim as squin_to_stim

bloqade/stim/upstream/from_squin.py

@@ -0,0 +1,10 @@
+from kirin import ir
+
+from ..groups import main
+from ..passes.squin_to_stim import SquinToStimPass
+
+
+def squin_to_stim(mt: ir.Method) -> ir.Method:
+    new_mt = mt.similar()
+    SquinToStimPass(mt.dialects, no_raise=False)(new_mt)
+    return new_mt.similar(dialects=main)

{bloqade_circuit-0.4.5.dist-info → bloqade_circuit-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.4.5
+Version: 0.5.1
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE
@@ -16,6 +16,7 @@ Requires-Dist: scipy>=1.13.1
 Provides-Extra: cirq
 Requires-Dist: cirq-core>=1.4.1; extra == 'cirq'
 Requires-Dist: cirq-core[contrib]>=1.4.1; extra == 'cirq'
+Requires-Dist: qpsolvers[clarabel]>=4.7.0; extra == 'cirq'
 Provides-Extra: pyqrack-cuda
 Requires-Dist: pyqrack-cuda>=1.38.2; extra == 'pyqrack-cuda'
 Provides-Extra: pyqrack-opencl
@@ -29,7 +30,8 @@ Requires-Dist: stim>=1.15.0; extra == 'stim'
 Provides-Extra: vis
 Requires-Dist: ffmpeg>=1.4; extra == 'vis'
 Requires-Dist: matplotlib>=3.9.2; extra == 'vis'
-Requires-Dist: pyqt5>=5.15.11; extra == 'vis'
+Requires-Dist: pyqt5>=5.15.11; (sys_platform == 'darwin') and extra == 'vis'
+Requires-Dist: pyqt5>=5.15.11; (sys_platform == 'linux') and extra == 'vis'
 Requires-Dist: tqdm>=4.66.5; extra == 'vis'
 Description-Content-Type: text/markdown