Solving Nested Modulus Equations

$x \% 2 = 1$

The above equation is pretty easy to solve, it just means that x is any value that when you divide by 2, gives a remainder of 1. x is all odd numbers. The more formal answer is:

$x \equiv 1 + 2\mathbb{Z}$

That reads as “x is equivalent to 1 plus 2 times any integer”. x has infinitely many solutions, so long as they fit that constraint.

That’s easy enough to figure out, but how would you solve this equation?

$(x \% 5) \%2 = 1$

or this one?

$((x \% 7) \% 5) \%2 = 1$

One Level (Simple Case)

There is something called the quotient remainder theorem that lets us change an equation like this:

$A \% B = C$

Into one like this:

$A \equiv C + B \mathbb{Z}$

The Z means “all integers” which implies that there are infinitely many solutions to A. This reads as “A is equivelant to C plus B times any integer”.

Let’s work out a couple examples.

$x \% 5 = 3$

That transforms to:

$x \equiv 3 + 5 \mathbb{Z}$

If you try plugging any positive or negative integer in place of Z, you’ll see that you get a number that satisfies the first equation.

Here’s another one:

$x \% 538 = 211$

That transforms to:

$x \equiv 211 + 538 \mathbb{Z}$

Once again you can plug any positive or negative integer in for Z and get a value for x that satisfies the original equation.

Pretty easy and pretty handy right? Let’s get a little more complex.

Two Levels

Let’s say you want to solve this equation from the intro.

$(x \% 5) \%2 = 1$

The first thing you might do is transform it to the below.

$x \% 5 \equiv 1 + 2 N_1$ where $N_1 \in \mathbb{Z}$.

What now? Can we transform it again? If we do, we get this:

$x \equiv 1 + 2 N_1+ 5 N_2$ where $N_i \in \mathbb{Z}$.

plugging 1 in for the N1 and N2, we get 8, which does satisfy the original equation.

If we plug 3 in for N1 and 1 in for N2 though, we get 12 which DOESN’T satisfy the original equation. What gives??

Well it turns out there are subtle restrictions on our equations that got lost in the shuffle. Let’s start over…

$(x \% 5) \%2 = 1$

In effect, what that equation says is “Something divided by two gives a remainder of 1” where the something happens to be x % 5, but we don’t really care about what the something actually is right now.

The equation also implies that the right side of the equation is a value modulo two, and it’s only valid values are {0,1}. Another way to write this is to say that the right side $\in \mathbb Z_2$ which reads as “in all integers mod 2”.

1 is obviously in the set of valid values {0,1}, so we don’t need any special notation just yet, but let’s keep it in mind as we move onto the next step.

$x \% 5 \equiv 1 + 2 \mathbb Z$

The above says that x divided by 5 gives a remainder that is 1 plus two times all integers. However there is a catch. There right side of the equation is a mod 5 value, which means it’s only valid values are {0,1,2,3,4}. In other words, the right side of the equation is $\in \mathbb Z_5$.

This has an effect of implicitly limiting the valid values that we can plug in to Z. It limits it to values of Z where 1+2*Z is in {0,1,2,3,4}. Let’s write this out a little more formally.

$x \% 5 \equiv a$ where $a = 1 + 2 \mathbb Z$ and $a \in \mathbb Z_5$

Let’s transform the equation again to solve for x:

$x \equiv a + 5\mathbb Z$ where $a = 1 + 2 \mathbb Z$ and $a \in \mathbb Z_5$

Note that there is no modulus on the left side of the equation now, so the right side of the equation is unlimited into the valid values it can have.

How do we use this resulting formula though to find valid values of x?

First we figure out the valid values of a. $a = 1 + 2 \mathbb Z$ where $a \in \mathbb Z_5$, so it’s only valid values have to be a subset of {0,1,2,3,4}.

Plugging a -1 in for Z, we get a value for a of -1, which isn’t a valid answer so we throw it away.

Plugging a 0 in for Z, we get a value for a of 1. That is a valid answer so we keep it!

