@@ -36,6 +36,12 @@ class RemoveRedundantOpsTransform(ExportPass):
         exir_ops.edge.aten.expand_copy.default,
         # copy.default(self, src): no-op when src dtype/shape matches self.
         exir_ops.edge.aten.copy.default,
+        # view_copy.default: a view onto the same shape. These survive into the
+        # partition and dispatch a shader that reads every texel and writes it
+        # back unchanged. Only same-shape views are safe to drop here: a view
+        # that changes the rank must keep its node, because the ops downstream
+        # read their argument's shape.
+        exir_ops.edge.aten.view_copy.default,
     }
 
     # For these ops the meaningful input is args[1] (src), not args[0] (self).
 
@@ -9,7 +9,7 @@
 import logging
 import operator
 from types import NoneType
-from typing import cast, Dict, List, Optional, Union
+from typing import cast, Dict, List, Optional, Tuple, Union
 
 import executorch.backends.vulkan.serialization.vulkan_graph_schema as vk_graph_schema
 import torch
@@ -32,6 +32,7 @@
 from executorch.exir.tensor import TensorSpec
 from torch._export.utils import get_buffer, get_param, is_buffer, is_param
 from torch.export import ExportedProgram
+from torch.export.graph_signature import OutputKind
 from torch.fx import Node
 
 _ScalarType = Union[bool, int, float]
@@ -490,19 +491,80 @@ def process_call_function_node(self, node) -> None:
     def process_getattr_node(self, node: Node) -> None:
         self.create_node_value(node)
 
+    def _output_nodes_in_order(self, node: Node) -> List[Tuple[Optional[int], Node]]:
+        """
+        The graph outputs in order, duplicates included, each paired with its
+        position in the output signature.
+
+        `node.all_input_nodes` de-duplicates, so a graph that returns the same
+        value twice (`return y, y`, or `return y, y.view(...)` once a redundant
+        view is removed) would serialize one output id for two outputs and fail
+        the runtime's argument count check.
+
+        The position is what distinguishes those repeats from a buffer mutation
+        that happens to alias a user output: both reference the same node, so
+        only the signature can say which slot is which. It is None when the
+        signature does not line up with the output args, in which case the
+        caller falls back to matching by name.
+        """
+        args = node.args[0] if len(node.args) == 1 else node.args
+        if isinstance(args, Node):
+            args = (args,)
+        output_specs = getattr(self.program.graph_signature, "output_specs", None)
+        aligned = output_specs is not None and len(output_specs) == len(args)
+        out_nodes: List[Tuple[Optional[int], Node]] = []
+        for idx, arg in enumerate(args):
+            if isinstance(arg, Node):
+                out_nodes.append((idx if aligned else None, arg))
+        return out_nodes
+
+    def _is_user_output_slot(self, idx: Optional[int]) -> Optional[bool]:
+        """
+        Whether the output slot at `idx` is a user output, or None if unknown.
+        """
+        if idx is None:
+            return None
+        output_specs = getattr(self.program.graph_signature, "output_specs", None)
+        if output_specs is None:
+            return None
+        return output_specs[idx].kind == OutputKind.USER_OUTPUT
+
     def process_output_node(self, node: Node) -> None:
-        for out_node in node.all_input_nodes:
+        # Names already emitted for a buffer mutation that aliases a user
+        # output; see the fallback branch below.
+        emitted_mutation_aliases: set[str] = set()
+        for idx, out_node in self._output_nodes_in_order(node):
             if out_node not in self.node_to_value_ids:
                 raise AssertionError(
                     "Cannot find input to output node in node_to_value_ids. This means "
                     "the output node is being serialized before its corresponding "
                     "internal node which is not allowed."
                 )
