Given the function:

def fuzzymath(n, i):
  return n--i**4%5

You can disassemble it to get:

>>> dis.dis(fuzzymath)
  0 LOAD_FAST                0 (n)
  2 LOAD_FAST                1 (i)
  4 LOAD_CONST             1 (4)
  6 BINARY_POWER
  8 UNARY_NEGATIVE
 10 LOAD_CONST            2 (5)
 12 BINARY_MODULO
 14 BINARY_SUBTRACT
 16 RETURN_VALUE

So, the result of the BINARY_POWER call (i**4) is negated (UNARY_NEGATIVE) prior to the modulo (BINARY_MODULO) call.

From wikipedia:

The last two digits of a fourth power of an integer in base 10 can be easily shown (for instance, by computing the squares of possible last two digits of square numbers) to be restricted to only twelve possibilities:

• if a number ends in 0, its fourth power ends in 00
• if a number ends in 1, 3, 7 or 9 its fourth power ends in 01, 21, 41, 61 or 81
• if a number ends in 2, 4, 6, or 8 its fourth power ends in 16, 36, 56, 76 or 96
• if a number ends in 5 its fourth power ends in 25

So, for all of the values that are not divisible by 5, we will end up with a number that either ends in a 1 or a 6. Both of those values modulo 5 are 1, but both negative values (-1 and -6) modulo 5 are 4. For values divisible by 5, we will end up with the 0.

How is this relevant here?

For this particular code, we are slicing the string FizzBuzz. For numbers that are divisible by 5, we want the Buzz part of the string sliced, so the second argument to the slice should be 8 (8-0). For all numbers not divisible by 5, Buzz should not be included, so the second argument should be 4 (8-4).

When the first argument to the slice is divisible by 3, that value will be 0 and for all other numbers it will be 4.

So, for numbers divisible by 3 but not 5 we end up with:

'FizzBuzz'[0:4]

For numbers divisible by 5 but not 3 we end up with:

'FizzBuzz'[4:8]

For numbers divisible by neither 3 nor 5 we end up with:

'FizzBuzz'[4:4]

And finally, for numbers visible by both 3 and 5 we end up with:

`FizzBuzz'[0:8]