@@ -133,11 +133,35 @@ def _graph_with_users_not_in_node_order() -> GraphModule:
     return GraphModule(torch.nn.Module(), graph)
 
 
+def _graph_with_erased_node_still_queued() -> GraphModule:
+    graph = Graph()
+    x = _set_val(graph.placeholder("x"), torch.ones(1))
+    first_neg = _set_val(
+        graph.call_function(torch.ops.aten.neg.default, (x,)), torch.ones(1)
+    )
+    second_neg = _set_val(
+        graph.call_function(torch.ops.aten.neg.default, (x,)), torch.ones(1)
+    )
+    first_relu = _set_val(
+        graph.call_function(torch.ops.aten.relu.default, (first_neg,)), torch.ones(1)
+    )
+    second_relu = _set_val(
+        graph.call_function(torch.ops.aten.relu.default, (second_neg,)), torch.ones(1)
+    )
+    output = graph.output((first_relu, second_relu))
+    output.meta["val"] = (torch.ones(1), torch.ones(1))
+    graph.lint()
+    return GraphModule(torch.nn.Module(), graph)
+
+
+def _nodes_with_target(graph_module, target):
+    return [node for node in graph_module.graph.nodes if node.target == target]
+
+
 def _add_node_names(graph_module):
     return [
         node.name
-        for node in graph_module.graph.nodes
-        if node.target == torch.ops.aten.add.Tensor
+        for node in _nodes_with_target(graph_module, torch.ops.aten.add.Tensor)
     ]
 
 
@@ -183,6 +207,23 @@ def test_fuse_duplicate_users_honors_do_not_fuse_marker():
     assert len(_add_node_names(result.graph_module)) == 2
 
 
+def test_fuse_duplicate_users_skips_erased_queued_nodes():
+    result = FuseDuplicateUsersPass()(_graph_with_erased_node_still_queued())
+
+    neg_nodes = _nodes_with_target(result.graph_module, torch.ops.aten.neg.default)
+    relu_nodes = _nodes_with_target(result.graph_module, torch.ops.aten.relu.default)
+    output = next(
+        node for node in result.graph_module.graph.nodes if node.op == "output"
+    )
+
+    result.graph_module.graph.lint()
+    assert result.modified
+    assert len(neg_nodes) == 1
+    assert len(relu_nodes) == 1
+    assert relu_nodes[0].args[0] is neg_nodes[0]
+    assert output.args[0] == (relu_nodes[0], relu_nodes[0])
+
+
 def test_fuse_duplicate_users_keeps_identical_rescale_users():
     graph_module = _graph_with_duplicate_rescale_users()
 
 
@@ -1168,6 +1168,39 @@ def test_up_pass_fuses_equivalent_output_permutations_before_fan_out() -> None:
     assert targets.index(PERMUTE) < targets.index(RELU) < targets.index(ADD)
 
 
+def test_up_pass_fusion_enables_further_propagation() -> None:
+    graph = torch.fx.Graph()
+    x = graph.placeholder("x")
+    x.meta["val"] = torch.empty((1, 2, 3, 4))
+    relu = graph.call_function(RELU, args=(x,))
+    relu.meta["val"] = torch.empty((1, 2, 3, 4))
+    neg = graph.call_function(NEG, args=(relu,))
+    neg.meta["val"] = torch.empty((1, 2, 3, 4))
+    first_permute = graph.call_function(PERMUTE, args=(neg, [0, 2, 3, 1]))
+    first_permute.meta["val"] = torch.empty((1, 3, 4, 2))
+    second_permute = graph.call_function(PERMUTE, args=(relu, [0, 2, 3, 1]))
+    second_permute.meta["val"] = torch.empty((1, 3, 4, 2))
+    add = graph.call_function(ADD, args=(first_permute, second_permute))
+    add.meta["val"] = torch.empty((1, 3, 4, 2))
+    graph.output(add)
+
+    graph_module = _run_pass_on_graph_module(graph, PropagateViewCopyPermuteUpPass)
+    call_nodes = [
+        node for node in graph_module.graph.nodes if node.op == "call_function"
+    ]
+    permutes = [node for node in call_nodes if node.target == PERMUTE]
+    x = next(node for node in graph_module.graph.nodes if node.op == "placeholder")
+    relu = next(node for node in call_nodes if node.target == RELU)
+    neg = next(node for node in call_nodes if node.target == NEG)
+    add = next(node for node in call_nodes if node.target == ADD)
+
+    assert len(permutes) == 1
+    assert permutes[0].args[0] is x
+    assert relu.args[0] is permutes[0]
+    assert neg.args[0] is relu
+    assert set(add.all_input_nodes) == {relu, neg}
+
+
 def test_propagate_moves_before_dtype_changing_rescale() -> None:
     graph = torch.fx.Graph()
     x = graph.placeholder("x")
 
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections import deque
 from typing import Any, cast, Iterable, Sequence, Set, Type
 
 import torch
@@ -104,20 +105,29 @@ def _collect_chains(self, graph_module: GraphModule) -> list[list[Node]]:
         """Returns a list of linear chains of view/permutes in the graph."""
         chains: list[list[Node]] = []
 