-            # Mutable buffers outputs are not included as an output to the
-            # delegate call. Skip marking them as an output.
+            # A mutation whose buffer is aliased to its input is applied in
+            # place, so its slot is not an output of the delegate call. Decide
+            # per slot rather than per node: the mutation and a user output can
+            # be the same node, and matching by name alone would either keep
+            # both or drop both.
+            #
+            # Only the aliased case is filtered here. Without aliasing the
+            # mutation still needs a slot to carry the new buffer value back,
+            # so the old rule stands: dropping the slot would leave the graph
+            # accepted but never updating the buffer, which is worse than the
+            # argument-count rejection it would otherwise get.
             if out_node.name in self.buffer_mutation_inputs:
-                if out_node.name not in self.buffer_mutation_user_outputs:
-                    continue
+                is_user_output = self._is_user_output_slot(idx)
+                if is_user_output is not None:
+                    if not is_user_output:
+                        continue
+                else:
+                    if out_node.name not in self.buffer_mutation_user_outputs:
+                        continue
+                    # Without the signature to separate the slots, the mutation
+                    # and the user output are indistinguishable occurrences of
+                    # one node, and together they get a single slot.
+                    if out_node.name in emitted_mutation_aliases:
+                        continue
+                    emitted_mutation_aliases.add(out_node.name)
             elif is_mutable_buffer_node(out_node, self.program):
                 continue
 
 
@@ -14,6 +14,7 @@
 
 import executorch.backends.vulkan.custom_ops_lib  # noqa: F401
 import torch
+from executorch.backends.vulkan.partitioner.vulkan_partitioner import VulkanPartitioner
 from executorch.backends.vulkan.serialization import (
     vulkan_graph_builder as graph_builder_module,
 )
@@ -34,6 +35,7 @@
     serialize_vulkan_graph,
     VulkanDelegateHeader,
 )
+from executorch.exir import to_edge_transform_and_lower
 
 
 class TestSerialization(unittest.TestCase):
@@ -168,6 +170,48 @@ def test_alias_buffer_mutations_preserves_shared_user_output(self) -> None:
                     [builder.node_to_value_ids[mutation]],
                 )
 
+    def test_mutation_aliasing_user_output_gets_one_slot(self) -> None:
+        # A mutated buffer returned through a view: once the view is removed
+        # the mutation and the user output are the same node. With aliasing on
+        # the mutation is applied in place and only the user output takes a
+        # slot; without it the mutation still needs a slot to carry the new
+        # value back, and the graph is left to be rejected rather than silently
+        # skipping the state update.
+        class Model(torch.nn.Module):
+            def __init__(self) -> None:
+                super().__init__()
+                self.register_buffer("state", torch.zeros(2, 48))
+
+            def forward(self, x):
+                self.state.add_(x)
+                return self.state.view(2, 48)
+
+        for alias, expected_slots in ((True, 1), (False, 2)):
+            with self.subTest(alias_buffer_mutations=alias):
+                captured: List[int] = []
+                original = graph_builder_module.VkGraphBuilder.build_graph
+
+                def spy(builder_self, _original=original, _captured=captured):
+                    graph = _original(builder_self)
+                    _captured.append(len(graph.output_ids))
+                    return graph
+
+                graph_builder_module.VkGraphBuilder.build_graph = spy
+                try:
+                    program = torch.export.export(
+                        Model(), (torch.ones(2, 48),), strict=True
+                    )
+                    to_edge_transform_and_lower(
+                        program,
+                        partitioner=[
+                            VulkanPartitioner({"alias_buffer_mutations": alias})
+                        ],
+                    ).to_executorch()
+                finally:
+                    graph_builder_module.VkGraphBuilder.build_graph = original
+
+                self.assertEqual(captured, [expected_slots])
+
     def _generate_random_const_tensors(self, num_tensors: int) -> List[torch.Tensor]:
         """
         Helper function to generate `num_tensor` buffers of random sizes and random contents,
 
@@ -63,9 +63,12 @@ def wrapper(*args, **kwargs):
 
 
 def lower_module(
-    model: torch.nn.Module, sample_inputs: Tuple[torch.Tensor], dynamic_shapes=None
+    model: torch.nn.Module,
+    sample_inputs: Tuple[torch.Tensor],
+    dynamic_shapes=None,
+    compile_options=None,
 ) -> EdgeProgramManager:
-    compile_options = {}
+    compile_options = dict(compile_options or {})
     if dynamic_shapes is not None:
         compile_options["require_dynamic_shapes"] = True
 
@@ -251,6 +254,7 @@ def lower_module_and_test_output(
         test_inputs=None,
         first_output_only=False,
         expect_no_delegates=False,
+        compile_options=None,
     ):
         """
         Helper testing function that takes a torch.nn.Module and lowers it to Vulkan with
