finding a^b^c^… mod m

Question

I would like to calculate:

a^bcd... mod m

Do you know any efficient way since this number

Answer 1

a^bc mod m = a^{bc mod n} mod m, where n = φ(m) Euler's totient function.

If m is prime, then n = m-1.

Edit: as Nabb pointed out, this only holds if a is coprime to m. So you would have to check this first.

Answer 2

1. Since for any relationship a=x^y, the relationship is invariant with respect to the numeric base you are using (base 2, base 6, base 16, etc).

2. Since the mod N operation is equivalent to extracting the least significant digit (LSD) in base N

3. Since the LSD of the result A in base N can only be affected by the LSD of X in base N, and not digits in higher places. (e.g. 34*56 = 30*50+30*6+50*4+4*5 = 10*(3+50+3*6+5*4)+4*6)

Therefore, from LSD(A)=LSD(X^Y) we can deduce

LSD(A)=LSD(LSD(X)^Y)

Therefore

A mod N = ((X mod N) ^ Y) mod N

and

(X ^ Y) mod N = ((X mod N) ^ Y) mod N)

Therefore you can do the mod before each power step, which keeps your result in the range of integers.

---

This assumes a is not negative, and for any x^y, a^y < MAXINT

---

This answer answers the wrong question. (alex)

Answer 3

Look at the behavior of A^X mod M as X increases. It must eventually go into a cycle. Suppose the cycle has length P and starts after N steps. Then X >= N implies A^X = A^(X+P) = A^(X%P + (-N)%P + N) (mod M). Therefore we can compute A^B^C by computing y=B^C, z = y < N ? y : y%P + (-N)%P + N, return A^z (mod m).

Notice that we can recursively apply this strategy up the power tree, because the derived equation either has an exponent < M or an exponent involving a smaller exponent tower with a smaller dividend.

The only question is if you can efficiently compute N and P given A and M. Notice that overestimating N is fine. We can just set N to M and things will work out. P is a bit harder. If A and M are different primes, then P=M-1. If A has all of M's prime factors, then we get stuck at 0 and P=1. I'll leave it as an exercise to figure that out, because I don't know how.

///Returns equivalent to list.reverse().aggregate(1, acc,item => item^acc) % M
func PowerTowerMod(Link<int> list, int M, int upperB = M)
    requires M > 0, upperB >= M
    var X = list.Item
    if list.Next == null: return X
    var P = GetPeriodSomehow(base: X, mod: M)
    var e = PowerTowerMod(list.Next, P, M)
    if e^X < upperB then return e^X //todo: rewrite e^X < upperB so it doesn't blowup for large x
    return ModPow(X, M + (e-M) % P, M)

Answer 4

Modular Exponentiation is a correct way to solve this problem, here's a little bit of hint:

To find a^bcd % m You have to start with calculating a % m, then a^b % m, then a^bc % m and then a^bcd % m ... (you get the idea)

To find a^b % m, you basically need two ideas: [Let B=floor(b/2)]