Update Pauli example (#423)

The problem with the link to the Fold pass is that there's a problem
with the nav generation, I think. The page of the fold pass is just
empty:
https://queracomputing.github.io/kirin/latest/reference/kirin/passes/fold/

Ref #419

Author: david-pl

docs/cookbook/paulilang/pauli.md

@@ -138,35 +138,35 @@ Since we want to rewrite statements of our dialect, the entry point we define in
 ```python
 from dataclasses import dataclass
 
-from kirin.rewrite import abc, result
+from kirin.rewrite import abc
 from kirin.dialects import py
 
 
 @dataclass
 class RewritePauliMult(abc.RewriteRule):
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         if not isinstance(node, py.binop.Mult):  # (1)!
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         if not isinstance(node.lhs.owner, PauliOperator) and not isinstance(node.rhs.owner, PauliOperator):  # (2)!
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         if isinstance(node.lhs.owner, py.Constant): # (3)!
             new_op = self.number_pauli_mult(node.lhs.owner, node.rhs.owner)
             node.replace_by(new_op)
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
         elif isinstance(node.rhs.owner, py.Constant): # (4)!
             new_op = self.number_pauli_mult(node.rhs.owner, node.lhs.owner)
             node.replace_by(new_op)
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
 
 
         if not isinstance(node.lhs.owner, PauliOperator) or not isinstance(node.rhs.owner, PauliOperator):  # (5)!
-                return result.RewriteResult()
+                return abc.RewriteResult()
 
         new_op = self.pauli_pauli_mult(node.lhs.owner, node.rhs.owner)  #(6)!
         node.replace_by(new_op)
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
     ...
 ```
@@ -411,9 +411,9 @@ The basic principle is the same as before.
 ```python
 @dataclass
 class RewriteDistributeMult(abc.RewriteRule):
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         if not isinstance(node, py.binop.Mult):  # (1)!
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         if isinstance(node.lhs.owner, py.binop.Add):  # (2)!
             m1 = py.binop.Mult(node.lhs.owner.lhs, node.rhs)  # (3)!
@@ -424,7 +424,7 @@ class RewriteDistributeMult(abc.RewriteRule):
 
             a = py.binop.Add(m1.result, m2.result)  # (5)!
             node.replace_by(a)  # (6)!
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
 
         if isinstance(node.rhs.owner, py.binop.Add):
             m1 = py.binop.Mult(node.lhs, node.rhs.owner.lhs)
@@ -435,9 +435,9 @@ class RewriteDistributeMult(abc.RewriteRule):
 
             a = py.binop.Add(m1.result, m2.result)
             node.replace_by(a)
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
 
-        return result.RewriteResult()
+        return abc.RewriteResult()
 ```
 
 1. Again, we want to make sure we're looking at a multiplication.
@@ -633,7 +633,7 @@ print(cool_example())  # (2)!
 1. Register an implementation for the statement `X()`.
 2. Notice that we are actually *calling* the function this time.
 
-And, sure enough, when running the code, we now obtain a $2x2$ matrix:
+And, sure enough, when running the code, we now obtain a 2 x 2 matrix:
 
 ```python
 [[ 2.+2.j -2.+2.j]
@@ -675,7 +675,7 @@ Amazing.
 
 But, wait:
 if constant folding can evaluate additions, couldn't it also evaluate multiplications?
-Wouldn't the make our multiplication rewrite pass obsolete?
+Wouldn't that make our multiplication rewrite pass obsolete?
 Sort of:
 this would mean that you still evaluate a whole bunch of matrix products, just at compile time rather than at runtime.
 Our rewriting pass, instead uses a symbolic approach to rewrite multiplications without the need to actually evaluate a matrix multiplication.

example/pauli/group.py

@@ -4,7 +4,7 @@
 from kirin.prelude import basic_no_opt
 
 
-@ir._dialectgroup(basic_no_opt.add(dialect=_dialect))
+@ir.dialect_group(basic_no_opt.add(dialect=_dialect))
 def pauli(self):
     def run_pass(mt):
         # TODO

example/pauli/rewrite.py

@@ -1,42 +1,42 @@
 from dataclasses import dataclass
 
 from kirin import ir
-from kirin.rewrite import abc, result
+from kirin.rewrite import abc
 from kirin.dialects import py
 
 from .stmts import X, Y, Z, Id, PauliOperator
 
 
 @dataclass
 class RewritePauliMult(abc.RewriteRule):
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         if not isinstance(node, py.binop.Mult):
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         if not isinstance(node.lhs.owner, PauliOperator) and not isinstance(
             node.rhs.owner, PauliOperator
         ):
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         if isinstance(node.lhs.owner, py.Constant):
             assert isinstance(node.rhs.owner, PauliOperator)  # make the linter happy
             new_op = self.number_pauli_mult(node.lhs.owner, node.rhs.owner)
             node.replace_by(new_op)
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
         elif isinstance(node.rhs.owner, py.Constant):
             assert isinstance(node.lhs.owner, PauliOperator)  # make the linter happy
             new_op = self.number_pauli_mult(node.rhs.owner, node.lhs.owner)
             node.replace_by(new_op)
-            return result.RewriteResult(has_done_something=True)
+            return abc.RewriteResult(has_done_something=True)
 
         if not isinstance(node.lhs.owner, PauliOperator) or not isinstance(
             node.rhs.owner, PauliOperator
         ):
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         new_op = self.pauli_pauli_mult(node.lhs.owner, node.rhs.owner)
         node.replace_by(new_op)
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
     @staticmethod
     def number_pauli_mult(lhs: py.Constant, rhs: PauliOperator) -> PauliOperator:

src/kirin/passes/fold.py

@@ -19,6 +19,17 @@
 
 @dataclass
 class Fold(Pass):
+    """
+    Pass that runs a number of small optimization rewrites.
+
+    Specifically, the following rewrites are chained:
+
+    - `ConstantFold`
+    - `InlineGetItem`
+    - `Call2Invoke`
+    - `DeadCodeElimination`
+    """
+
     hint_const: HintConst = field(init=False)
 
     def __post_init__(self):