If you've ever taken some lessons on competitive programming, chances are that you have already heard about one of the most famous formula: the Möbius inversion. This article is aimed to provide some basic insight on what is the Möbius inversion, as well as how to apply it in various programming tasks.

# Prequisite

If you are not familiar with the linear sieve and multiplicative functions, it is recommended that you read about them first here.

I will introduce some frequently used notations and lemmas first.

## Notation

- [
*P*] refers to the boolean expression, i.e. [*P*] = 1 when*P*is true, and 0 otherwise. - ⌊
*x*⌋ refers to rounding*x*down to the nearest integer. Thus refers to the integer division. *d*|*n*means that d can divide n (without a remainder).

The following functions are all multiplicative functions, where *p* is a prime number and *k* is a positive integer.

- The constant function
*I*(*p*^{k}) = 1. - The identity function
*Id*(*p*^{k}) =*p*^{k}. - The power function
*Id*_{a}(*p*^{k}) =*p*^{ak}, where*a*is constant. - The unit function .
- The divisor function , denoting the sum of the
*a*-th powers of all the positive divisors of the number. - The Möbius function μ(
*p*^{k}) = [*k*= 0] - [*k*= 1]. - The Euler's totient function φ(
*p*^{k}) =*p*^{k}-*p*^{k - 1}.

## Lemma

I have some my unofficial names for these frequently used conclusions. If you happen to know any more commonly used name for them, you are more than welcome to tell me.

- (
**The integer division lemma**) For every positive integer*p*,*q*and*r*, .

Proof: We know that . Hence . Since the fraction part of cannot exceed , we achieve the conclusion.

- (
**The harmonic lemma**) Consider the harmonic sequence on integer division .

- The sequence is non-increasing, and there are at most different elements.
- The sum of the sequence is approximate to .

Proof: Denote . For every *i* not exceeding , there will be no more than values in the domain of *d*(*i*), so there can be at most different values for *d*(*i*). For the rest part of *i* greater than , we can infer that and is a positive integer, so there can be at most different values for *d*(*i*). Therefore we know that there are at most different elements in the sequence.

Since the Euler–Mascheroni constant states that , we know that , so the sum of the original sequence is approximate to .

Moreover, it is actually possible to exploit the property that the sequence has at most different elements, and write a loop that runs in complexity to iterate through every possible value of *d*(*i*), using the fact that the greatest integer *x* satisfying *d*(*x*) = *d*(*i*) is . The piece of code below demonstrates one way to program it.

```
for (int i = 1, la; i <= n; i = la + 1) {
la = n / (n / i);
//n / x yields the same value for i <= x <= la.
}
```

- (
**The transitive property of multiplicative functions**)

- If both
*f*(*x*) and*g*(*x*) are multiplicative, then*h*(*x*) =*f*(*x*)*g*(*x*) is also multiplicative. - If both
*f*(*x*) and*g*(*x*) are multiplicative, then their Dirichlet convolution is also multiplicative. Specifically, if*f*(*x*) is multiplicative, is also multiplicative.

The proof is more mathematical, which I will skip here.

# What is the Möbius inversion?

According to Wikipedia, the Möbius inversion states that:

If for every positive integer *n*, then , where μ(*x*) is the Möbius function, which is multiplicative and satisfies *f*(1) = 1, *f*(*p*) = - 1, *f*(*p*^{k}) = 0 for any prime number *p* and any integer *k* ≥ 2. ( *It is worth noting that you can pre-compute all values of the Möbius function from 1 to n using the linear sieve.* )

However, the definition alone does not mean much (unless the problem statement explicitly gives you something like . In that case, well...). There is one important property that is probably more useful than the definition:

In order to prove this property, we have to use the transitive property of multiplicative functions to show that is multiplicative. After that, we can see *f*(1) = 1 and *f*(*p*^{k}) = 0, which means *f*(*x*) = ε(*x*). Now you may ask: why is this property important? I think it is best to show the reasons in some basic examples below.

**Example 1.** Find out the number of co-prime pairs of integer (*x*, *y*) in range [1, *n*].

**Solution 1.** Notice that the question is the same as asking you the value of

Now apply the Möbius inversion on [*gcd*(*i*, *j*)] = 1, we have

which is the same as

Notice that [*d*|*gcd*(*i*, *j*)] = [*d*|*i*][*d*|*j*]. Therefore

We can change the order of summing things up, so

We know that . Thus

Then we can simply loop through 1 to *n* to compute the formula. While we can optimize this loop to using the harmonic lemma, we still have to use the linear sieve to pre-compute the values of μ(*d*). Therefore, the overall complexity of the algorithm is *O*(*n*).

**Example 2.** Find out the sum of *gcd*(*x*, *y*) for every pair of integer (*x*, *y*) in range [1, *n*] (*gcd*(*x*, *y*) means the greatest common divisor of *x* and *y*).

**Solution 2.** Similar as above, notice that the question is the same as asking you the value of

Let *k* = *gcd*(*i*, *j*). We can then loop for *k* first.

Now assume *i* = *ak*, *j* = *bk*, and then

It can be observed that the last part of the formula is the same as the one in example 1. Applying the same procedure, we have

According to the harmonic lemma, . Therefore, if we compute the sum above with brute force, the overall complexity will be .

This is, however, not the best complexity we can achieve with the Möbius inversion. Now let *l* = *kd*, and we can loop for *l* first.