Plugging a 1 in gives us 3 which is valid, so we keep that too.

Plugging a 2 in gives us a value of 5, which isn’t valid, so we throw it away and know that we are done.

Our values for a are {1,3}.

$x \equiv a + 5\mathbb Z$

Plugging in each value of a means that we get two equations as a solution for x. Valid values of x are the union of these two lists – both equations give valid answers.

$x \equiv 1 + 5\mathbb Z$
$x \equiv 3 + 5\mathbb Z$

The first equation gives us values of {…, -4, 1, 6, 11, …}
The second equation gives us values of {…, -2, 3, 8, 13, …}

Taking the union of those, our solutions for x are:
{…, -4, -2, 1, 3, 6, 8, 11, 13, …}

If you plug those into the original equation $(x \% 5) \%2 = 1$, you’ll see that they are valid solutions! Those equations also represent ALL solutions, so they aren’t only valid, they are also complete.

Let’s step it up just one more notch.

Three Levels (Boss Mode)

Let’s solve the hardest equation from the intro:

$((x \% 7) \% 5) \%2 = 1$

This starts off just like the two leveled equation. Something on the left mod 2 is equation to 1. The 1 on the right side is $\in \mathbb Z_2$, but since that’s obviously true for this constant, we don’t need to do anything special. So, we transform it to the below:

$(x \% 7) \% 5 \equiv a$
$a = 1 + 2 \mathbb Z$
$a \in \mathbb Z_5$

Then we do another transformation:
$x \% 7 \equiv b$
$b = a + 5 \mathbb Z$
$a = 1 + 2 \mathbb Z$
$a \in \mathbb Z_5$
$b \in \mathbb Z_7$

Then for the last transformation, we get this:
$x \equiv b + 7 \mathbb Z$
$b = a + 5 \mathbb Z$
$a = 1 + 2 \mathbb Z$
$a \in \mathbb Z_5$
$b \in \mathbb Z_7$

Now that we have our equations worked out, we need to start finding out what the values actually are. We start with a because it’s what b and x are based on, and is made up of constants. We get {1,3} again as the valid values of a. That gives us:
$x \equiv b + 7 \mathbb Z$
$b = a + 5 \mathbb Z$
$a = [1,3]$
$b \in \mathbb Z_7$

Now we want to plug each value of a into b and find all the valid values for b. When we plug 1 into b for a, it becomes $b = 1 + 5 \mathbb Z$, $b \in \mathbb Z_7$. The valid values for that are {1,6}.

When we plug 3 into b for a, it becomes $b = 3 + 5 \mathbb Z$, $b \in \mathbb Z_7$. The only valid value there is {3}.

That means that our valid values for b are {1,3,6}. It’s the union of the valid values we found for each value of a.

That makes our equations into this:
$x \equiv b + 7 \mathbb Z$
$b = [1,3,6]$

If we plug those values of b into the equation for x, we get these three equations:

$x \equiv 1 + 7 \mathbb Z$
$x \equiv 3 + 7 \mathbb Z$
$x \equiv 6 + 7 \mathbb Z$

The first equation gives us some x values of {…, -6, 1, 8, 15, …}. The second equation gives us x values of {…, -4, 3, 10, 17, …}. The third equation gives us x values of {…, -1, 6, 13, 20, …}.

Taking the union of all of those, we get…
{…, -6, -4, -1, 1, 3, 6, 8, 10, 13, 15, 17, 20, …}

If you plug those numbers into the original equation $((x \% 7) \% 5) \%2 = 1$, you can see that they are valid solutions!

When you are performing this algorithm, if you ever hit a case where there are no valid answers in one of the steps – like say, there were no valid answers for equation b in the above – that means that there is no solution to your equation.

Sample Code

Since solving these equations can be pretty manual and tedious, here is some code that can solve these equations for you. If you were confused at all by the explanation above, the code may also be able to show you how it works better, especially if you step through it and see what it’s doing.

