[INTERPRETER] Make int1 add/sub wrap around like the GPU

[ArsalanShakil]

Summary

Fixes #10919.

int1 + int1 produced different results in the interpreter and on the GPU:

• GPU: int1 is a 1-bit integer, so arith.addi wraps mod 2 and True + True == 0.
• Interpreter: binary_op ran numpy bool arithmetic, which is logical/saturating (True + True == True == 1), so it disagreed with the GPU.

As noted by @peterbell10 in the issue, 0 is the intended result (int1 should wrap like any other integer type), so the interpreter is the side to change; the GPU path is unchanged.

This also fixes a related interpreter crash: int1 - int1 previously raised TypeError: numpy boolean subtract ... is not supported, since numpy rejects bool subtraction. It now wraps correctly (matching the GPU).

Change

In InterpreterBuilder.binary_op, when the operand type is int1, compute the op in a wider integer domain (int8) and truncate back to one bit (& 1). This matches the GPU's 1-bit wraparound. Ops whose int1 results are already in {0, 1} (mul, and, or, xor, min, max, comparisons) are unaffected.

Test

test_int1_bin_op_wraparound in test_core.py runs int1 +/- int1 and asserts mod-2 wraparound. Marked @pytest.mark.interpreter so it runs on both the GPU and interpreter paths, pinning them together.

[ArsalanShakil]

Update: fixed the failing interpreter test

The first push failed the integration-tests-nvidia interpret step on both parametrizations of the new test:

• test_int1_bin_op_wraparound[+]: interpreter returned [0, 1, 1, 1] instead of the expected [0, 1, 1, 0]
• test_int1_bin_op_wraparound[-]: interpreter raised TypeError: numpy boolean subtract ... is not supported

Why it was failing. My first version of the fix gated the new behavior on the Triton dtype: if lhs.dtype.scalar == tl.int1. In the interpreter that condition never held for these operands, so the branch was skipped and numpy ran its native bool arithmetic (logical or for +, and an outright error for -). The GPU test passed the whole time, which is what pointed at an interpreter-specific dtype mismatch rather than a problem with the fix itself.

The fix. Key the branch off the actual numpy data instead, which is the ground truth for what the op executes on:

if lhs.data.dtype == np.bool_ and rhs.data.dtype == np.bool_:
    output = (op(lhs.data.astype(np.int8), rhs.data.astype(np.int8)) & 1).astype(np.bool_)
    return TensorHandle(output, tl_dtype)

Computing in int8 and masking back to one bit reproduces the GPU's 1-bit wraparound. Every other op that routes through binary_op with bool operands (==, <, &, |, ^, *, min, max) already produces values in {0, 1}, so the & 1 is a no-op for them and their results are unchanged. The sanitize_overflow path is unaffected because it casts operands to int64 before reaching binary_op, so their data is never bool.

The test is marked @pytest.mark.interpreter, so it now pins the interpreter and GPU paths together for int1 add/sub.