THE MITRE DISSECTION PUZZLE

Vesa Timonen
June 9, 2024

DISSECTION PUZZLE

In a dissection puzzle, a polygon is required to be cut into the minimal number of pieces that can then be reassembled into another polygon. The history of dissection puzzles dates back to Plato's era (427–347 BCE) in ancient Greece. [Wikipedia]

An example of a dissection puzzle is the square trisection, which involves dividing a large square into the fewest polygons possible to create three smaller, identical squares. Historical records trace the first 9-piece solution to around 1000 AD. This was followed by an 8-piece solution circa 1400 AD, a 7-piece solution in 1877, and a groundbreaking 6-piece solution in 1891. [Perigal, 1891] [Blanvillain, 2010]

Dissecting a regular polygons into other regular polygons has been well-studied field. The best-known dissections have been well studied and documented. [Theobald] [Wolfram] [Frederickson, 1997]

THE MITRE PUZZLE

Dissection puzzles gained popularity in the late 19th century when newspapers and magazines began to feature them. Famous puzzle creators Sam Loyd (US) and Henry Dudeney (UK) frequently included these puzzles into their columns. [Wikipedia]

The early version of the mitre puzzle, dating back to the early 19th century, presents the challenge of cutting a mitre shape into four parts of same size and shape. That is actually impossible with exact measures and interconnected pieces. The intended solution utilized corner-connected pieces. [Hoffman, 1893] [Dudeney, 1917]

In 1901, Sam Loyd introduced a variation of the mitre puzzle, asking solver to divide the mitre shape into fewest pieces possible which will fit together and form a square. He also revealed his 4-piece solution. [Loyd, 1901a] [Loyd, 1901b]

However, in 1911, Henry Dudeney demonstrated that Loyd's solution was faulty and then presented his own 5-piece solution. [Dudeney, 1911a] [Dudeney, 1911b]

The quest for a 4-piece solution has continued until recently (May 2024). This solution has one piece (green) that is flipped over, leaving room for further improvement.



THE SOFTWARE

An optimizer software was developed to solve dissection puzzles:
  1. The software receives a dissection puzzle as input, consisting of two polygons (provided as lists of vertex points) and the number of allowed cuts.

  2. It begins by randomizing the initial cuts and dissection fitness value is calculated comparing polygons between two dissections using turning function.

  3. Next, the software optimizes the dissection fitness by making incremental adjustments to the cut lines. This process employs simulated annealing to progressively refine the cuts. If the fitness value becomes sufficiently small, the dissection is considered a potential solution.
All calculations are performed numerically and must be verified manually. Currently, verification is done using geometric constraint-solving software, such as the sketch tool in a CAD program. There is a small chance that some solutions may not be mathematically accurate, even though they are numerically very close.

THE 4-PIECE SOLUTION

In the solution, one piece (green) is flipped over. To allow this, we must assume that the problem is in 3D, as flipping over is a 3D operation.

In the 4-piece solution, the cutting lines can be adjusted smoothly to generate infinitely many solutions to the mitre puzzle.


