a = recursively_remove_getitems(a)
b = recursively_remove_getitems(b)
return op_types.is_fusible(a) and op_types.is_fusible(b)

diff --git a/torch/_functorch/partitioners.py b/torch/_functorch/partitioners.py
index 81e2f297f6f..8c02fb68211 100644
--- a/torch/_functorch/partitioners.py
+++ b/torch/_functorch/partitioners.py
@@ -1293,6 +1293,7 @@ def get_default_op_list() -> OpTypes:
         aten.as_strided,
         aten.permute,
         aten.select,
+        operator.getitem,
     ]
     view_ops = recomputable_view_ops
     default_recomputable_ops += [

import torch
import triton
import triton.language as tl

def test_triton_kernel_not_fusable_with_users():
    @triton.jit
    def _sin_kernel(
        in_ptr0,
        out_ptr,
        out2_ptr,
        n_elements,
        BLOCK_SIZE: "tl.constexpr",
    ):
        pid = tl.program_id(axis=0)
        block_start = pid * BLOCK_SIZE
        offsets = block_start + tl.arange(0, BLOCK_SIZE)
        mask = offsets < n_elements
        x = tl.load(in_ptr0 + offsets, mask=mask)
        output = tl.sin(x)
        tl.store(out_ptr + offsets, output, mask=mask)
        tl.store(out2_ptr + offsets, output, mask=mask)

    from typing import List

    from torch._library import capture_triton, triton_op

    @triton_op("mylib::sin_kernel", mutates_args={})
    def sin_kernel(x: torch.Tensor) -> List[torch.Tensor]:
        n_elements = x.numel()
        out = torch.empty_like(x)
        out2 = torch.empty_like(x)
        capture_triton(_sin_kernel)[(n_elements,)](
            x, out, out2, n_elements, BLOCK_SIZE=4
        )
        return [out, out2]

    class MySin(torch.autograd.Function):
        @staticmethod
        def forward(ctx, x):
            out, saved = tuple(torch.ops.mylib.sin_kernel(x))
            ctx.save_for_backward(x, saved)
            return out

        @staticmethod
        def backward(ctx, grad):
            (x, saved) = ctx.saved_tensors
            return grad * saved.sigmoid() * x

    @torch.compile(backend="aot_eager")
    def f(x):
        return MySin.apply(x)

    x = torch.randn(4, 4, requires_grad=True, device='cuda')
    out = f(x)

test_triton_kernel_not_fusable_with_users()