-        view_permute_nodes = [
+        view_permute_nodes = deque(
             node for node in graph_module.graph.nodes if node.target in self._targets
-        ]
+        )
+        remaining = set(view_permute_nodes)
 
         while view_permute_nodes:
-            node = view_permute_nodes.pop(0)
+            node = view_permute_nodes.popleft()
+            if node not in remaining:
+                continue
+            remaining.remove(node)
+
             chain = [node]
             current = node
 
             while len(current.users) == 1:
                 user = next(iter(current.users))
                 if user.target not in self._targets:
                     break
-                view_permute_nodes.remove(user)
+                if user not in remaining:
+                    raise RuntimeError(
+                        f"View/permute node {user.name} belongs to multiple chains"
+                    )
+                remaining.remove(user)
                 chain.append(user)
                 current = user
 
 
@@ -4,7 +4,7 @@
 # LICENSE file in the root directory of this source tree.
 
 from collections import deque
-from typing import Any, Deque, Dict, Hashable, List, Set, Tuple, Type
+from typing import Any, Callable, Deque, Dict, Hashable, List, Set, Tuple, Type
 
 import torch
 from executorch.exir.dialects.edge._ops import EdgeOpOverload
@@ -83,6 +83,12 @@ def build_node_signature(
     return (node.op, _get_target_key(node.target), normalized_args, normalized_kwargs)
 
 
+def _is_erased(node: Node) -> bool:
+    # FX currently retains graph after erase_node(), but also handle versions
+    # that detach erased nodes from their graph.
+    return node.graph is None or getattr(node, "_erased", False)
+
+
 class FuseDuplicateUsersPass(ExportPass):
     """Fuse identical users of a producer node into a single operation.
 
@@ -112,12 +118,20 @@ def call(self, graph_module: GraphModule) -> PassResult:
 
         node_order = {node: index for index, node in enumerate(graph.nodes)}
         producers: Deque[Node] = deque(node for node in graph.nodes)
+        queued_producers: Set[Node] = set(producers)
+
+        def enqueue_producer(node: Node) -> None:
+            if _is_erased(node) or node in queued_producers:
+                return
+            producers.append(node)
+            queued_producers.add(node)
 
         while producers:
             producer = producers.popleft()
+            queued_producers.discard(producer)
 
-            if producer.graph is None:
-                # Node was deleted by a previous rewrite while still queued.
+            if _is_erased(producer):
+                # Graph.erase_node marks nodes retained by iterators as erased.
                 continue
 
             # Only meaningful if a value is consumed by multiple users.
@@ -126,33 +140,9 @@ def call(self, graph_module: GraphModule) -> PassResult:
                 continue
 
             candidate_groups = self._get_candidate_groups(node_order, user_nodes)
-
-            signature_to_user: Dict[Tuple[Hashable, ...], Node] = {}
-            for group in candidate_groups:
-                for user in group:
-                    signature = self._build_user_signature(user)
-                    if signature is None:
-                        continue
-
-                    representative = signature_to_user.get(signature)
-                    if representative is None:
-                        # Check if we already encountered identical node that we can fuse with.
-                        signature_to_user[signature] = user
-                        continue
-
-                    if user is representative:
-                        # The queue can enqueue the surviving node again after rewrites.
-                        continue
-
-                    user.replace_all_uses_with(representative)
-                    graph.erase_node(user)
-                    modified = True
-
-                    # Revisit the current producer and the surviving user so that
-                    # newly formed duplicate chains can be fused in later
-                    # iterations.
-                    producers.append(producer)
-                    producers.append(representative)
+            modified |= self._fuse_candidate_groups(
+                graph, producer, candidate_groups, enqueue_producer
+            )
 
         if modified:
             if self._recompile_before_retrace:
@@ -162,10 +152,44 @@ def call(self, graph_module: GraphModule) -> PassResult:
 
         return PassResult(graph_module, modified)
 
+    def _fuse_candidate_groups(
+        self,
+        graph: torch.fx.Graph,
+        producer: Node,
+        candidate_groups: List[List[Node]],
+        enqueue_producer: Callable[[Node], None],
+    ) -> bool:
+        modified = False
+        signature_to_user: Dict[Tuple[Hashable, ...], Node] = {}
+        for group in candidate_groups:
+            for user in group:
+                signature = self._build_user_signature(user)
+                if signature is None:
+                    continue
+
+                representative = signature_to_user.get(signature)
+                if representative is None:
+                    signature_to_user[signature] = user
+                    continue
+
+                if user is representative:
+                    continue
+
+                user.replace_all_uses_with(representative)
+                graph.erase_node(user)
+                modified = True
+
+                # Revisit the producer and survivor because this fusion can expose
+                # another duplicate pair later in the chain.
+                enqueue_producer(producer)
+                enqueue_producer(representative)
+
+        return modified
+
     def _get_candidate_groups(self, node_order, user_nodes):
         users_by_target: Dict[Tuple[str, Hashable], List[Node]] = {}
         for user in user_nodes:
-            if user.graph is None:
+            if _is_erased(user):
                 # User might already have been removed by a prior rewrite.
                 continue