I’m trying to get my head around why the third option below still needs the union. Are there inputs other than X: float, alpha: float that would return a tuple? Or does the checker check the float, float combination against both because floats are array-like and the checker doesn’t stop after finding the precise match? Or something else?

ArrayLike is a fair bit broader than I would actually like in many cases. Numpy (understandably) does not provide all of its building blocks as public apis, though, so narrowing it would essentially mean reimplementing or vendoring a lot of the machinery. But I suspect there are things that do qualify under arraylike that may not qualify as Sequence (particularly things that provide a __array__ method, though probably still inadvisable to make such a thing that isn't considered a sequence)

Mypy does not like when multiple signatures are given that are incompatible, though and float is included in arraylike, so it's output must also be in the return type.

One option would be to make the fallback Any so that users won't have to deal with a union return type but mypy also doesn't complain. It's a bit of a cop out answer, but sometimes best for situations where the return type is known but cannot be differentiated by input types (in this case because we want the catch all arraylike to be sure we didn't miss anything)

The other aspect I didn't fully think about was if other scalars could be passed, though pretty sure it essentially is floats (and int I guess, but type checkers accept int when typed as float)

TLDR it's a conservative catch all that probably isn't going to be selected in most use cases, but needs to be consistent with the other signature options