@@ -262,7 +266,12 @@ def lower_module_and_test_output(
         model.eval()
         model(*sample_inputs)
 
-        edge_program = lower_module(model, sample_inputs, dynamic_shapes=dynamic_shapes)
+        edge_program = lower_module(
+            model,
+            sample_inputs,
+            dynamic_shapes=dynamic_shapes,
+            compile_options=compile_options,
+        )
 
         et_program = edge_program.to_executorch()
 
@@ -1314,6 +1323,84 @@ def forward(self, x):
             sample_inputs,
         )
 
+    def test_vulkan_backend_redundant_view_to_output(self):
+        # Returning a value and a redundant view of it: once the view is
+        # removed, both outputs are the same node. The serializer must still
+        # emit two output ids, or the runtime's argument count check fails.
+        class RedundantViewToOutputModule(torch.nn.Module):
+            def forward(self, x):
+                y = x + 1
+                return y, y.view(2, 48)
+
+        sample_inputs = (torch.randn(size=(2, 48), dtype=torch.float32),)
+
+        self.lower_module_and_test_output(
+            RedundantViewToOutputModule(),
+            sample_inputs,
+        )
+
+    def test_vulkan_backend_duplicate_output(self):
+        # The same guarantee without any view involved: `all_input_nodes`
+        # de-duplicates, so this loses an output slot too.
+        class DuplicateOutputModule(torch.nn.Module):
+            def forward(self, x):
+                y = x + 1
+                return y, y
+
+        sample_inputs = (torch.randn(size=(2, 48), dtype=torch.float32),)
+
+        self.lower_module_and_test_output(
+            DuplicateOutputModule(),
+            sample_inputs,
+        )
+
+    def test_vulkan_backend_buffer_mutation_aliasing_user_output(self):
+        # A mutated buffer returned through a redundant view, with the mutation
+        # aliased onto its input. Once the view is removed the buffer-mutation
+        # slot and the user output are the same node, but only the user output
+        # gets a slot in the delegate call, so keeping both would leave the
+        # serialized graph expecting one argument more than the call provides.
+        #
+        # Run it twice: the state has to carry over, which is what says the
+        # mutation is really being applied in place rather than quietly
+        # dropped along with its output slot.
+        class MutationAliasModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.register_buffer("state", torch.zeros(2, 48))
+
+            def forward(self, x):
+                self.state.add_(x)
+                return self.state.view(2, 48)
+
+        sample_inputs = (torch.ones(size=(2, 48), dtype=torch.float32),)
+        test_inputs = [(torch.ones(size=(2, 48), dtype=torch.float32),)]
+
+        self.lower_module_and_test_output(
+            MutationAliasModule(),
+            sample_inputs,
+            test_inputs=test_inputs,
+            compile_options={"alias_buffer_mutations": True},
+        )
+
+    def test_vulkan_backend_view_chain_collapsing_to_input_shape(self):
+        # A chain of views whose net effect is the original shape. Fusing the
+        # chain leaves a view onto the shape it started from, which the
+        # redundant-op sweep then removes; the output count must survive both
+        # rewrites.
+        class ViewChainModule(torch.nn.Module):
+            def forward(self, x):
+                y = x + 1
+                z = y.view(4, 24).view(8, 12).view(2, 48)
+                return y, z
+
+        sample_inputs = (torch.randn(size=(2, 48), dtype=torch.float32),)
+
+        self.lower_module_and_test_output(
+            ViewChainModule(),
+            sample_inputs,
+        )
+
     def test_vulkan_backend_view_int(self):
         class ViewModule(torch.nn.Module):
             def __init__(self):
 
