Skip to content
Related Articles

Related Articles

Orbit counting theorem or Burnside’s Lemma
  • Last Updated : 25 Jan, 2021

Burnside’s Lemma is also sometimes known as orbit counting theorem. It is one of the results of group theory. It is used to count distinct objects with respect to symmetry. It basically gives us the formula to count the total number of combinations, where two objects that are symmetrical to each other with respect to rotation or reflection are counted as a single representative.

Therefore, Burnside Lemma’s states that total number of distinct object is: \sum_{k=1}^{N} \frac{c(k)}{N}
where:  

  • c(k) is the number of combination that remains unchanged when Kth rotation is applied, and
  • N is the total number of ways to change the position of N elements.

For Example:
Let us consider we have a necklace of N stones and we can color it with M colors. If two necklaces are similar after rotation then the two necklaces are considered to be similar and counted as one different combination. Now Let’s suppose we have N = 4 stones with M = 3 colors, then

Since we have N stones, therefore, we have N possible variations of each necklace by rotation: 



Observations: 

  1. There are N ways to change the position of necklace as we can rotate it by 0 to N – 1 times.
  2. There are M^{N}       ways to color a necklace. If the number of rotation is 0, then all M^{N}       ways remains different.
  3. If the number of rotation is 1, then there in only M necklaces which will be different out of all M^{N}       ways.
  4. Generally if the number of rotation is KM^{gcd(K, N)}       necklaces will remain sames out of all M^{N}       ways.

Therefore for total number of distinct necklaces of N stones after coloring with M colors is the summation of all the distinct necklaces at each rotation. It is given by: 
Total Distinct Ways = \sum_{i=0}^{N-1} \frac{M^{gcd(i, N))}}{N}

Below is the implementation of the above approach: 

C++




// C++ program for implementing the
// Orbit counting theorem
// or Burnside's Lemma
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find result using
// Orbit counting theorem
// or Burnside's Lemma
void countDistinctWays(int N, int M)
{
 
    int ans = 0;
 
    // According to Burnside's Lemma
    // calculate distinct ways for each
    // rotation
    for (int i = 0; i < N; i++) {
 
        // Find GCD
        int K = __gcd(i, N);
        ans += pow(M, K);
    }
 
    // Divide By N
    ans /= N;
 
    // Print the distinct ways
    cout << ans << endl;
}
 
// Driver Code
int main()
{
 
    // N stones and M colors
    int N = 4, M = 3;
 
    // Function call
    countDistinctWays(N, M);
 
    return 0;
}

Java




// Java program for implementing the
// Orbit counting theorem
// or Burnside's Lemma
class GFG{
 
static int gcd(int a, int b)
{
    if (a == 0)
        return b;
         
    return gcd(b % a, a);
}
 
// Function to find result using
// Orbit counting theorem
// or Burnside's Lemma
static void countDistinctWays(int N, int M)
{
    int ans = 0;
 
    // According to Burnside's Lemma
    // calculate distinct ways for each
    // rotation
    for(int i = 0; i < N; i++)
    {
        // Find GCD
        int K = gcd(i, N);
        ans += Math.pow(M, K);
    }
 
    // Divide By N
    ans /= N;
 
    // Print the distinct ways
    System.out.print(ans);
}
 
// Driver Code
public static void main(String []args)
{
     
    // N stones and M colors
    int N = 4, M = 3;
 
    // Function call
    countDistinctWays(N, M);
}
}
 
// This code is contributed by rutvik_56

C#




// C# program for implementing the
// Orbit counting theorem
// or Burnside's Lemma
using System;
class GFG
{
static int gcd(int a, int b)
{
    if (a == 0)
        return b;       
    return gcd(b % a, a);
}
 
// Function to find result using
// Orbit counting theorem
// or Burnside's Lemma
static void countDistinctWays(int N, int M)
{
    int ans = 0;
 
    // According to Burnside's Lemma
    // calculate distinct ways for each
    // rotation
    for(int i = 0; i < N; i++)
    {
        // Find GCD
        int K = gcd(i, N);
        ans += (int)Math.Pow(M, K);
    }
 
    // Divide By N
    ans /= N;
 
    // Print the distinct ways
    Console.Write(ans);
}
 
// Driver Code
public static void Main(string []args)
{
     
    // N stones and M colors
    int N = 4, M = 3;
 
    // Function call
    countDistinctWays(N, M);
}
}
 
// This code is contributed by pratham76
Output: 
24

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :