It is common, (but by no means required) for participants to use the number of the conference as a theme in their exchange gift in some way. I considered a ten pointed star with pieces that slot together as a promising shape for a puzzle, and I recalled that there were ten distinct reversible binary sequences of length four. (In this scheme 0011 and 1100, for example, are considered equivalent because they reverse to each other.) This meant that with four slots at intersection points, if there were two possible positions for each slot, (like up and down) there would be exactly ten possible pieces, which would make an elegant puzzle set if I used one of each. Conveniently, the pieces could be flipped horizontally to physically realize the reversal of the string. Inconveniently, the pieces could also be flipped vertically, which would invert the 1′s and 0′s, and lower the number of distinct piece shapes to six. Another problem is that some configurations of pieces could not be physically assembled. If there was a triangle of pieces where each had an up slot followed by a down going around the triangle, there would be no way to fit the third piece in, because it would simultaneously need to be slotted in from above and below.

I solved both of these problems at once by changing the inner slots to all face the same direction, and to have shallow vs. deep as their two possible states instead of up and down. Now the ten pieces can be divided into two pentagonal configurations that are connected by their outer slots, and connect to each other by the inner slots. Because every triangle in the star contains the two inner slots of a piece, the triangles are all assemblable. The pentagons must also be assemblable, because there are only four pieces with up and down outer slots, so one side of the pentagon must have two slots pointing the same direction, and that side may be placed last. And because the direction of the inner slots is forced, only horizontal flipping is allowable. Here’s a photo of an assembled puzzle, along with an unassembled set of pieces:

Mathematical niftiness aside, is this a good puzzle? I think so. It has a fair number of solutions, but neither so many that you can easily stumble upon one without applying any strategy to solving the puzzle, nor so few that you have to spend a lot of time engaged in trial and error. Let me know if you have one of these and need hints for solving it.

In an upcoming post, I’ll discuss some variations on this type of puzzle.

Rodolfo Kurchan has posted Puzzle Fun #25. Some good new coloring problems using multiple sets of polyominoes.

David Goodger has been doing some good work on triangular and hexagonal grid polysticks.

George Sicherman is continuing to make advances in the realm of polyform compatibility problems. He also recently posted a catalog of the polypennies up to order 6.

KSO Glorieux Ronse is a school in Belgium that has, over the past decade, conducted a wonderful educational experiment by posting contests based on polyomino problems that could be engaged with by their own students just as much as the world’s puzzle solving elite. (The latter tended to win, of course.) Their 50th contest, which they state was their final one, was held late last year. They solicited the polyform puzzle community for problems to use in the contest and got quite a few, including one from me. No word yet on the results of the contest, (or their previous one for that matter) but the problems there are still pretty interesting.

I’ll be at the 10th Gathering for Gardner (G4G10) this week, and I expect that I’ll come back with quite a lot to think and post about. If you’re going to be there, my talk on Flexible Polyforms has tentatively been scheduled for the Thursday morning session. I hope to see some of you there!

For a while I’ve been trying to find a tiling of a figure with 5-fold symmetry using just the pentapennies. It feels like it should be doable, but I haven’t had any luck so far. Maybe you will? Call that problem #27. As with the polycircles in my last post, I decided to stack the deck in my favor by adding smaller pieces to the tiling set. This tiling contains 85 pennies: 65 from the 13 pentapennies and 20 from the five tetrapennies. With polypenny tilings you can either use a pattern with a penny in the center, or you can leave the center open. With a penny in the center, the remaining number of pennies is divisible by six. This is nice not only because we get a little more symmetry, but also because the configuration of six pennies around the central penny is strongly connected, which means that we have more flexibility in where the polypennies can go in that region.

Unfortunately, although seven is also a divisor of 84, seven pennies don’t fit around a central penny, so this is probably as good as we can do for symmetry. Although if we went to hyperbolic geometry, seven pennies could fit perfectly around a central penny after all. But, for now at least, I’ll save my pennies and not spend them irresponsibly at non-Euclidean exchange rates.

The pentapennies

I called these polyforms “polypennies” rather than “polycircles” because “pennies” captured the equal size of the cells. (ETA: I forgot that I raided the word from the term “penny graph,” which has been used as an alternative to “unit coin graph” to describe the adjacency graph associated with a particular configuration of non-overlapping unit radius circles.) I also knew that eventually I would want to get to polyforms made of circles of arbitrary size, for which I was reserving the term “polycircle”. Well, it happens that I’ve been invited to Gathering for Gardner 10, where I plan to give a talk on flexible polyforms, so eventually is now.

