Fix non-deterministic rewriter behavior in multi-output pattern matching (#2880)

`GraphPattern.__init__` collects output nodes into a `set[NodePattern]`,
then converts to a list via `list(output_nodes)`. Python's hash
randomization means this list has non-deterministic order across process
invocations. For multi-output patterns (e.g. `SlicesSplit`), the matcher
fixes `output_nodes[0]` to the current node and searches for
`output_nodes[1:]` — so different orderings cause the same rule to match
or not match non-deterministically.

- Replace `set[NodePattern]` with `dict[NodePattern, None]` (ordered set
idiom) to preserve deterministic insertion order from the `outputs`
sequence
- Add regression test verifying `output_nodes` ordering is stable across
repeated `GraphPattern` constructions

```python
# Before: non-deterministic iteration order
output_nodes: set[NodePattern] = set()
...
output_nodes.add(candidate)
...
self.output_nodes: list[NodePattern] = list(output_nodes)

# After: preserves insertion order from outputs sequence
output_nodes: dict[NodePattern, None] = {}
...
output_nodes[candidate] = None
...
self.output_nodes: list[NodePattern] = list(output_nodes)
```

Fix #2878

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: justinchuby <11205048+justinchuby@users.noreply.github.com>

Author: Copilot

onnxscript/rewriter/_pattern_ir.py

@@ -836,7 +836,11 @@ def __init__(
 
         # Determine the output nodes of the pattern. These are a minimal set of nodes
         # whose backward-slices cover the entire pattern.
-        output_nodes: set[NodePattern] = set()
+        # Use a dict as an ordered set to preserve deterministic insertion order
+        # from the outputs sequence. Using a plain set would cause non-deterministic
+        # ordering due to Python's hash randomization, leading to non-deterministic
+        # pattern matching behavior.
+        output_nodes: dict[NodePattern, None] = {}
         covered: set[NodePattern] = set()
         choice_values_returned: set[ValuePattern] = set()
         covered_choice_values: set[ValuePattern] = set()
@@ -848,7 +852,7 @@ def __init__(
             if isinstance(value_pattern, NodeOutputPattern):
                 candidate = value_pattern.producer()
                 if candidate not in covered:
-                    output_nodes.add(candidate)
+                    output_nodes[candidate] = None
                     _add_backward_slice(candidate, covered, covered_choice_values)
             elif isinstance(value_pattern, (OpIdDispatchOr, BacktrackingOr)):
                 choice_values_returned.add(value_pattern)

onnxscript/rewriter/_pattern_ir_test.py

@@ -71,6 +71,31 @@ def node_checker(context, node):
         self.assertTrue(hasattr(producer, "_check"))
         self.assertIs(producer._check, node_checker)
 
+    def test_graph_pattern_output_nodes_have_deterministic_order(self):
+        """Test that GraphPattern.output_nodes preserves insertion order from outputs.
+
+        Regression test for https://github.com/microsoft/onnxscript/issues/2234.
+        When output_nodes was built from a set, Python's hash randomization could
+        cause non-deterministic ordering, leading to non-deterministic pattern
+        matching behavior for multi-output patterns.
+        """
+        opset_builder = _pattern_ir.OpsetPatternBuilder("")
+        x = _pattern_ir.ValuePattern("x")
+        # Create two distinct node patterns via two separate ops
+        out_a = opset_builder.Relu(x, _outputs=["a"])
+        out_b = opset_builder.Sigmoid(x, _outputs=["b"])
+        outputs = [out_a, out_b]
+
+        # Build the graph pattern multiple times and check the order is always the same
+        for _ in range(50):
+            graph_pattern = _pattern_ir.GraphPattern(inputs=[x], outputs=outputs, nodes=[])
+            node_op_ids = [n._op_identifier for n in graph_pattern.output_nodes]
+            self.assertEqual(
+                node_op_ids,
+                [("", "Relu", ""), ("", "Sigmoid", "")],
+                "output_nodes order must match the order of outputs",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()