Dependency injection requires a trade-off between decoupling parts of the code at the expense of increasing its complexity through creating abstractions. So as a rule of thumb, that increase in complexity has to offer benefits that outweigh the costs.
By injecting dependencies that are mutable or have side effects, we gain obvious benefits. The code becomes easier to test as those side-effects can be mocked out. We control which parts of the system have access to those mutating parts, making the code cleaner, easier to understand and easier to maintain. The increased complexity is easily counteracted by those benefits.
But if a dependency is pure, we do not gain any of those benefits, yet we still incur the increased complexity costs. Would you inject
Math.PI (or the equivalent), or access it directly? It's a constant, so there would be no benefit in doing so; it can be made globally accessible. But then surely the same applies to
Math.Max()? It's completely deterministic. There would be no benefit to mocking it; no benefit to swapping it out for another implementation of
Max. So again it's a complexity cost for no gain. So it too should be globally accessible.
Math.Max() globally accessible makes sense. Then likewise, making your
somePureFunction globally accessible also makes complete sense. Injecting it again makes the code more complex with no added benefits.
Of course, it's important to emphasise "pure" here. If your function in any way is non-deterministic, has any sort of side effect or in any way mutates the parameters passed to it, it is not pure and so should not be globally accessible. Inject them. Just don't inject pure functions.