For polycircles with cells of arbitrary size, another dimension of flexibility is required. Two polycircles are equivalent if they can be made congruent by continuously expanding or shrinking the circles without changing adjacencies, in addition to applying the transformations allowed with polypennies. This extra flexibility means that, in addition to the polycircles that are equivalent to polypennies, there are some polycircles that could only be formed by placing circles into spaces where they wouldn’t fit if all of the circles were forced to be the same size.

As with other flexible polyforms, elegant tiling puzzles for the polycircles can be produced by attempting to maximize the symmetry of the configuration to be tiled. Here’s an example, with fourfold rotational symmetry, of a tiling puzzle containing all of the polycircles of order 1 through 4:

This was not a hard puzzle to solve, once I came up with a configuration to tile that would work. Adding smaller pieces is a time-honored trick for making polyform puzzles easier; I put in the 1- through 3-circles because I was failing to make any headway with the 4-circles alone. The extra dimension of flexibility was helpful in that one can generally resize the circles to touch more neighbors than is possible in polypenny puzzles, which tend to end up with a number of cells with only two neighbors. On the other hand, the 4-circles with a circle inside the gap between three others in a triangle were trickier to deal with than any of the 4-circles that are equivalent to 4-pennies.

Can we do better than the above? I think fivefold symmetry may be possible.

Problem #26: Find and solve a tiling puzzle for the 1-, 2-, 3-, and 4-circles with fivefold rotational symmetry.

If you know your Julia sets, you might be thinking something odd is going on here.

If you don’t, here’s a quick primer.

Pick a complex constant c. Then for every point z in the complex plane, create a sequence with the following recursive definition:

z₀ = z
z_n+1 = z_n² + c

This sequence will do one of two things. Either it will zip away from 0 and eventually go indefinitely far away, or it won’t. (It could converge to a single point, or alternate between a few points, or bounce around chaotically. It doesn’t matter.) The points where the sequence sticks around near zero form a quadratic Julia set. There are other kinds of Julia sets, defined using different formulas. But the kind of Julia set you will most commonly encounter is this one, and henceforward I will use the term Julia set to refer to this kind of Julia set.

Julia sets are fun to play with because they are fractals, with infinite levels of detail and self-similarity. Some Julia sets form a single connected blob:

Julia set for c = .3 + .2i

Other Julia sets form dusts, where any region that appears to be in the set is actually divided into separate disconnected regions, and these regions are themselves divided, ad infinitum:

Julia set for c = .7 + .33i

I should note that I’m cheating here slightly. A dust isn’t actually much to look at. Although it contains an infinite number of points, the probability of an individual point being in a dust-like Julia set is 0, so if I were plotting it properly, there would be nothing to see. What I’m actually plotting for each point is a level of grey on a scale from 0 to 255 (the latter being black) corresponding to the number of iterations it took for the sequence to escape beyond a given bound. The use of a grayscale gives dusts a more organic look, which I rather like.

Every Julia set is either a dust or a blob. The famous Mandelbrot set effectively catalogs this aspect of Julia sets. For every possible constant c, one checks only the behavior of 0 in the Julia set for that constant. If 0 escapes to infinity, we have a dust, otherwise we have a blob.  Near the boundary, the blob thins into increasingly narrow filaments, but it remains in a single connected piece until the boundary is crossed, and the blob shatters into a dust. The Mandelbrot set contains all of the constants that give “blob-like” Julia sets.

The Mandelbrot Set

Getting back to my first image in this post, you can now see why I said there was something odd about it. That fractal is not a single blob; there are many disconnected parts. But it also isn’t a dust; there are filled solid regions. So it can’t be a proper Julia set. But it does have a Julia set “feel” to its self-similarity. So what’s going on?

The answer is that instead of using a single constant at every step of iterating the sequences for each point, as one would for a proper Julia set, I alternated between two constants. In fact, the two constants I alternated between were precisely the constants for the blob and dust I showed above. Thus it is perhaps unsurprising that the “child” of a blob and a dust would show characteristics of each: those characteristics were in its “genes”.

Alternating between the two constants in the opposite order gives the following:

Looks like the same basic pattern as before, but with two big connected bits instead of one. Notice that in this one the center point (z=0) is outside the set, while for the other one it was inside the set. Since this is the point that would tell us if we had a blob or a dust in a normal Julia set, it feels appropriate that it can go either way depending on the order here.

Here’s the Python code that produced the last image:

from PIL import Image
size = 400
im = Image.new("RGB", (size, size))
c = [.3 + .2j, -.70 + .33j] #j is i in python
for x in xrange(size):
    for y in xrange(size):
        z = x * (4.0 / size) - 2 + (y * (4.0 / size) - 2) * 1j
        i = 0
        while abs(z) < 4 and i < 256:
            z = z ** 2 + c[i % 2]
            i += 1
        im.putpixel((x,size-y-1), (255-i,255-i,255-i))