Applying the transitive property of multiplicative functions, we can see that is multiplicative. Moreover, we have *g*(*p*^{k}) = *p*^{k} - *p*^{k - 1}. If you have somewhat studied about the number theory, you may figure out that *g*(*l*) is actually the Euler's totient function. Regardless of whether you know about the coincidence or not, *g*(*l*) can be pre-computed with the linear sieve, and , which can be simply computed in *O*(*n*) complexity.

**Example 3.** Find out the sum of *lcm*(*x*, *y*) for every pair of integer (*x*, *y*) in range [1, *n*] (*lcm*(*x*, *y*) means the least common multiple of *x* and *y*).

**Solution 3.** Well, we should be pretty familiar with the techniques by now. First of all, the answer should be

Since , let *k* = *gcd*(*i*, *j*). We can then loop for *k* first.

Now assume *i* = *ak*, *j* = *bk*, and then

Now let's proceed to assume *a* = *dp*, *b* = *dq*, then

Now notice , and we have

Now following the example above, let *l* = *kd*, and then

Notice that is also multiplicative, and *g*(*p*^{k}) = *p*^{k} - *p*^{k + 1}. We can pre-compute the values of *g*(*l*) via the linear sieve, and . The overall complexity will be *O*(*n*).

# Practice Problems

## Simple Sum

(Thanks _threat_ for showing me this one!)

## GCD

## Sky Code

# Extensions

It is known that all examples above can be further optimized to . The exact technique will (probably) be introduced in the upcoming article.

*Update: The article introducing the optimization is ready here.*

*Finally, thanks Tommyr7 for his effort in the article!*

Excellent tutorial. If you don't mind can you just write down in 1-2 sentences how to precompute the Mobius function using linear sieve ?

See the example for the Euler's totient function in the linear sieve tutorial.

For the Möbius function the three cases are:

1) if x is prime: mobius[x]=-1 (obiously the number of prime factors of a prime number is odd)

2) x=ip and i%p!=0: mobius[x]=mobius[i]*mobius[j] (since the function is multiplicative)

3) x=ip and i%p==0: mobius[x]=0 (p^2 divides x)

kahe ka excellent.. kuch samjh me aaye.. ye koi kaam ka hi nahi hai.. kahan apply karoge isko bhai

Can you explain how to use Mobius inversion in The GCD problem link given here. I am having problem in using the theory given the that problem.

Step 1: if and only if , and . Using this we can reduce the problem of finding 0 <

x≤b, 0 <y≤dsuch that to the problem of example 1.Step 2: The sum over the interval [

a,b] × [c,d] is the sum over [1,b] × [1,d] minus [1,a- 1] × [1,d] minus [1,b] × [1,c- 1] plus [1,a- 1] × [1,c- 1].`Please notice that, (x=5, y=7) and (x=7, y=5) are considered to be the same.`

How you dealt with the condition that there should be unique pairs?

Firstly, note that a and c are both equal to 1 in the problem statement. Now, let's first handle the corner cases:

Let

m=min(b,d). Ifk= 0 orm<k, the answer is clearly 0.Now, firstly we obtain the answer without worrying about duplicate entries. It'll be computed by the formula given by newCEA.

After this, now let's eliminate all the duplicate values. Firstly, note that the duplicate pairs must have both the values lying within the range [1,

m] because the remaining nos. from the 2 given ranges that are not lying within this range must be present in exactly one of the ranges and therefore cannot contribute to duplicates. LetXbe the answer to the original problem that includes the duplicates entries, i.e., the no. of co-prime pairs between the ranges [1,b] and [1,d]. Now computeY= no. of co-prime pairs where both numbers lie between the range [1,m]. Note that there must be exactly one pair (x,y) wherex=y, and that is (k,k). For all other pairsx≠y, so (x,y) and (y,x) must both appear in the answer as a co-prime pairs, so there are only duplicate values and these are also the only duplicate values present within the ranges [1,b] and [1,d]. So, the final answer is . Here is my solution for this problem as a reference.In your formula, the last must term must be

The max must be replaced with min.

this article is good but i have a big problem : in your example you have range from [1,n] but in many problem we have an array of element.if in example1 we have an array of element (1<=A(i)<=1000000) now how we can find number of Co-prime pair in array with mobius ? how use mobius in problem that given array of element? ***actually i want you prove this with array of element such your proving in three examples that you mentioned above?

how is the greatest integer x satisfying d(x) = d(i) is n/(n/i)?

We know that for two positive integers

a,n:Let's define

a*k<=n<a*k+aa*k<=nanda* (k+ 1) >nand

So, if for a positive integer

x, < x <=But < x <=

This tells us that is the maximum x for which

What is the intended complexity in Sky Code? My N d(N) q solution gets TLE immediately. (N = 10000)

Precomputing the divisors of all numbers from 1 to 10000 gets AC on the problem. Using square root factorization gets TLE.

`Moreover, we have g(p^k) = p^k - p^(k - 1).`

How did you conclude this?Update: I solved it for prime

pand then generalized it for somep^k. Is it the right way?So in example 1, step 2, did he just say that f = f ◦ μ?

How does one conclude from

that

Ah, I see, he just rewrote what was the dirichlet identity.

Duh doy, heh.

Very good tutorial. Thanks a lot!

Here is an easier version of the Sky Code problem. It asks to find co-prime triples, whereas in Sky Code, we are required to find co-prime quadruples (4-tuples).

now i know how bad my math is

how to derive the formula for first question link that you provided..help plz