The exact coordinates of the 4-piece solution. 


                    double a = 2.0 / sqrt(3.0) - 1.0;
                    double b = 2.0 - sqrt(3.0);
                    double c = 1.0 - 1.0 / sqrt(3.0);
                    double d = sqrt(3.0) - 1.0;
                    double e = 2.0 / sqrt(3.0);

                    /* Animation start vertices for mitre shape */
                    struct polygon mitreA_polygons[] = {
                        {vertex_count: 5, vertex: { {0.0, 0.0},
                                                    {e / 2.0, e / 2.0},
                                                    {e, 0.0},
                                                    {d, d},
                                                    {0.0, 2 * a} }},
                        {vertex_count: 4, vertex: { {e, 0.0},
                                                    {e, 2 * a},
                                                    {e - b / 2.0, d - 0.5},
                                                    {e, 0.0} }},
                        {vertex_count: 6, vertex: { {e - b / 2.0, d - 0.5},
                                                    {e, 2 * a},
                                                    {e, e},
                                                    {d, e},
                                                    {d, e},
                                                    {d + c / 2.0, d / 2.0} }},
                        {vertex_count: 6, vertex: { {d + c / 2.0, d / 2.0},
                                                    {d, e},
                                                    {d, e},
                                                    {0.0, e},
                                                    {0.0, 2 * a},
                                                    {d, d} }}
                    };

                    /* Animation end vertices for mitre shape */
                    struct polygon mitreB_polygons[] = {
                        {vertex_count: 5, vertex: { {0.0, 0.0},
                                                    {e / 2.0, e / 2.0},
                                                    {0.5 + e / 4.0, d / 2.0},
                                                    {0.5, 3.0 * e / 4.0},
                                                    {0.0, e / 2.0} }},
                        {vertex_count: 4, vertex: { {e, 0.0},
                                                    {e, e / 2.0},
                                                    {0.5 + e / 4.0, d / 2.0},
                                                    {0.5 + e / 4.0, d / 2.0} }},
                        {vertex_count: 6, vertex: { {0.5 + e / 4.0, d / 2.0},
                                                    {e, e / 2.0},
                                                    {e, e},
                                                    {1.0, e},
                                                    {0.5, 1.0},
                                                    {e / 2.0, d} }},
                        {vertex_count: 6, vertex: { {e / 2.0, d},
                                                    {0.5, 1.0},
                                                    {1.0, e},
                                                    {0.0, e},
                                                    {0.0, e / 2.0},
                                                    {0.5, 3.0 * e / 4.0} }}
                    };

                    /* Animation start vertices for square shape */
                    struct polygon squareA_polygons[] = {
                        {vertex_count: 5, vertex: { {a, 0.0},
                                                    {1.0, 0.0},
                                                    {1.0, 1.0 - a},
                                                    {d, 1.0},
                                                    {d + c / 2.0, c / 2.0} }},
                        {vertex_count: 4, vertex: { {d, 1.0},
                                                    {1.0, 1.0 - a},
                                                    {1.0, 1.0},
                                                    {d, 1.0} }},
                        {vertex_count: 6, vertex: { {0.0, 0.0},
                                                    {a, 0.0},
                                                    {d + c / 2.0, c / 2.0},
                                                    {d + c / 2.0, c / 2.0},
                                                    {d, e / 2.0},
                                                    {0.0, a} }},
                        {vertex_count: 6, vertex: { {0.0, a},
                                                    {d, e / 2.0},
                                                    {d + c / 2.0, c / 2.0},
                                                    {d, 1.0},
                                                    {d, 1.0},
                                                    {0.0, 1.0} }},
                    };

                    /* Animation end vertices for square shape */
                    struct polygon squareB_polygons[] = {
                        {vertex_count: 5, vertex: { {c, 0.0},
                                                    {1.0, 0.0},
                                                    {1.0, e / 2.0},
                                                    {0.5, 3.0 * e / 4.0},
                                                    {1.0 - e / 4.0, a / 2.0} }},
                        {vertex_count: 4, vertex: { {0.5, 3.0 * e / 4.0},
                                                    {1.0, e / 2.0},
                                                    {1.0, 1.0},
                                                    {1.0, 1.0} }},
                        {vertex_count: 6, vertex: { {0.0, 0.0},
                                                    {c, 0.0},
                                                    {1.0 - e / 4.0, a / 2.0},
                                                    {e / 2.0, e/ 2.0},
                                                    {0.5, 1 - e / 4.0},
                                                    {0.0, c} }},
                        {vertex_count: 6, vertex: { {0.0, c},
                                                    {0.5, 1 - e / 4.0},
                                                    {e / 2.0, e / 2.0},
                                                    {0.5, 3.0 * e / 4.0},
                                                    {1.0, 1.0},
                                                    {0.0, 1.0} }},
                    };


THE 5-PIECE SOLUTIONS

Since Dudeney's revelation, several individuals have found new 5-piece solutions. [Wei]

The software was developed to find more, and the findings are listed in the image below.

At present, the software cannot handle curved lines. Incorporating curved lines could potentially lead to new 5-piece (or even 4-piece) solutions. Another interesting area of exploration is using fractal cutting lines.


REFERENCES

[Blanvillain, 2010] Blanvillain, Christian; Pach, Janos (2010). "Square Trisection".
[Dudeney, 1911a] Dudeney, Henry Ernest (1911). "Perplexities". The Strand Magazine Vol. 41. (p. 746).
[Dudeney, 1911b] Dudeney, Henry Ernest (1911). "Perplexities". The Strand Magazine Vol. 42. (p. 108).
[Dudeney, 1917] Dudeney, Henry Ernest (1917). Amusements in mathematics (p. 333).
[Frederickson, 1997] Frederickson, Greg Norman (1997). Dissections: Plane & Fancy.
[Hoffman, 1893] Hoffman (1893). Puzzles old and new.
[Loyd, 1901a] Loyd, Sam (Sunday, July 21, 1901). The Philadelphia Inquirer (p. 33).
[Loyd, 1901b] Loyd, Sam (Sunday, August 11, 1901). The Philadelphia Inquirer (p. 31).
[Perigal, 1891] Perigal, Henry (1891). Geometric Dissections and Transformations.
[Theobald] Theobald, Gavin (May 31, 2024). "Geometric Dissections".
[Wei] Wei, Fu (May 31, 2024). "Origami idea solves century-old math problem".
[Wolfram] Theobald, Gavin; Weisstein, Eric W. "Dissection".
[Wikipedia] Wikipedia (May 31, 2024). "Dissection puzzle".