im.save("julia6.png")

It might be nice to have some puzzle using these. So here is one! Fill in segments on the figure below so that each of the ten patterns above is represented on a 7-segment LED shaped subsection of the figure.

Reflections and rotations of the patterns are considered equivalent. There are 13 7-segment LED shaped subsections of the figure, so three of them either can have other patterns, or can be duplicates.

Are there any other puzzle grids that would make for a puzzle using these patterns that is as good or better than this one?

A reducible cover is one where a cell can be removed and the remaining figure is still a cover. An interesting problem then is to find an irreducible cover in a single piece that is as large as possible. (Why a single piece? Well, without specifying that, the largest irreducible cover will simply be all of the shapes in the set in separate pieces.) Here’s a (conjectured) maximal irreducible contiguous cover (MICC) of the pentominoes:

The above solution has been on my polyomino cover page for a while. Here are a couple of new results, (still just conjectured since I found them by hand rather than exhaustive computer search, and I am not able as yet to prove they are maximal.)

An MICC (?) of the hexiamonds

An MICC (?) of the pentaedges (shown in two copies for clarity)

Between these solutions, we see some patterns emerging. Certain polyforms are in some sense distinctive: they have features that do not occur in other polyforms in the set. This makes it easy to make a large cover that includes exactly one copy of them. Other polyforms end up serving a connective function. For example, there are quite a few occurrences of the L pentomino in the first figure, so removing a cell will never make the cover cease to include an L. By using a few pentominoes as many times as possible in this connective function, more pentominoes are left over to occur singularly.  In some cases multiple polyforms that occur only once are forced to overlap, so we don’t get their full number of cells to add to the cover, but we do get a few. This is shown with the outlined hexiamonds above. In the case of the pentominoes, we have one cell where two T pentominoes overlap; since these are the only two T pentominoes in the figure, the cell can’t be removed from the cover.

Problem #25: Find maximal irriducible contiguous covers of anything and everything! This problem ought to yield interesting results for any kind of polyform you can throw at it.

One final note: It was slightly unfortunate that I chose the word “cover” to represent a concept in polyforms when it already had an unrelated meaning in graph theory; it’s even more problematic now that I’m using graphs themselves as polyforms. It appears that in graph theory, the appropriate term is “common supergraph”. I could use “common superform”, although one problem is that polyforms, unlike graphs, are generally not allowed to be disconnected, and for some problems (though not this one) we want sets of polyforms that aren’t connected to each other. Perhaps “common superformsets” in that case, as ugly as it sounds.

Alternatively, we could look at sets of connected graphs with n edges, which I will call polyedges. There are no non-planar n-edges until size 9. There are 12 pentaedges, the same as the number of pentominoes, and I hope to show that this is a versitile and interesting set of polyforms.

The 12 pentaedges

(The term polyedges is used in some sources to refer to what are more commonly referred to as polysticks, i. e. connected sets of segments in a (typically square) lattice. However, I have need of a term, and polyedge seems so clearly the right one that I feel justified in repurposing it.)

In making tiling problems for polyedges, we treat them like polysticks, allowing polyedges to meet at a vertex but not allowing edges to overlap between forms. Now, one important problem remains: what graphs should we use as patterns for them to tile? We are unconstrained by geometrical considerations, which in the case of polyominoes, for example, pull us toward making rectangles. But we can still use symmetry. Not only are highly symmetrical graphs particularly elegant, but symmetry can narrow the space of solutions; since polyedges are very flexible, this is probably desirable. It will help that the total number of edges in the set is 60, a number with many factors, which should help in our search for symmetrical patterns.

Here are the pentaedges tiling 4 copies of K6, the complete graph (all vertices are connected) with 6 vertices:

This pattern has a truly dizzying amount of symmetry. Every permutation of the vertices in a complete graph maps the graph to itself. There are 6! = 720 such mappings (or automorphisms) for each K6. Since we can permute all four copies independently, on top of which we can arbitrarily reorder the copies themselves, the full pattern has 720⁴ · 4! = 6,449,725,440,000 automorphisms.

On the other hand, it’s non-planar, and we might want to tile some planar patterns. One highly symmetrical planar pattern with 60 edges is a pair of icosahedra. I show them squished onto a plane for clarity below, but as graphs they’re still equivalent to the 20-sided dice that role-playing gamers use.

Notice that I used 6 colors to distinguish the pentaedges in the figure above. In fact, I had to, since each of the pentaedges touches each of the others within each icosahedron. We could instead try to minimize the number of colors required.