@@ -5,6 +5,9 @@
 
 from executorch.backends.vulkan._passes.conv1d_as_conv2d import Conv1dAsConv2dPass
 from executorch.backends.vulkan._passes.fuse_patterns import FusePatternsPass
+from executorch.backends.vulkan._passes.remove_redundant_ops import (
+    RemoveRedundantOpsTransform,
+)
 
 from executorch.exir import EdgeCompileConfig, EdgeProgramManager, to_edge
 
@@ -877,3 +880,60 @@ def forward(self, x):
 
         gm = ep.graph_module
         self.assertEqual(op_node_count(gm, "q8ta_pixel_shuffle.default"), 0)
+
+    def test_remove_same_shape_view_copy(self):
+        """A view onto the shape it already has is dropped."""
+
+        class SameShapeViewModule(torch.nn.Module):
+            def forward(self, x):
+                # Two views that cancel out. FuseViewCopyTransform collapses the
+                # chain into a single view back to the original shape, which is
+                # what leaves a redundant node behind in a real graph.
+                return (x.view(4, 24).view(2, 48) + 1.0).view(2, 48)
+
+        model = SameShapeViewModule()
+        inputs = (torch.rand(size=(2, 48), dtype=torch.float32),)
+        program = torch.export.export(model, inputs)
+        edge_program = to_edge(
+            program, compile_config=EdgeCompileConfig(_check_ir_validity=False)
+        )
+        ep = edge_program._edge_programs["forward"]
+
+        before = op_node_count(ep.graph_module, "view_copy.default")
+        self.assertGreater(before, 0)
+
+        RemoveRedundantOpsTransform().call(ep.graph_module)
+        gm = ep.graph_module
+        self.assertLess(op_node_count(gm, "view_copy.default"), before)
+
+        # Every view that survived changes the shape.
+        for node in gm.graph.nodes:
+            if get_target_canonical_name(node) == "view_copy.default":
+                self.assertNotEqual(
+                    node.args[0].meta["val"].shape, node.meta["val"].shape
+                )
+
+        self.assertTrue(torch.allclose(ep.module()(*inputs), model(*inputs)))
+
+    def test_rank_changing_view_copy_is_kept(self):
+        """A view that changes the shape must survive.
+
+        Its consumers read their argument's shape, so removing it makes them see
+        the wrong rank even when both shapes occupy the same image extents.
+        """
+
+        class RankChangeModule(torch.nn.Module):
+            def forward(self, x):
+                return x.view(1, 2, 48) + 1.0
+
+        model = RankChangeModule()
+        inputs = (torch.rand(size=(2, 48), dtype=torch.float32),)
+        program = torch.export.export(model, inputs)
+        edge_program = to_edge(
+            program, compile_config=EdgeCompileConfig(_check_ir_validity=False)
+        )
+        ep = edge_program._edge_programs["forward"]
+
+        before = op_node_count(ep.graph_module, "view_copy.default")
+        RemoveRedundantOpsTransform().call(ep.graph_module)
+        self.assertEqual(op_node_count(ep.graph_module, "view_copy.default"), before)
@@ -199,6 +199,12 @@ def preprocess(  # noqa: C901
                 SqueezeUnsqueezeInputs(),
                 FuseViewCopyTransform(),
                 ViewCopyToSqueezeUnsqueezePass(),
+                # Again: the three passes above rewrite views, and collapsing a
+                # chain of them can leave a view onto the shape it started from.
+                # Those reach the runtime as a shader that reads every texel and
+                # writes it back, and the earlier run happened before they were
+                # created.
+                RemoveRedundantOpsTransform(),
             ],
         )