#include <stdio.h>
#include <array>
#include <vector>

//=================================================================================
void WaitForEnter()
{
printf("nPress Enter to quit");
fflush(stdin);
getchar();
}

//=================================================================================
{
int Z = 0;
while (1)
{
int value = multiply * Z + add;
if (value < mod)
solutions.push_back(value);
else
return;
++Z;
}
}

//=================================================================================
{
std::for_each(
{
}
);
}

//=================================================================================
int main(int argc, char **argv)
{
// a,b,c,d...
// ((x % a) % b) % c = d
// etc.
//const int c_values[] = {7, 5, 2, 1};
const int c_values[] = { 12, 9, 7, 5, 3, 2 };
const size_t c_numValues = sizeof(c_values) / sizeof(c_values[0]);

// print the equation
printf("Solving for x:n");
for (size_t i = 0; i < c_numValues - 1; ++i)
printf("(");
printf("x");
for (size_t i = 0; i < c_numValues - 1; ++i)
printf(" %% %i)", c_values[i]);
printf(" = %inn", c_values[c_numValues-1]);

// print the solution equations
for (size_t i = 0; i < c_numValues - 2; ++i)
{
char eqn = i > 0 ? 'A' + i - 1 : 'x';
char eq = i > 0 ? '=' : 0xF0;

printf("%c %c %c + %i*Z", eqn, eq, 'B' + i - 1, c_values[i]);
if (i > 0)
printf(" (in Z_%i)n", c_values[i-1]);
else
printf(" (in Z)n");
}
printf("%c = %i + %i*Z (in Z_%i)nn", 'A' + c_numValues - 2 - 1, c_values[c_numValues - 1], c_values[c_numValues - 2], c_values[c_numValues - 3]);

// gather up the permutation of solutions for each equation, starting with the lowest equation which has only constants
std::array<std::vector<int>, c_numValues - 2> solutions;
AddSolutions(solutions[c_numValues - 3], c_values[c_numValues - 1], c_values[c_numValues - 2], c_values[c_numValues - 3]);
for (size_t i = c_numValues - 3; i > 0; --i)

// Detect empty set
if (solutions[0].size() == 0)
{
printf("No solutions!n");
WaitForEnter();
return 0;
}

// Print the more specific solution equations
printf("x = ");
for (size_t i = 0, c = solutions[0].size(); i < c; ++i)
{
if (i < c - 1)
printf("%c U ", 'a' + i);
else
printf("%cn", 'a' + i);
}
std::sort(solutions[0].begin(), solutions[0].end());
for (size_t i = 0, c = solutions[0].size(); i < c; ++i)
printf("%c = %i + %iZn", 'a' + i, solutions[0][i], c_values[0]);

// Print specific examples of solutions (first few numbers in each)
std::vector<int> xValues;
printf("n");
for (size_t i = 0, c = solutions[0].size(); i < c; ++i)
{
printf("%c = {..., ", 'a' + i);
for (int z = 0; z < 3; ++z)
{
printf("%i, ", solutions[0][i] + z * c_values[0]);
xValues.push_back(solutions[0][i] + z * c_values[0]);
}
printf("...}n");
}

// Show the list of specific values of X
std::sort(xValues.begin(), xValues.end());
printf("nx = {..., ");
std::for_each(xValues.begin(), xValues.end(), [](int v) {printf("%i, ", v); });
printf("...}n");

// Test the solutions to verify that they are valid!
bool valuesOK = true;
for (size_t i = 0, c = xValues.size(); i < c; ++i)
{
int value = xValues[i];
for (size_t j = 0; j < c_numValues - 1; ++j)
value = value % c_values[j];

if (value != c_values[c_numValues - 1])
{
printf("Solution %i is invalid!!n", xValues[i]);
valuesOK = false;
}
}
if (valuesOK)
printf("nAll solutions shown tested valid!n");

WaitForEnter();
return 0;
}


Here’s an example run, where it solves a 5 level equation.