Problem #22: Tile a pair of icosahedra with the pentaedges using only 3 colors, with no two pentaedges of the same color meeting at a point. (It may help to know that there must be 11 vertices where the degrees of the vertex for each adjoining pentaedge are 2, 2, and 1, 7 where they are 3, 1, and 1, and 3 where they are 3 and 2. This can be obtained by counting the total number of vertices of each type in the 12 pentaedges and setting up a system of equations; I won’t get into the details here, but I’ll put them in a comment.)

The pattern above has 28,800 automorphisms. It’s not the most symmetrical planar pattern possible. A set of 4 pentagonal dipyramids has 3,840,000 automorphisms. After finding the other tilings in this post, I got lazy wanted to let others join in the fun, so I’m leaving the problem to you:

Problem #23: Tile a set of 4 pentagonal dipyramids with the 12 pentaedges.

With polysticks, we often like to forbid solutions from containing points where two polysticks cross. We can do the same with polyedges, if we set up the pattern properly:

Notice the trick I played with the pentagonal (or 5-cycle) pentaedge at the bottom of the figure, putting the 5-star pentaedge inside it. In the previous problem, we couldn’t tile the icosahedra without any crossings, because one pentaedge contains a 4-cycle, which can only be placed on an icosahedron with an edge connecting two opposite corners, and the pentaedge containing this edge must cross the 4-cycle. Can we find a pattern where the pentaedges containing 4- and 5-cycles can both enclose one or more other pentaedges, so that the pattern contains only triangular faces and can still be tiled without crossings? Here’s a candidate that can be inscribed on a cube; in this case it seems clearer to show the cube in an unfolded state than to squish it as we did with the icosahedra.

Problem #24: Tile the above figure with the pentaedges. (Keep in mind that in the unfolded version, the edges that fold together count as a single edge. The pentaedges that are already placed are just for illustration, and can be placed differently in a solution.)

To make it a bit easier to communicate solutions or new problems you find, I’m providing source svgs (made in Inkscape) for some of the images above. They contain copies of the relevant patterns in plain black, which can be turned into a solution by recoloring the edges.

Problem #22 (Icosahedra)
Hexagonal figure
Problem #24 (Cube with triangles)

This post expands on material at my non-blog. Theoretically, I’m using this blog to write more exploratory material in the service of the non-blog, where I intend to collect it in a more digested form. However, lately I’ve been more poaching the non-blog for material to use here, and I haven’t gotten around to updating the non-blog as I mean to. Nevertheless, if you like what you’ve been seeing here, you should check it out, as it contains most of my polyform discoveries from the ’00s.

(The other is a variation on this one where the order of two of the polysticks in the center of the top of the figure is swapped.)

Later, I saw that the same set of polysticks would fit into a 3×4 array of diamonds. All of the vertices in this figure have even degree, which means that it is possible to make Eulerian circuits on it. Sicherman sent in a solution to this one too:

Sorry, I was too lazy to turn it into snakes. For this problem, solutions like the above with no point where four polysticks meet are preferable, otherwise there would be more than one direction for a path to take. Although it would be nice if it could be done without any points where two polysticks cross, this is impossible. (The pieces contain 14 straight joints; if there are no crossings, each straight joint must also be the locus of two end points. Since each piece has two end points, and there are 13 pieces, there aren’t enough end points to go around.)

The shape of the darker region is “magic” because the number of cells in each 3×3 block corresponds to a number in a magic square, while the number of cells in each row, column, and main diagonal is 5. The sum of the numbers in each row and column is 115.

There’s still room for improvement here: note that the diagonals do not add up to the magic sum. (A mostly magic square with this property is called semimagic.)

Problem #21.1 Find a magic magic 45-omino, as above, but with diagonals adding to the magic sum.

It’s interesting that this solution was found by manually tweaking the output of a program that I wrote to solve the problem. I was never able to get the program to find an actual solution, so I had it give up after a certain number of trials and output the best near solution. There may well be a large number of solutions, but the search space is enormous.

It’s pretty simple to get fairly close by picking a random permutation of numbers and repeatedly swapping them around to get sums closer to the magic sum. But getting from this local minimum to a real solution is the hard part. The problem would seem to call for something like simulated annealing, and indeed I found a reference to a magic square finder algorithm using something similar. (It should be noted that if all you want is a magic square of a given size, there are deterministic methods that will get you one very quickly.) I added a hack to my code to make it do a crude version of this, but it doesn’t seem to have helped much. (The near solution that Herdt fixed up was made with the old version of the code.)

Feel free to look at my solver code (in Python). I do wonder if there is some way it can be fixed up to be better at getting from near solutions to real solutions.