Cube

Solution: Mathematical Derivation

function distinctCubes(numColors) {
    // For a cube with all faces different colors
    // Answer = n! / 24 where n is number of colors
    // For n = 6: 6! / 24 = 720 / 24 = 30

    if (numColors < 6) {
        return 0; // Can't paint all faces different colors
    }

    const factorial = (n) => {
        let result = 1;
        for (let i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    };

    const arrangements = factorial(numColors);
    const rotationalSymmetries = 24;

    return arrangements / rotationalSymmetries;
}

console.log(distinctCubes(6));  // 30
console.log(distinctCubes(7));  // 210 (if we have 7 colors, pick 6)

Enumeration of 24 Rotations

function cubeRotations() {
    const rotations = {
        identity: 1,
        faceRotations90: 6,    // 90° and 270° around x, y, z axes
        faceRotations180: 3,   // 180° around x, y, z axes
        vertexRotations: 8,    // 120° and 240° around 4 diagonals
        edgeRotations: 6       // 180° around 6 edge-midpoint axes
    };

    const total = Object.values(rotations).reduce((a, b) => a + b, 0);

    console.log("Cube rotation symmetries:");
    console.log("  Identity:", rotations.identity);
    console.log("  Face 90°/270°:", rotations.faceRotations90);
    console.log("  Face 180°:", rotations.faceRotations180);
    console.log("  Vertex 120°/240°:", rotations.vertexRotations);
    console.log("  Edge 180°:", rotations.edgeRotations);
    console.log("  Total:", total);

    return total;
}

console.log(cubeRotations());  // 24

Burnside's Lemma Application

function burnsideCube() {
    // For 6 different colors on cube faces
    // Count colorings fixed by each rotation

    const colorings = {
        identity: factorial(6),        // All 720 colorings
        faceRotations90: 0,           // No coloring unchanged by 90° rotation
        faceRotations180: 0,          // No coloring unchanged by 180° face rotation
        vertexRotations: 0,           // No coloring unchanged by vertex rotation
        edgeRotations: 0              // No coloring unchanged by edge rotation
    };

    // Sum of fixed colorings
    const totalFixed =
        1 * colorings.identity +
        6 * colorings.faceRotations90 +
        3 * colorings.faceRotations180 +
        8 * colorings.vertexRotations +
        6 * colorings.edgeRotations;

    // Burnside's formula: Average over group
    const distinct = totalFixed / 24;

    console.log("Burnside's Lemma calculation:");
    console.log(`  Total fixed colorings: ${totalFixed}`);
    console.log(`  Group size: 24`);
    console.log(`  Distinct cubes: ${distinct}`);

    return distinct;
}

function factorial(n) {
    let result = 1;
    for (let i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

console.log(burnsideCube());  // 30

Variation: Repeating Colors Allowed

function distinctCubesWithRepetition(numColors) {
    // If colors can repeat, use full Burnside calculation
    // This is more complex - each rotation type contributes

    const n = numColors;

    // Identity: all n^6 colorings
    const identity = Math.pow(n, 6);

    // Face rotations (90° and 270°): faces must match in groups
    // For 90° rotation around axis: 2 faces on axis (can be any color)
    // + 4 faces around axis (must all be same color)
    const face90 = 6 * n * n * n;  // 6 rotations × n^3

    // Face rotations (180°): opposite faces must match
    const face180 = 3 * Math.pow(n, 3);  // 3 rotations × n^3

    // Vertex rotations: more complex...
    const vertex = 8 * Math.pow(n, 2);  // Simplified

    // Edge rotations
    const edge = 6 * Math.pow(n, 3);

    const totalFixed = identity + face90 + face180 + vertex + edge;
    return totalFixed / 24;
}

// For 6 colors with repetition allowed
console.log(distinctCubesWithRepetition(6));  // Much larger number

Visual Example: Why Rotations Matter

Consider cube with faces colored R,G,B,Y,O,P:

Configuration 1:      Configuration 2:
  Top: R                Top: G
  Bottom: G             Bottom: R
  Front: B              Front: B
  Back: Y               Back: Y
  Left: O               Left: O
  Right: P              Right: P

These are the SAME cube! Just rotated 180° around front-back axis.

So we count them as ONE distinct cube, not two.

Simpler Explanation

Think of fixing one face (say, make top always red). Then you have 5 remaining faces to color with 5 remaining colors.

That's 5! = 120 ways. But you can still rotate around the vertical axis (4 rotations). So:

120 / 4 = 30 distinct cubes.

This matches our answer!

Complexity

Mathematical complexity: Requires group theory understanding
Computation: O(1) - just factorial and division

Common Mistakes

• Forgetting rotations: Saying 720 instead of 30
• Wrong symmetry count: Cube has 24 rotations, not 6
• Not considering all rotation types: Face, vertex, and edge rotations
• Overcounting or undercounting: Missing some symmetries

Related Problems

Necklace problem: How many distinct necklaces with n beads and k colors? (circular symmetry)

Colorings of platonic solids: Tetrahedron (12 symmetries), octahedron (24), dodecahedron (60), icosahedron (60)

Graph automorphisms: Counting distinct graphs up to isomorphism

Follow-Up Questions

Q: What if some colors can repeat?
A: More complex - need full Burnside calculation for each rotation type

Q: What about a tetrahedron?
A: 12 rotations, so 4!/12 = 2 distinct colorings

Q: How to compute programmatically?
A: Generate all permutations, apply rotations, count unique up to rotation