Volume 15, Number 2, Pages 95–131

ISSN 1715-0868

A NEW MATHEMATICAL MODEL FOR TILING FINITE

REGIONS OF THE PLANE WITH POLYOMINOES

MARCUS R. GARVIE AND JOHN BURKARDT

Abstract. We present a new mathematical model for tiling finite sub-

sets of Z2 using an arbitrary, but finite, collection of polyominoes. Unlike
previous approaches that employ backtracking and other refinements of
‘brute-force’ techniques, our method is based on a systematic algebraic
approach, leading in most cases to an underdetermined system of linear
equations to solve. The resulting linear system is a binary linear pro-
gramming problem, which can be solved via direct solution techniques,
or using well-known optimization routines. We illustrate our model with
some numerical examples computed in MATLAB. Users can download,
edit, and run the codes from http://people.sc.fsu.edu/~jburkardt/
m_src/polyominoes/polyominoes.html. For larger problems we solve
the resulting binary linear programming problem with an optimization
package such as CPLEX, GUROBI, or SCIP, before plotting solutions
in MATLAB.

1. Introduction and motivation

Consider a planar square lattice Z2 . We refer to each unit square in the
lattice, namely [j̃ − 1, j̃] × [ĩ − 1, ĩ], as a cell. A polyomino is a union of
a finite number of edge-connected cells in the lattice Z2 . We assume that
the polyominoes are simply-connected. The order (or area) of a polyomino
is the number of cells forming it. The polyominoes of order n are called
n-ominoes and the cases for n = 1, 2, 3, 4, 5, 6, 7, 8 are named monominoes,
dominoes, triominoes, tetrominoes, pentominoes, hexominoes, heptominoes,
and octominoes, respectively. Golomb introduced polyominoes in a 1965
book [32] (revised and reissued in 1994 [34]). An in-depth treatment of this
subject area can be found in [31] and in a collection of essays edited by
A. J. Guttman [39]. See also the comprehensive text by Grünbaum and
Shephard [37] and the many references therein.
We broadly classify polyominoes as follows (see [31]). A fixed polyomino is
an equivalence class of polyominoes that are equivalent under translations,

Received by the editors February 6, 2019, and in revised form July 9, 2020.
2010 Mathematics Subject Classification. 05B50, 52C20, 90C05, 90C10.
Key words and phrases. polyominoes, tiling, integer linear programming, optimization,
MATLAB.
Corresponding author: Marcus Garvie.

© 2020 University of Calgary

95
96 MARCUS R. GARVIE AND JOHN BURKARDT

so each of the eight tetrominoes illustrated in Figure 1 represent a different

fixed polyomino. A free polyomino is an equivalence class of polyominoes
that are equivalent under translations, rotations, and reflections, so the eight
tetrominoes illustrated in Figure 1 represent the same free polyomino. There

Figure. 1. The 8 fixed L-shaped tetrominoes.

are also one-sided polyominoes that are equivalence classes of polyominoes

that are equivalent under rotations and translations. For example, the first
four polyominoes in the above series represent the same one-sided polyomino.
Considerable effort has been devoted to the problem of enumerating poly-
ominoes as a function of area, or perimeter. Although the general problems
are still open, asymptotic formulae and formulae for special cases have been
derived [12, 18, 19, 21, 31, 35, 39, 43, 44, 51, 56, 66].
Much effort has also been applied to the problem of tiling the plane with a
single polyomino, or with a finite set of polyominoes [8, 23, 33, 38, 72, 75, 78].
The question of whether a finite set of polyominoes can tile the infinite plane
is undecidable [8, 73], and determining whether one can tile a finite region
of the plane with a given set of polyominoes is in general N P-complete [53].
However, there are special classes of problems that can be solved efficiently.
For example, the powerful methods of Combinatorial Group Theory have
been successfully applied in a number of interesting cases to prove whether
a region can be tiled with a given set of polyominoes, which are generally
stronger than classical colouring arguments [15, 60, 61, 68, 76]. There is a
large literature on the many theoretical and computational investigations of
tiling finite regions of the plane with a given set of polyominoes, and the
following list is far from complete: [2, 3, 4, 9, 26, 27, 28, 29, 42, 55, 57, 65,
67, 69, 70, 71, 77].
As the problem of tiling regions of the plane is in general N P-complete, it
is not surprising that existing algorithms for tiling with polyominoes use re-
finements of ‘brute-force’ techniques for exhaustively finding solutions with
a computer. Tiling problems are almost always solved using backtracking
[30, 47], which is a recursive procedure for pruning the search tree of a
combinatorial problem. Backtracking is a procedure appropriate for a prob-
lem whose solution can be described as a sequence of steps, each of which
involves a choice from some set of options. For example, a maze may be
 A NEW MODEL FOR TILING WITH POLYOMINOES 97

represented as an abstract graph whose nodes are labelled alphabetically. If

we wish to search for a path from node A to node Z, a backtracking method
can be employed. Starting from node A, the backtracking procedure con-
structs a tentative path by moving from the current node to a previously
unvisited neighbour. Since there may be several choices for such a step, it
randomly chooses a node to move to, storing any unchosen options for future
exploration. After each move, there are three possibilities:
1. The new node is the goal Z, so we are done. Report the path.
2. The new node is not the goal, but it does connect to other nodes that
have not been explored. Choose one, add it to the path, move there, and
remember all other unchosen nodes for later options.
3. The new node is not the goal, and does not connect to any unexplored
nodes. Remove this node from the path, ‘backtracking’ to the previously
visited node.
Assuming the graph is finite, the backtracking procedure will methodically
arrive at a path to the exit, or end up back at the starting node if there is
no such path.
Donald Knuth [45, 46] implemented a combinatorial search algorithm
called Dancing Links (also called ‘DLX’). The Dancing Links algorithm
is a recursive, nondeterministic, backtracking algorithm that finds all so-
lutions to the exact cover problem, and has been applied to various prob-
lems in addition to tiling with polyominoes, for example: Steiner systems
[10], chessboard separation problems [13], general lattice problems [52], hex-
omino puzzles [16], and a problem in artificial intelligence [5]. Additional
backtracking solvers include an algorithm by Fletcher [22], the ‘de Bruijn al-
gorithm’ [17] which is very similar, and a modern solver by Matthew Busche
[11], called ‘POLYCUBE’, which is optimized in C++ and incorporates ele-
ments from both the DLX and de Bruijn to implement a suite of algorithms
and techniques. An alternative approach using ‘brute-force’ for tiling with
polyominoes uses evolutionary computation with fitness functions [4].
The main aim of this paper is to answer the following questions:

Question. Is there is a general systematic mathematical alternative to the

backtracking methods for tiling with polyominoes? And if the answer is ‘yes’,
does it yield a flexible algorithmic approach for finding solutions?

The motivation for our work is contained in an example by Michael Reid

[68] for tiling a simple region with copies of a single polyomino. Reid was
concerned with theoretical aspects of applying the tile homotopy method for
proving the impossibility of specific tiling problems and acknowledged that
his group theory method could not be made algorithmic. However, Reid’s
example is the only case we are aware of that turns a polyomino tiling
problem into an algebraic problem, and for the purposes of introducing our
method his example is reproduced below.
98 MARCUS R. GARVIE AND JOHN BURKARDT

Consider tiling the region in Figure 2 with dominoes,

( )
,

all orientations permitted:

Figure. 2. Region to tile with dominoes.

Reid introduced a variable xi ∈ {0, 1} for how many times each placement
of a domino is used to tile the region, illustrated in Figure 3: In any tiling

(a) x1 . (b) x2 . (c) x3 . (d) x4 . (e) x5 .

(f) x6 . (g) x7 . (h) x8 . (i) x9 . (j) x10 .

Figure. 3. Possible tile placements and associated variables.

of Figure 2 each of the 8 cells must be covered exactly once, yielding the
following system of 8 linear equations in 10 unknowns :
x1 + x6 =1
x3 + x6 =1
x1 + x2 + x7 =1
x3 + x4 + x7 + x8 =1
(1.1)
x5 + x8 =1
x2 + x9 =1
x4 + x9 + x10 =1
x5 + x10 =1
Observe that the total number of dominoes used to tile the region is given
by
10
X
xi = (number of cells in region)/2 = 4.
i=1
 A NEW MODEL FOR TILING WITH POLYOMINOES 99

This
P is incorporated in the above system as adding the equations yields
2 10i=1 xi = 8, which gives the same result. We have converted a tiling
problem into an algebraic problem. A tiling of the region corresponds to
a solution of the algebraic system, however the converse is not necessarily
true. Nonbinary ‘solutions’ do not correspond to a tiling of the region.
We generalize the approach used in this example for tiling arbitrary finite
subsets of Z2 using a given number of free polyominoes, with a known num-
ber of copies of each polyomino. The model formulation is easily converted
into an algorithm that can be coded on a computer. The resulting linear
system of equations can be solved via a direct approach, or as a binary
linear programming problem using well-known optimization routines. The
binary linear programming problem is another N P-complete problem [25],
but hopefully more efficient than a pure trial-and-error approach.
The remaining parts of this paper are organized as follows. In Section 2
the mathematical model for tiling with polyominoes is derived and stated
and methods for solving the model are discussed in Section 3. In Section 4 we
present numerical results for small problems solved in MATLAB using a di-
rect solution method, and for larger problems solved using high-performance
optimization software packages. Conclusions are made in Section 5. Finally,
in Appendix A the main notation of this paper is summarized, and in Ap-
pendix B some implementation details are given for using the optimization
software to find multiple feasible solutions.

2. Constructing the mathematical model

Consider an arbitrary union of a finite number of edge-connected cells in
the lattice Z2 denoted R with order cR that is connected, but not necessarily
simply-connected (i.e., R is allowed to have ‘holes’). Using a given finite set
of free polyominoes we aim to tile R. A tiling of a region R is an arrangement
of our set of polyominoes that covers every cell of R exactly once. Our
approach for representing polyominoes as unique binary matrices is similar
to that in [6]. Drawing R in the positive quadrant of the plane, define the
rectangular hull of R to be the smallest rectangle containing R. The lattice
associated with any r × c rectangular hull of R can be expressed as

B := {(j̃, ĩ) | 0 ≤ ĩ ≤ r; 0 ≤ j̃ ≤ c; ĩ, j̃ ∈ Z}.

We then define a binary matrix B ∈ {0, 1}r×c such that the (ĩ, j̃) entry of
B is equal to 1 if the unit square [j̃ − 1, j̃] × [ĩ − 1, ĩ] of B is a cell of R,
otherwise 0. If R is simply-connected and a rectangle, then all the entries
in B will be equal to 1. An example is illustrated in Figure 4:
Assume we have a collection of ns free polyominoes S := {Pi }ni=1 s
, where
the order of each Pi is denoted ci . Allowing for a combination of rotations,
reflections and translations, assume each polyomino Pi fits si ways into R.
We tile R with di , 1 ≤ di ≤ si , copies of each free polyomino Pi ∈ S,
100 MARCUS R. GARVIE AND JOHN BURKARDT

 
0 0 1 1 1
1 1 1 1 1
 
1 1 0 1 0
0 1 1 1 0
(a) R, (b) R and B. (c) B.

Figure. 4. Constructing the binary matrix B.

i = 1, . . . , ns , thus
ns
X
(2.1) ci di = cR ,
i=1

and the total number of polyominoes used to tile R is

ns
X
(2.2) np := di .
i=1

We associate the jth placement of polyomino Pi into R with a binary matrix

Ai,j ∈ {0, 1}r×c , j = 1, . . . , si , defined in the same way that the binary
matrix B is defined. That is, the (ĩ, j̃) entry of Ai,j ∈ {0, 1}r×c is equal to
1 if the unit square [j̃ − 1, j̃] × [ĩ − 1, ĩ] of B is a cell of Pi , otherwise 0.
Two placements of a triomino into a region R and their associated binary
matrices are illustrated in Figure 5.
 
0 0 0 0 0
0 0 0 0 0
 
0 1 0 0 0
0 1 1 0 0
(a) 1st placement of P1 . (b) A1,1 .
 
0 0 0 1 0
0 0 1 1 0
 
0 0 0 0 0
0 0 0 0 0
(c) 2nd placement of P1 . (d) A1,2 .

Figure. 5. Constructing the binary matrices Ai,j .

For a valid configuration we must have Pi ∩ R = Pi , i.e. each cell of Pi

must not overlap with a cell outside of R or with any cells that are part of
a hole in R.
For notational simplicity we avoid using a separate notation for enumer-
ating the fixed polyominoes associated with a given free polyomino Pi . How-
ever, it is clear that the number of ways a particular free polyomino Pi fits
 A NEW MODEL FOR TILING WITH POLYOMINOES 101

in the region R is in general greater then the number of ways the associated
fixed polyominoes for Pi fits into R1.
The set of binary matrices Ai,j associated with fitting the polyominoes Pi
into R is called Series i, given by
Series i := {Ai,j ∈ {0, 1}r×c | j = 1, . . . , si }, i = 1, . . . , ns .
The total number of binary matrices Ai,j is given by
ns
X
(2.3) n := si .
i=1
Before the model can be formulated and solved for a particular case, there
is the practical task of finding all binary matrices Ai,j in each series. Initially
for each free polyomino Pi we find all the associated fixed polyominoes ob-
tained by appropriate combinations of rotations and reflections. Depending
on the symmetry of the polyomino this will be either 1, 2, 4, or 8. For each
fixed polyomino we exhaustively find all possible ways in which the fixed
polyomino fits into R, and for each configuration we calculate the associ-
ated binary matrix. The number of choices a particular fixed polyomino fits
into R will depend on divisibility conditions concerning the dimensions of
the rectangular hulls of Pi and R. As this is elementary (but tedious) we
omit further details.
We introduce a variable αi,j ∈ {0, 1} for how many times the jth place-
ment of Pi is used to tile R. The mathematical description of tiling the
region R with polyominoes in S is given by the following problem:

Problem I.

Seek parameters αi,j ∈ {0, 1}, 1 ≤ i ≤ ns , 1 ≤ j ≤ si such that

si
ns X
X
(2.4a) αi,j Ai,j = B,
i=1 j=1
si
X
(2.4b) subject to αi,j = di , 1 ≤ di ≤ si , i = 1, . . . , ns .
j=1

The constraints (2.4b) enforce the conditions that we must use exactly di
polyominoes from each Series i to tile R.
Remark 2.1. In general, the solutions of equation (2.4a) subject to the
constraints (2.4b) (if they exist) are rational (see Theorem 2.18). If the
solutions of this relaxed problem are not binary then we can no longer in-
terpret each di as the number of copies of a polyomino Pi used to tile a region
R. For
P 1example, consider d1 = 1, s1 = 3, with α1,1 = α1,2 = α1,3 = 1/3,
and sj=1 α1,j = 1, so the number of polyominoes used from Series 1 is 3.
1This is because free polyominoes can be rotated, reflected, and translated in R, while
fixed polyominoes can only be translated.
102 MARCUS R. GARVIE AND JOHN BURKARDT

Remark 2.2. It is natural to assume that an additional constraint is nec-

essary in order to fully describe the tiling problem, namely, that the area of
the polyominoes used in the tiling must match the area of the region to be
tiled. However, it is easy to demonstrate that this constraint is already im-
plicit in the current set of equations. If one sums over all rows and columns
of the matrices in equation (2.4a),
P s thePright hand side evaluates to cR and
each Ai,j becomes ci , yielding ni=1 ci sj=1
i
αi,j = cR . Then using equation
(2.4b) we obtain ni=1
P s
ci di = cR .
We consider the mathematical description of tiling the region R with
copies of a single polyomino in S (ns = 1) as a separate problem. Problem
I represents the general case, in which several distinct polyominoes are to be
used. Technically, this includes the case where only one polyomino shape is
to be employed; however this case will be termed Problem II, since it occurs
frequently in the literature, is easier to describe and visualize, and in some
cases can be simpler to analyze or simulate computationally.

Problem II.

Seek parameters α1,j ∈ {0, 1}, 1 ≤ j ≤ s1 such that

s1
X
(2.5) α1,j A1,j = B.
j=1

Remark 2.3. In general, the solutions of equation (2.5) (if they exist) are
rational (see Theorem 2.18). If the solutions of this relaxed problem are not
binary then d1 may not be a positive integer (see Example 4.4).
Remark 2.4. If one sums over all rows and columns of the matrices in
equation (2.5), the right hand side evaluates to cR , and each A1,j evaluates
to c1 , yielding
Xs1 s1
X
c1 α1,j = cR = c1 d1 =⇒ α1,j = d1 , 1 ≤ d1 ≤ s1 .
j=1 j=1
Thus the constraint on the variables of the problem when we tile with copies
of a single polyomino is automatically incorporated into the problem (cf.
Remark 2.2).
For a given set of free polyominoes
Pns S, there may be many possible ways
of satisfying the area equation i=1 ci di = cR , depending on how many
copies of each polyomino Pi are used. If a single polyomino P1 is used to
tile R then it must be used d1 = cR /c1 times. On the other hand, if all
theP free polyominoes are used exactly once, then di = 1 for i = 1, . . . , ns
so ni=1 s
ci = cR . If the number of copies di of each polyomino Pi are not
specified then we have a linear Diophantine equation in ns unknowns to
solve for:
(2.6) c1 d1 + c2 d2 + · · · + cns dns = cR .
 A NEW MODEL FOR TILING WITH POLYOMINOES 103

Each positive integer solution may correspond to a different tiling prob-

lem. The following theorem concerns the existence of nonnegative integer
solutions to equation (2.6), where gcd(c1 , c2 , . . . , cns ) denotes the greatest
common divisor of the coefficients c1 , c2 , . . . , cns :
Theorem 2.5 (see [64]). For fixed coefficients ci , i = 1, . . . , ns there exists
an integer N such that
(i) gcd(c1 , c2 , . . . , cns ) | cR , and
(ii) cR ≥ N
together form a sufficient (but not necessary) condition for a nonnegative
integer solution of equation (2.6).
The result follows immediately from Theorem 1.0.1 in [64] after dividing
equation (2.6) through by gcd{ci }ni=1 s
. Theorem 2.5 tells us that in general,
ns
if either gcd{ci }i=1 does not divide cR , or if the target region cR is not suffi-
ciently large, then there is no nonnegative integer solution of equation (2.6),
i.e., in particular, there is no positive integer solution (recall, we assume all
coefficients di are strictly positive).
Theorem 2.6. If equation (2.6) does not possess a positive integer solution
then S does not tile R.
Proof. By assumption there is at least one di , 1 ≤ i ≤ ns that is not a
positive integer. Thus from equation (2.4b) one or more of the coefficients
αi,j are not binary and so S does not tile R. 
Example 2.7. Let
( )
P = with S= , ,

all rotations and reflections permitted. We have c1 = 4, c2 = 2, and cR = 9,

so as gcd(c1 , c2 ) does not divide cR , it follows from Theorem 2.5 that d1 or
d2 is not a positive integer, and so from Theorem 2.6 we conclude that S
does not tile R.
Remark 2.8. Theorem 2.5 implies that even when gcd(c1 , c2 , . . . , cns ) does
divide cR , if cR is not sufficiently large we may still have no nonnegative
integer solution to equation (2.6) (see Example 2.9). From a practical per-
spective this is important. If the number of polyominoes used to tile R is
large, or cR is large, it can be difficult to know ahead of time whether a
nonnegative integer solution to equation (2.6) exists without additional in-
formation.
Example 2.9. Let
( )
P = with S= , ,
104 MARCUS R. GARVIE AND JOHN BURKARDT

all rotations and reflections permitted. We have c1 = 3, c2 = 4, cR = 12

and gcd(c1 , c2 ) divides cR . However, as the linear Diophantine equation
3d1 + 4d2 = 12 does not have a positive integer solution it follows from
Theorem 2.6 that S does not tile R.
The problem of determining how many nonnegative integer solutions to
equation (2.6) exist is well-known to be N P-complete [62, p. 376] and some
methods for computing the solutions are given in [64].
Remark 2.10. If the constraints (2.4b) are omitted in Problem I then the
number of copies of each polyomino used to tile the region is unspecified,
which greatly expands the number of possible solutions. Indeed, some of the
coefficients di may be zero, which is not possible when the constraints are
imposed. (For instance, in Example 2.9 four copies of the triomino will tile
the region.) For simplicity in the sequel we assume that the coefficients di
are given and the constraints are incorporated in the problem.
After multiplying the binary matrices Ai,j on the left hand side of equa-
tion (2.4a) by the parameters αi,j and then taking the sum of the resulting
matrices, we equate the nonzero 2 entries of B with the corresponding en-
tries on the left hand side of equation (2.4a) yielding cR linear equations
(see equation (2.1)). The ordering of the equations corresponds to taking
entries in the matrix B row-wise, left to right, top to bottom. Consider
first the case that ns > 1. Adding the constraints (2.4b) yields a total of m
equations in n unknowns, with the following matrix form:

Linear System I.
(2.7) M α = b,
b M ∈ {0, 1}m×n , α ∈ {0, 1}n ,
where m = cR + ns , n = ni=1
P s
si and
(
b i = 1 for i = 1, . . . , cR
{b} ,
di for i = cR + 1, . . . , m

T
α = α1,1 . . . α1,s1 | α2,1 . . . α2,s2 | . . . | αns ,1 . . . αns ,sns .
The vertical lines in the solution vector indicate the partition of unknowns
according to the series they are associated with. As a consequence of the
constraints (2.4b) exactly di coefficients associated with each Series i are
equal to 1, with the remaining coefficients equal to zero.
Remark 2.11. Let M c be the matrix composed of the first cR rows of M , i.e.
the coefficient matrix of Linear System I without the constraint equations.
Each row in M c corresponds to a nonzero entry in B, while each column
corresponds to an unknown in α. The columns of M c are equal to the entries
i,j
in the binary matrices A written row-wise. (We only take the entries in
2Zero entries of B correspond to cells not in R.
 A NEW MODEL FOR TILING WITH POLYOMINOES 105

Ai,j that correspond to nonzero entries in B.) Thus if we sum the first cR
equations in Linear System I we obtain
s1 s2 s ns
X X X
c1 α1,j + c2 α2,j + · · · + cns αns ,j ,
j=1 j=1 j=1

which is a linear combination of the last ns constraint equations with weights

c1 , c2 , . . . , cns 3. Thus the reduced row echelon form of the augmented matrix
associated with Linear System I will always have a row of zeros in the bottom
row, which has relevance to the solvability of the system (see Section 3).
Problem II (ns = 1) yields the following system of m equations in n un-
knowns, with the matrix form:

Linear System II.

(2.8) M α = b,
b M ∈ {0, 1}m×n , α ∈ {0, 1}n ,
where m = cR , n = s1 and
(2.9) {b}
b i = 1 for i = 1, . . . , cR

T
α = α1,1 . . . α1,s1 .
Remark 2.12. In Linear System II if d1 = cR /c1 is not a positive integer
then the single free polyomino does not tile R.
Remark 2.13. By the terms relaxed Linear System I and relaxed Linear
System II we mean the corresponding relaxed linear systems with (if they
exist) rational solutions (see Remark 2.1 and Remark 2.3).
Tiling with sets of polyominoes typically yields underdetermined linear
systems of equations with multiple (binary) solutions. Linear System I is
underdetermined if cR + ns < n, while Linear System II is underdetermined
if cR < s1 .
There appears to be little we can say about the number of binary solu-
tions, denoted N , of Linear System I or II without some additional infor-
mation. If we have a consistent underdetermined linear system then either
we have no binary solutions (N = 0), a unique binary solution (N = 1),
or a finite number of binary solutions (N > 1). For example, the problem
of tiling the 6 × 10 rectangle with the full set of 12 free pentominoes has
N = 2339 solutions, excluding trivial variations obtained by reflecting or
rotating the whole rectangle [40], and the problem of tiling any rectangle
with 20 squares using the full set of 5 free tetrominoes has no solution [49].
Regarding the solvability of Linear Systems I and II the usual condition
involving rank can be computed for determining the consistency of the sys-
tem (see Section 3.1 for more details). We may also be able to determine
ahead of time if positive rational solutions exist. If positive solutions do
3This is equal to c , cf. Remark 2.2.
R
106 MARCUS R. GARVIE AND JOHN BURKARDT

not exist then certainly there are no binary solutions. To this end we state
one of the many (equivalent) results concerning the existence of solutions
to linear inequalities, which is a classic result in linear programming and
optimization:
Theorem 2.14 (Farkas’ Lemma, see [20],[24, Lemma 1, p. 318]). Let A ∈
Rm×n and b ∈ Rm , then exactly one of the following alternatives hold:
(i) There exists x ∈ Rn satisfying Ax = b and x ≥ 0.
(ii) There exists y ∈ Rm satisfying yT A ≥ 0T and yT b < 0.
Remark 2.15. Inequalities involving vectors are understood component-
wise, i.e. x ≥ 0 means each component of x is greater than or equal to
0. A similar interpretation is given to the statement yT A ≥ 0T .
Remark 2.16. The statement yT A ≥ 0T is equivalent to the statement
AT y ≥ 0. (Here, 0T is the 1 × n zero vector.)
Remark 2.17. In Linear System I when we use only a single polyomino
from each series then the vector b in Theorem 2.14 is a vector of all ‘1’s
and so the statement yT b < 0 becomes m
P
y
i=1 i < 0, where yi := {y}i .
If A is a binary matrix and the components of b are positive integers,
then the above result can be strengthened to the rational solution case:
Theorem 2.18. If A ∈ {0, 1}m×n and b ∈ Nm then Theorem 2.14 holds
with x ∈ Qn .
Proof. Suppose the system of equations Ax = b is consistent. If we have a
unique solution then the Gaussian elimination algorithm with exact arith-
metic and partial pivoting applies a finite number of operations (+, −, ×,
÷) to the entries of N ∪ {0} in the augmented matrix [A|b]. Thus the solu-
tion must be rational. If we have an infinite number of solutions then the
solutions are guaranteed to be rational if we choose the free variables to be
rational. 

In the next section we illustrate the applicability of the Farkas’ Lemma

(Theorem 2.14) to our mathematical model with two problems (Example 4.3
and Example 4.4) that are simple enough to be done without the need
for optimization software. However, for larger problems, standard linear
programming techniques applied to the problem

T
 minimize y b

ILP1 : subject to yT A ≥ 0T

y unrestricted in sign


guarantees the existence of a positive rational solution for nonnegative opti-

mal values, i.e. for yT b ≥ 0, which is a necessary condition for the existence
of a binary solution to Ax = b.
 A NEW MODEL FOR TILING WITH POLYOMINOES 107

3. Solving the model

Numerous MATLAB codes, written in support of this research work,
are available at the website http://people.sc.fsu.edu/~jburkardt/m_
src/polyominoes/polyominoes.html. Because of some efficiency issues,
there are separate codes for the cases where we tile with copies of a single
polyomino (‘monohedral case’), or tile with copies of several different poly-
ominoes (‘multihedral case’). Small cases (n < 30) can be solved entirely
with these codes, but for even moderate-sized problems (30 < n < 200),
it is best to write out the linear system as an LP file, and then rely on
high-performance integer linear programming packages such as CPLEX,
GUROBI, or SCIP for the solution. Once that is obtained, there are MAT-
LAB codes to read solutions and produce plots or printouts (see Section 3.2
for more details).

3.1. Direct solution algorithm with MATLAB. We employed a direct

solution method for solving small problems (n < 30) in MATLAB (R2018A),
run on a MacBook Pro (OS X 10.13.6) with 16 GB of memory and 2.7 GHz
Intel Core i7.
The method of computing the solution to a linear system Ax = b is called
a direct method if the solution can be computed using exact arithmetic
with a finite number of operations. Binary linear programming problems of
this type can trivially be solved with O(2n mn) floating point operations via
exhaustive search [59], but this is prohibitive for large problems. We describe
below how we reduce the computational cost of finding binary solutions for
our problem using a direct method, which is then illustrated for some small
problems in Section 4.1.
The first step in our approach for solving Linear System I or II via a direct
method is to reduce the associated augmented matrix [M |b] b to reduced row
echelon form (RREF), denoted [A|b]. Let r := rank(M ). If r < rank([M |b]) b
the system is inconsistent, which implies there does not exist a tiling of the
region R. Assume the system is consistent. If r = n, then we have the
unique (rational) solution α = b. If this is a binary solution then there is
a unique tiling of the region R using the polyominoes in S. If r < n we
must identify the f := n − r free variables and the series to which they
belong. Then to find any binary solutions we choose all possible allowable
binary choices of the free variables, and for each choice check via a back-
substitution procedure (described below) if the solution of the linear system
is binary. The number of binary choices for the free variables depends on
the series they belong to and the number of copies of each polyomino used
in each series. In any particular Series i if we have fi free variables then we
need to consider all ways for at most di of the free variables to be equal to
‘1’, with the remaining free variables in that series equal to ‘0’. This leads to
the following theorem for the number of binary choices of the free variables
we must consider in the direct solution method:
108 MARCUS R. GARVIE AND JOHN BURKARDT

Theorem 3.1. Consider f ≥ 1 free variables P s with fi free variables in Series

i, 0 ≤ fi ≤ si , i = 1, . . . , ns , where f = ni=1 fi . Then the number of possible
binary choices for the free variables to check in the direct solution method is
given by
 f
 2i if fi ≤ di
Yns 

di
!
(3.1) bf := bfi where bfi := X fi .
i=1

 if fi > di
 k
k=0

Proof. In any given series if fi ≤ di then we need all ways of assigning

‘1’s to the free variables up to a maximum of fi . That is, we need all
ways of choosing 0, 1, . . . , fi of the fi free variables equal to ‘1’, yielding
Pfi fi
f
k=0 k = 2 possibilities. If fi > di then we need all ways of assigning
i

‘1’s to at most di free variables, as we use exactly di copies of Pi in Series

i. Thus we need all combinations of choosing 0, 1, . . . , di−1 , di of the fi free
Pdi fi

variables equal to ‘1’, yielding k=0 k possibilities. The result then follows
after applying the Fundamental Counting Principle over all series. 
Corollary 3.2. We have two special cases:
(i) If exactly one polyomino is used from each series, that is di = 1 for all
i, ns > 1, then equation (3.1) reduces to
ns
Y
bf = (1 + fi ).
i=1

(ii) If copies of a single polyomino are used to tile R, i.e. ns = 1, d1 =

cR /c1 then equation (3.1) becomes
 f

 2 if f ≤ d1

d1
!
bf = X f .

 if f > d1

k=0
k

We employ a simple procedure that facilitates the coding of the back-

substitution process for a given binary choice of free variables. Each binary
choice of a free variable is enforced by inserting a new equation back into
the system. For example, for the ith free variable αi = c ∈ {0, 1}, we insert
a new row in the system Aα = b between rows i − 1 and i with a ‘1’ at the
(i, i) position, illustrated below:
i
    
i 0 ··· 0 1 0 ··· 0  αi  =  c  ,

After we have inserted all equations corresponding to the current binary

choices of free variables we have an n × n upper triangular system which we
 A NEW MODEL FOR TILING WITH POLYOMINOES 109

solve via back-substitution. If the ‘solution’ is binary we have found a solu-

tion to the tiling problem. All nonbinary ‘solutions’ are discarded. For the
most efficient implementation of back-substitution, as soon as a nonbinary
variable is computed we halt the procedure, and start the back-substitution
procedure with the next set of free variables. The above procedure is re-
peated for all binary choices of free variables. The direct solution method
is summarized in Algorithm 1 (Figure 6).
110 MARCUS R. GARVIE AND JOHN BURKARDT

Algorithm 1
1: N ← 0
2: Read M and b b from file
3: Compute [A|b] (the RREF of [M |b]) b
4: Compute r := rank(M )
5: if r < rank([M |b]) b then
6: print "System is inconsistent"
7: else if r = n then
8: if b is binary then
9: α←b
10: Save binary solution α to file
11: print "There is a unique binary solution"
12: else
13: print "No binary solution exists"
14: end if
15: else {system has an infinite number of rational solutions}
16: f ←n−r
17: Identify the fk free variables in each Series Sk and compute bfk , for
k = 1, . . . , ns , using
Qns equation (3.1)
18: Compute bf := k=1 bfk
19: for i = 1 to bf do
20: Assign binary values to free variables {fk }nk=1
s

21: Solve Aα = b via back-substitution for the variables

{αn , αn−1 , . . . , α1 }
22: if any αk is not binary then
23: Break for loop
24: end if
25: N ←N +1
26: Write binary solution α to file
27: end for
28: if N = 0 then
29: print "No binary solution exists"
30: else
31: print "There are" N "binary solutions"
32: end if
33: end if

Figure. 6. Direct solution method for solving polyomino tiling problem.

See Section 3.1 for further details.
 A NEW MODEL FOR TILING WITH POLYOMINOES 111

3.2. Solution using integer linear programming packages. Excellent

noncommercial and commercial software for solving large, real-world integer
programming problems have been developed. Among them, we investigated
two commercial optimization solvers, namely
• IBM(R) ILOG(R) CPLEX(R) Interactive Optimizer 12.8.0.0
(CPLEX for short), see
https://www.ibm.com/analytics/cplex-optimizer,
• GUROBI Optimization 7.5.2. (GUROBI for short), see
http://www.gurobi.com
and one noncommercial solver
• SCIP (Solving Constraint Integer Programs) version 6.0.0., see
http://scip.zib.de.
These optimization packages carry out the optimization process by
branch-and-bound algorithms, including some general purpose heuristics.
For a survey of modern advances in the theory of branch-and-bound algo-
rithms see [58].
Linear System I and II can be expressed as integer linear programming
problems in the LP format with no objective function, which for medium-
sized or large problems (200 < n < 70, 000) we solved using CPLEX,
GUROBI, or SCIP. We found CPLEX to be considerably faster than either
GUROBI or SCIP for solving the problems in this paper. The interactive
shell commands used for calculating all feasible solutions are given in Ap-
pendix B. For further details and for the standard shell commands needed
to find a single optimal solution see the links given above. All optimizers
were run on a MacBook Pro (OS X 10.13.6) with 16 GB of memory and 2.7
GHz Intel Core i7.
To solve a particular instance of a tiling problem we employed three steps:
(i) Construct the linear system in MATLAB and export the associated
LP file to an optimizer 4
(ii) Solve the LP file with an optimizer and export the solution file back
to MATLAB
(iii) Extract the solution(s) from the file produced in (ii) in a form that
MATLAB can read and plot the solution(s)
To help other researchers who wish to reproduce our results, or pursue in-
vestigations of their own, the MATLAB ‘LPmake’ files needed to perform
step (i) above for the medium to large problems are available from
http://people.sc.fsu.edu/~jburkardt/m_src/polyominoes.html
(called SCRIPTS) and the MATLAB codes needed to perform step (iii) (called
PLOT_MONO and PLOT_MULTI) for the monohedral and multihedral cases, re-
spectively).

4For GUROBI to solve these problems we found it necessary to make the objective
function in the LP file blank, instead of the default: ‘Obj: 0’.
112 MARCUS R. GARVIE AND JOHN BURKARDT

4. Numerical experiments
4.1. Small problems solved in MATLAB. We demonstrate the direct
solution method with some examples that illustrate the types of solutions
that are possible. Although these examples are very simple, they encapsulate
all the features of larger problems.

Example 4.1 (Tiling with 3 polyominoes). We find all possible ways of

tiling the 2 × 4 rectangle
( )
P = with S= , , ,

all rotations and reflections permitted. Considering all possible placements

of the three polyominoes in the rectangle yields the series:

Series 1 =
 

 
       
1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0
 
, , , ,

 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 

 | {z } | {z } | {z } | {z }

A1,1 A1,2 A1,3 A1,4

Series 2 =



       
0 0 1 0 0 0 0 1 1 0 0 0 0 1 0 0

, , , ,

 1 1 1 0 0 1 1 1 1 1 1 0 0 1 1 1

 | {z } | {z } | {z } | {z }
A2,1 A2,2 A2,3 A2,4


       

1 1 1 0 0 1 1 1 1 1 1 0 0 1 1 1

, , , ,
1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1  
| {z } | {z } | {z } | {z }

A2,5 A2,6 A2,7 A2,8

Series 3 =



       
1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1

, , , ,

 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

| {z } | {z } | {z } | {z }
A3,1 A3,2 A3,3 A3,4



       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

, , , .
1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1  
| {z } | {z } | {z } | {z }

A3,5 A3,6 A3,7 A3,8
 A NEW MODEL FOR TILING WITH POLYOMINOES 113

The binary matrix associated with the region R is

 
1 1 1 1
B= .
1 1 1 1
We have m = cR + ns = 8 + 3 = 11 and n = s1 + s2 + s3 = 4 + 8 + 8 = 20.
So Problem I becomes
Seek parameters αi,j ∈ {0, 1}, 1 ≤ i ≤ 3, 1 ≤ j ≤ si such
that
si
3 X
X si
X
i,j
αi,j A = B, subject to αi,j = 1, i = 1, 2, 3,
i=1 j=1 j=1

which yields an underdetermined linear system M α = b b with 11 equations

in 20 unknowns corresponding to Linear System I. If we neglect the last 3
constraint equations, then the columns of M are simply the elements of the
binary matrices Ai,j written row-wise, taken in the order in which they are
given above. The right-hand-side vector is a vector of all ones. The reduced
row echelon form of the associated augmented matrix is given by:

[A|b] =
α1,1 α1,2 α1,3 α1,4 α2,1 α2,2 α2,3 α2,4 α2,5 α2,6 α2,7 α2,8 α3,1 α3,2 α3,3 α3,4 α3,5 α3,6 α3,7 α3,8
0 2 −1 0 −1 −1 −1 −2 −1 0 −2 −1
 
1 0 0 0 0 0 1 0 0

 0 1 0 0 0 0 −1 0 0 0 0 1 0 1 1 1 1 0 1 1 1 

 0 0 1 0 0 0 1 0 0 0 0 −1 0 0 −1 0 0 0 0 −1 0 


 0 0 0 1 0 0 −1 0 0 0 −2 1 0 0 1 0 1 1 −1 2 1 

 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 


 0 0 0 0 0 1 1 0 0 0 1 0 0 −1 −1 0 −1 −1 0 −1 0 


 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 1 0 0 


 0 0 0 0 0 0 0 0 1 0 −1 1 0 0 0 0 1 0 −1 1 1 

 0 0 0 0 0 0 0 0 0 1 −1 0 0 0 0 0 0 1 −1 0 0 

 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
The variables corresponding to each column are indicated with vertical lines
separating the series they are associated with and pivots are circled. The
system is clearly consistent with 10 = r < n = 20, so there are f = n−r = 10
free variables:
Series 1: −
Series 2: α2,3 , α2,7 , α2,8
Series 3: α3,2 , α3,3 , α3,4 , α3,5 , α3,6 , α3,7 , α3,8
In each series only a single free variable can be equal to 1 at a time, or
all members of that series can be zero, yielding (see Corollary 3.2, part (i))
bf = (1 + 0)(1 + 3)(1 + 7) = 32 possible binary choices of free variables to
check. Solving the linear systems via back-substitution for all possible choices
of free variables as described in Section 3.1 yields the following four binary
solutions:
114 MARCUS R. GARVIE AND JOHN BURKARDT

α1,1 α1,2 α1,3 α1,4 α2,1 α2,2 α2,3 α2,4 α2,5 α2,6 α2,7 α2,8 α3,1 α3,2 α3,3 α3,4 α3,5 α3,6 α3,7 α3,8

0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0
1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1

The four corresponding tilings are shown below:

(a) Tile 1. (b) Tile 2. (c) Tile 3. (d) Tile 4.

Figure. 7. The 4 possible ways to tile R.

These tilings are trivial variations of each other obtained by rotating or

reflecting the whole rectangle. Thus ignoring these variations yields just one
way to tile the region.
Example 4.2 (Tiling with a single polyomino). We solve the simple example
given by Reid [68] introduced at the start of this paper. Initially we calculate
all binary matrices corresponding to the placements of a domino in the region
R (illustrated in Figure 3). We have m = cR = 8, n = s1 = 10, (ns = 1).
So Problem II becomes
Seek parameters α1,j ∈ {0, 1}, 1 ≤ j ≤ 10 such that
10
X
α1,j A1,j = B,
j=1

which yields an underdetermined linear system M α = b b with 8 equations

in 10 unknowns corresponding to Linear System II. The columns of M are
simply the elements of the binary matrices Ai,j written row-wise, taken in the
order in which they are given above, but neglecting the entries in the (1, 3)
positions. The right-hand-side vector is a vector of all ones. The reduced
row echelon form of the associated augmented matrix is given by:

 α1,1 α1,2 α1,3 α1,4 α1,5 α1,6 α1,7 α1,8 α1,9 α1,10 
1 0 0 0 0 0 1 0 −1 0 0
 0 1 0 0 0 0 0 0 1 0 1
 
 0 0 1 0 0 0 1 0 −1 0 0
 
 0 0 0 1 0 0 0 0 1 1 1
[A|b] = 
 0 0 0 0 1 0 0 0 0 1

 1
 0 0 0 0 0 1 −1 0 1 0 1
 
 0 0 0 0 0 0 0 1 0 −1 0
0 0 0 0 0 0 0 0 0 0 0
 A NEW MODEL FOR TILING WITH POLYOMINOES 115

The variables associated with each column are indicated and the pivots have
been circled. The system is clearly consistent with 7 = r < n = 10, so there
are f = n − r = 3 free variables: α1,7 , α1,9 , and α1,10 . As d1 = cR /c1 = 4
we have bf = 23 binary choices for the free variables to check for (see Corol-
lary 3.2, part (ii)). Solving the linear systems via back-substitution for all
possible choices of free variables as described in Section 3.1 yields the fol-
lowing four binary solutions:

α1,1 α1,2 α1,3 α1,4 α1,5 α1,6 α1,7 α1,8 α1,9 α1,10

0 1 0 1 1 1 0 0 0 0
0 1 0 0 0 1 0 1 0 1
1 0 1 0 1 0 0 0 1 0
0 0 0 0 1 1 1 0 1 0

The four corresponding tilings are shown below:

(a) Tile 1. (b) Tile 2. (c) Tile 3. (d) Tile 4.

Figure. 8. The 4 possible ways to tile R.

Ignoring trivial differences due to rotating and reflecting, the whole tiled
region yields just two different tilings.

Example 4.3 (Rational solutions of the relaxed system). Consider tiling

( )
P = with S= , ,

all rotations and reflections permitted. There is obviously no tiling. We

have c1 = 4, c2 = 2, cR = 6, and with d1 = d2 = 1 there is a solution
to the linear Diophantine equation c1 d1 + c2 d2 = cR , thus a solution to the
relaxed Linear System I may exist. We prove there exists a positive rational
solution. Initially we calculate all possible binary matrices corresponding to
the placements of the two polyominoes in the rectangle.
We have m = cR + ns = 6 + 2 = 8 and n = s1 + s2 = 2 + 7 = 9, which
leads to the underdetermined linear system M α = b b with 8 equations in 9
unknowns corresponding to Linear System I. For any vector y ∈ R8 , the
116 MARCUS R. GARVIE AND JOHN BURKARDT

linear inequalities yT M ≥ 0T become

y2 + y4 + y5 + y6 + y7 ≥0 (1)
y1 + y2 + y3 + y5 + y7 ≥0 (2)
y1 + y2 + y8 ≥0 (3)
y2 + y3 + y8 ≥0 (4)
y4 + y5 + y8 ≥0 (5)
y5 + y6 + y8 ≥0 (6)
y1 + y4 + y8 ≥0 (7)
y2 + y5 + y8 ≥0 (8)
y3 + y6 + y8 ≥0 (9)
P8
Adding inequalities (1), (2), (7), and (9) yields 2 i=1 yi ≥ 0, which is a
b = P8 yi < 0. Thus from Theorem 2.18
contradiction to the statement yT b i=1
and Theorem 2.14 we conclude there exists a nonnegative rational solution
to the system M α = b. b Indeed, it is easy to verify that α1,1 = α1,2 = α2,5 =
α2,7 = 1/2 is a solution as equation (2.4a) of Problem I becomes
         
1 0 1 0 1 1 1 1 1 1 0 0 1 0 0 1 1 1 1
+ + + = .
2 1 1 1 2 0 1 0 2 1 0 0 2 0 0 1 1 1 1
Example 4.4 (Unique rational solution of the relaxed system). Consider
tiling ( )
P = with S= ,

all rotations and reflections permitted. There is obviously no tiling. We show

there exists a unique rational solution. After calculating all binary matrices,
we have m = cR = 5, n = s1 = 5, (ns = 1), which leads to the linear system
of equations M α = b b with 5 equations in 5 unknowns corresponding to
Linear System II. For any vector y ∈ R5 , the linear inequalities yT M ≥ 0T
become
y1 + y3 + y4 ≥0
y2 + y4 + y5 ≥ 0
y1 + y2 + y3 ≥0
y1 + y2 + y4 ≥0
y2 + y3 + y4 ≥0
which together with yT b b = 5 yi < 0 is satisfied by y = (1 1 − 2 1 − 2)T .
P
i=1
Thus from Theorem 2.14 and Theorem 2.18 it follows there does not exist
a positive rational solution to M α = b. b However, it is easy to check that
this system is consistent (rank(M ) = 5 = rank([M |b])).
b Indeed, Gaussian
elimination yields the unique solution:
α1,1 = 2/3, α1,2 = 1, α1,3 = 2/3, α1,4 = −1/3, α1,5 = −1/3,
 A NEW MODEL FOR TILING WITH POLYOMINOES 117

and equation (2.5) becomes

         
2 1 0 0 0 1 0 2 1 1 0 1 1 1 0 1 0 1 0
+ + − −
3 1 1 0 0 1 1 3 1 0 0 3 0 1 0 3 1 1 0
 
1 1 0
= .
1 1 1

Example 4.5 (No solution of any kind). Let

( )
P = with S= , ,

all rotations and reflections permitted. There is obviously no tiling. How-

ever, we have c1 = 3, c2 = 2, and cR = 5, so with d1 = d2 = 1 we have
a nonnegative integer solution to c1 d1 + c2 d2 = cR . After calculating the
binary matrices, we have m = cR + ns = 7, n = s1 = 8, which leads to
the linear system of equations M α = b b with 7 equations in 8 unknowns
corresponding to Linear System I. After reducing the associated augmented
matrix to reduced row echelon form we find

rank(M ) = 5 < rank([M |b])

b = 6,

thus the system of equations is inconsistent.

4.2. Larger problems solved with optimization packages. We present

some medium to large (200 < n < 70, 000) tiling examples that illustrate
the range of problems that can be solved with the methodology outlined in
Section 3.2.

Example 4.6. For our first example we investigated the problem of enu-
merating all possible solutions to tiling the 5 × 18 rectangle with 30 copies
of a single L-triomino:
( )
S= .

All rotations and reflections are permitted. The binary linear programming
problem has 272 variables with 91 constraints. A particular solution com-
puted using CPLEX is shown in Figure 9a. CPLEX, GUROBI and SCIP
successfully found 1, 168, 512 solutions in 3.8 minutes, 2.8 hours, and 8.6
minutes, respectively, which is in agreement with results reported at [36]. If
we neglect trivial variations due to rotating and reflecting the whole board
this yields a total of 1, 168, 512/4 = 292, 128 solutions.

Example 4.7. For our second example we enumerated the total number of
solutions to tiling the 10 × 6 rectangle with each of the 12 free pentominoes
(often labelled with the letters - F, I, L, N, P, T, U, V, W, X, Y, and Z.
118 MARCUS R. GARVIE AND JOHN BURKARDT

which are indicative of the polyomino shapes):

(
S= , , , ,

, , , ,

)
, , ,

All rotations and reflections are permitted. The binary linear programming
problem has 2, 056 variables with 73 constraints. This example is a classic
problem of tiling with polyominoes. A particular solution computed using
CPLEX is shown in Figure 9b. CPLEX, GUROBI and SCIP successfully
found 9, 356 solutions in 7.3 minutes, 77.4 minutes, and 89.9 minutes, re-
spectively, which is in agreement with the first reporting of this result in
1960 [40], and at numerous websites (e.g. [36]). If we neglect trivial vari-
ations due to rotating and reflecting the whole board this yields a total of
9, 356/4 = 2, 339 solutions.
The next two examples demonstrate the capability of our method to tile
nonrectangular regions, or regions containing ‘holes’.
Example 4.8. We tile an L-shaped region with 4 copies of each of the fol-
lowing 8 octominoes5:

(
S= , , , ,

)
, , ,

5There are 369 free octominoes [66].

 A NEW MODEL FOR TILING WITH POLYOMINOES 119

All rotations and reflections are permitted. The binary linear programming
problem has 9, 878 variables with 265 constraints. CPLEX and SCIP suc-
cessfully found a single (optimal) solution in 12.8 minutes and 13.1 hours,
respectively, however GUROBI failed to find a solution in over 14 hours of
computation. The solution shown in Figure 10a was computed in CPLEX.
Example 4.9. We tiled an 11 × 11 square with four 2 × 2 holes using
the 12 free pentominoes (see Example 4.7) with copies6. All rotations and
reflections are permitted. The binary linear programming problem has 2, 619
variables with 118 constraints. CPLEX, GUROBI, and SCIP successfully
found a single (optimal) solution in 0.4, 1.5, and 15.9 seconds, respectively.
The solution shown in Figure 10b was computed in CPLEX.
The last two examples illustrate the capability of our method to tile large
problems, either with copies of a single polyomino, or with copies of a set of
pieces.
Example 4.10. We tile a 60 × 60 square with 600 copies of a single hex-
omino: ( )
S= .

All rotations and reflections are permitted. The binary linear programming
problem has 26, 912 variables with 3, 601 constraints. CPLEX found a single
(optimal) solution (see Figure 11) in 1.9 hours, however SCIP and GUROBI
failed to find a solution in over 14 hours of computation.
Example 4.11. For our final example we tile the 40 × 30 rectangle using 20
copies each of the 12 free pentominoes (see Example 4.7). All rotations and
reflections permitted. The binary linear programming problem has 67, 396
variables with 1, 213 constraints. CPLEX found a single (optimal) solution
(see Figure 12) in 9.5 minutes, however SCIP and GUROBI failed to find a
solution in over 14 hours of computation.

6With the naming convention of Example 4.7 we used the following numbers of copies
of the free pentominoes: V, W, and Z - a single copy each; all other pieces utilized two
copies each.
120 MARCUS R. GARVIE AND JOHN BURKARDT

(a) Tiling the 5 × 18 rectangle. (b) Tiling the 10 × 6 rectangle.

Figure. 9. Tiling rectangular regions. (a) See Example 4.6. We tile

with 30 copies of a single L-triomino. (b) See Example 4.7. We tile with
a full set of the 12 free pentominoes.

(a) Tiling an L-shaped region. (b) Tiling a square with 4 holes.

Figure. 10. Two medium-sized tiling problems. (a) See Example 4.8.
We tile with 4 copies of 8 octominoes. (b) See Example 4.9. We tile
with copies of the 12 free pentominoes. See the text for further details
concerning the tiles used.
 A NEW MODEL FOR TILING WITH POLYOMINOES 121

Figure. 11. See Example 4.10. 600 copies of a single hexomino tile a
60 × 60 square.
122 MARCUS R. GARVIE AND JOHN BURKARDT

Figure. 12. See Example 4.11. We tile the 40 × 30 rectangle with 20

copies of each of the 12 free pentominoes.
 A NEW MODEL FOR TILING WITH POLYOMINOES 123

Experiment 4.12. We investigated the relationship between the time it

takes for CPLEX to find an optimal solution to a tiling problem (‘runtime’)
and the size of the problem (measured by the area of the region to be tiled).
For simplicity and to avoid confounding results with different geometries we
used copies of a single L-triomino (see Example 4.6) to tile a sequence of
squares of increasing size:
P := [45 + 3k] × [45 + 3k], k = 0, 1, . . . , 29.
The runtimes (in seconds) versus the areas of the square regions tiled are
shown in Figure 13 (dashed line with triangular markers). The exponential
regression curve for the data is also plotted with a solid line and round
markers, and has the approximate equation
runtime = 2.15e3.87×10 ·area ,
−4

with a correlation coefficient of r = 0.865. The runtimes double after each

increase in area of about 1, 791 cells.

2,500
Runtimes vs Area
Exponential regression curve
2,000
Runtime (sec)

1,500

1,000

500

0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8
Area of square regions (# cells) ·104

Figure. 13. CPLEX runtimes versus area of square regions tiled with
L-triominoes.

The ‘saw-tooth’ shape of the data merits some discussion. The lower data
points in the ‘saw-tooth’ pattern correspond to areas divisible by 6 while the
upper data points correspond to areas divisible by 3, but not 6. As the L-
triomino tiles a 6 × 6 square it is plausible that optimal solutions are found
124 MARCUS R. GARVIE AND JOHN BURKARDT

more readily when the area is divisible by 6. If this were the case we might
expect the optimal tiling of areas divisible by 6 to be predominantly filled with
6 × 6 blocks, where each block is tiled by 12 L-triominoes. We checked if this
was the case for the 66 × 66 square and it was not (details omitted). Further
investigations are needed to explain this behaviour.

5. Conclusions
The main contribution of this paper is to present the first general system-
atic algebraic approach for tiling finite subsets of Z2 with polyominoes. The
resulting mathematical model can be solved via direct solution techniques
(see Algorithm 1), or expressed as a binary linear programming problem in
MATLAB and solved using high-performance optimization packages, for ex-
ample, CPLEX, SCIP, or GUROBI. To the best of our knowledge, all current
general purpose algorithms for tiling regions of the plane with polyominoes
employ backtracking techniques for exhaustively finding solutions with a
computer. We illustrated our methodology for small problems (n < 30) in
MATLAB, and for medium to large problems (200 < n < 70, 000) we used a
combination of MATLAB and high-performance optimization packages. We
found the CPLEX optimizer to be much faster than either SCIP or GUROBI
for solving the problems in this paper.
We make no claims regarding the efficiency of our methodology. Indeed,
preliminary investigations using the optimized C++ backtracking software
(POLYCUBE), freely available at [11], indicate this package to be consid-
erably faster than our approach (details omitted). There are a couple of
reasons that may explain this. Firstly, the backtracking algorithms for
tiling remain entirely in the discrete realm, however, with our optimiza-
tion approach we must sift through the rational solutions to find the binary
solutions. Another reason that can make backtracking fast is that the code
can be tailored to the specific problem being solved. For example, one can
choose to place pieces in the target region first that are most constrained.
Regardless of the method employed, as the problem of tiling finite regions of
the plane with polyominoes is in general N P-complete (see the discussion in
Section 1), there will always be an upper bound on the size of the problems
that can be solved. This was illustrated by the results of Experiment 4.12
in Section 4.2, which confirmed numerically that tiling finite regions of the
plane with the L-triomino is N P-complete [57]. With our approach that
upper bound is determined in large part by the efficiency of the particu-
lar optimization package employed. There have been huge advances made
in recent decades for solving mixed-integer and integer linear programming
problems [48, 54]. As advances are made (in software and hardware) for solv-
ing integer linear programming problems, the efficiency of our methodology
for tiling with polyominoes will also improve.
There are several advantages of the methodology employed in this paper
for tiling with polyominoes compared to the backtracking methods. Firstly,
 A NEW MODEL FOR TILING WITH POLYOMINOES 125

as the tiling problem has been converted into an algebraic model, the struc-
ture, combinatorial nature, and solvability of the model can be analyzed
(see for example Theorem 2.14, Theorem 2.18, and Theorem 3.1). For ex-
ample, the standard condition involving rank can be efficiently applied to
determine if the associated linear system of equations is consistent. In prin-
ciple, it should also be possible to construct a solver that is tailored to
the properties of the linear systems. It is the subject of a follow-up paper
to investigate the efficiency of an optimized C++ version of Algorithm 1.
A second advantage of our mathematical model is its flexibility. Ignoring
memory and efficiency considerations, there are no limitations on: the ge-
ometry of the region to be tiled; the number of different pieces used; or
the total number of pieces (including copies) that are used to tile a spe-
cific region. If the constraints in Problem I are neglected, then we do not
have to specify beforehand how many copies of each polyomino are to be
used7. A third advantage of our methodology is that the underlying code
for constructing the mathematical model is freely available as a suite of
MATLAB programs (see http://people.sc.fsu.edu/~jburkardt/m_src/
polyominoes/polyominoes.html). Thus other researchers can reproduce
our numerical results, or use it as a starting point for their own investiga-
tions.
The techniques developed in this paper may have more general applica-
bility. As the problem of tiling regions of the plane with polyominoes is an
example of an exact cover problem [45], it would be interesting to investigate
if our methodology can be adapted to tackle other exact cover problems. For
example, the n-queens problem [7], Sudoku [74], and edge-matching puzzles
[50] are examples of mathematical puzzles and games that can be repre-
sented as exact cover problems. Applications that can be modelled as exact
cover problems include Integrated Circuit Design [41], 3D Printing [79], and
Cloud Computing [14].
There are some additional lines of enquiry we can pursue with our math-
ematical model. For example, it would be interesting to investigate least
squares approximations of Linear System I and II. When the linear system
is inconsistent, and cells in a tiling are allowed to overlap, the least squares
solution corresponds to a weighted sum of pieces that minimizes the sum
of the squared deviations. In this context, a deviation corresponds to the
mismatch between the ‘height’ of a cell in the target region and unity. Thus
even when a given set of polyominoes does not tile the target region, we can
seek an approximate solution in the least squares sense. This is an approach
that is not possible with backtracking methods as backtracking methods
remain entirely in the discrete realm.
In addition to investigating the efficiency of an optimized C++ implemen-
tation of Algorithm 1 (see the comments above), it might be advantageous

7Although such an approach would lead to a much more computationally expensive

optimization problem.
126 MARCUS R. GARVIE AND JOHN BURKARDT

to apply a parallel computing approach to the direct solution method for

solving our model. This is because the binary choices for each of the bf sets
of free variables can be tested independently (see Section 3.1), which would
significantly reduce runtimes of a solver.
Finally, we mention that our methodology can be smoothly generalized to
tiling problems in higher dimensional spaces Zd , d ≥ 3, using polycubes [1].
An example for the case d = 3 is the ‘somacube’ puzzle, where seven pieces
made from unit cubes are used to tile a 3 × 3 × 3 cube. There are exactly 240
distinct configurations [63]. We leave this task, and other investigations, for
future work.

Appendix A. Notation
For the convenience of the reader we summarize the main notation used
in Table 1.
Table 1
Main notation used.

Symbol Definition
R The polyomino to be tiled
cR The order of R
B Lattice for the rectangular r × c hull of R
B ∈ {0, 1}r×c Binary matrix associated with B
ns Number of series (= number of free polyominoes)
S Set of free polyominoes Pi
Pi ith free polyomino
ci Order of Pi
si Number of ways each Pi fits in R (= number of binary
matrices Ai,j in Series i)
di Number of copies of Pi used to tile R
Ai,j ∈ {0, 1}r×c Binary matrix associated with j ways of fitting Pi in R
n Total number of binary matrices Ai,j (= number of un-
knowns in linear systems)
αi,j ∈ {0, 1} Number of times the jth placement of Pi is used to tile R
np Number of polyominoes used to tile R
m Number of equations in Linear System I, or II
M ∈ {0, 1}m×n Coefficient matrix of Linear System I or II
α ∈ {0, 1}n Solution vector for Linear System I or II
b
b Right-hand-side vector for Linear System I or II
N Number of binary solutions of Linear System I or II
[A|b] Reduced row echelon form of [M |b] b
r Rank of M
f n − r (= number of free variables in [A|b])
fi Number of free variables in Series i
bfi Number of binary choices for the free variables in Series i
bf Number of binary choices for all free variables
 A NEW MODEL FOR TILING WITH POLYOMINOES 127

Appendix B. Shell commands for calculating all feasible

solutions
B.1. Shell commands for CPLEX.
1. Set the absolute gap for the solution pool to zero:
CPLEX> set mip pool absgap 0.0
2. Aggressively seek all solutions:
CPLEX> set mip pool intensity 4
3. Set the upper bound on the number of solutions sought to N :
CPLEX> set mip limits populate N
4. Set the upper bound on the number of solutions stored to be N :
CPLEX> set mip pool capacity N
5. Specify that all solutions found will be written out to file:
CPLEX> set output writelevel 1
6. Read the LP file:
CPLEX> read test.lp
7. Calculate all solutions and store them:
CPLEX> populate
8. Write all solutions to a file:
CPLEX> write test.sol all

B.2. Shell commands for SCIP.

1. Read the LP file:
SCIP> read test.lp
2. Set some parameters needed for collecting all feasible solutions:
SCIP> set emphasis counter
SCIP> set constraints countsols collect TRUE
3. Calculate all feasible solutions:
SCIP> count
4. Write all solutions to file:
SCIP> write allsolutions test.txt

B.3. Shell commands for GUROBI. The following line of code: reads
the LP file, sets the upper bound on the number of solutions sought to N ,
calculates all feasible solutions, and saves the solutions to file:
> gurobi_cl PoolSearchMode=2 PoolSolutions=N PoolGap=0
ResultFile=test.sol test.lp

Acknowledgments
We gratefully acknowledge the helpful comments of: Matthew Busche,
Laurence Garvie, Steven Gismondi, Herb Kunze, Rajesh Pereira, and Allan
Willms. We are also very grateful to an anonymous referee for their careful
corrections and valuable suggestions that improved this paper.
128 MARCUS R. GARVIE AND JOHN BURKARDT

References
1. G. Aleksandrowicz and G. Barequet, Counting polycubes without the dimensionality
curse, Discrete Math. 309 (2009), 4576–4583.
2. F. Ardila and R. Stanley, Tilings, Math. Intelligencer 32 (2010), no. 4, 32–43.
3. J. M. Ash and S. W. Golomb, Tiling deficient rectangles with trominoes, Math. Mag.
77 (2003), no. 1, 46–55.
4. D. Ashlock and L. Taylor, Evolving polyomino puzzles, Proceedings of the IEEE 2016
Congress on Evolutionary Computation, IEEE Congress on Evolutionary Computa-
tion, IEEE, Vancouver, 2016, pp. 327–334.
5. B. Banerjee, L. Kraemer, and J. Lyle, Multi-agent plan recognition: Formalization and
algorithms, Proceedings of the twenty-fourth AAAI conference on artificial intelligence
(AAAI-10), Book Series: Lecture Notes in Artificial Intelligence, Conference: 24th
AAAI Conference on Artificial Intelligence (AAAI), Atlanta, GA, 2010, pp. 1059–
1064.
6. D. Battalion, M. Bouvel, A. Frosini, and S. Rinaldi, Permutation classes and poly-
omino classes with excluded submatrices, Math. Struct. in Comp. Science 27 (2017),
157–183.
7. J. Bell and B. Stevens, A survey of known results and research areas for n-queens,
Discrete Math. 309 (2009), no. 1, 1–31.
8. R. Berger, The undecidability of the domino problem, Mem. Amer. Math. Soc. 66
(1966), 1–72.
9. O. Bodini, Tiling a rectangle with polyominoes, Discrete Math. Theor. Comput. Sci.
AB(DMCS) (2003), 81–88.
10. M. Braun, T. Etzion, P. R. J. Östergård, A. Vardy, and A. Wassermann, Existence of
q-analogs of steiner systems, Forum Math. Pi e7, 14 pp. (2016).
11. M. Busche, Solving polyomino and polycube puzzles. algorithms, software, and solu-
tions, http://www.mattbusche.org/blog/article/polycube/ (2 July 2020).
12. G. Castiglione, A. Frosini, A. Restivo, and S. Rinaldi, Enumeration of L-convex poly-
ominoes by rows and columns, Theoret. Comput. Sci. 347 (2005), 336–352.
13. R. D. Chatham, M. Doyle, J. J. Miller, A. M. Rogers, R. D. Skaggs, and J. A. Ward,
Algorithm performance for chessboard separation problems, J. Combin. Math. Combin.
Comput. 70 (2009), 127–142.
14. B. A. Cheikh, An exact cover-based approach for service composition, 2016 IEEE
International Conference on Web Services (ICWS), IEEE Computer Society, 2006,
pp. 631–636.
15. J. L. Conway and J. C. Lagarias, Tiling with polyominoes and combinatorial group
theory, J. Combin. Theory Ser. A 53 (1990), no. 2, 183–208.
16. M. Cwiek and J. Nalepa, Spatial planning as a hexomino puzzle, Intelligent Infor-
mation and Database Systems, ACIIDS 2017, Pt 1, Book Series: Lecture Notes in
Artificial Intelligence, vol. 10191, Conference: 9th Asian Conference on Intelligent In-
formation and Database Systems (ACIIDS), Kanazawa, JAPAN, 2017, pp. 410–420.
17. N. G. de Bruijn, Programmeren van de pentomino puzzle, Euclides 47 (1971/72),
90–104.
18. A. Del Lungo, E. Duchi, A. Frosini, and S. Rinaldi, On the generation and enumeration
of some classes of convex polyominoes, Electron. J. Combin. 11 (2004), no. 1, 1–46.
19. M.-P. Delest and G. Viennot, Algebraic languages and polyominoes enumeration, The-
oret. Comput. Sci. 34 (1984), no. 1-2, 169–206.
20. J. Farkas, Über die Theorie der einfachen Ungleichungen, Journal für riene und ange-
wandte Mathematik 121 (1902), 1–27.
21. S. Feretić, A perimeter enumeration of column-convex polyominoes, Discrete Math.
Theor. Comput. Sci. 9 (2007), no. 1, 57–83.
 A NEW MODEL FOR TILING WITH POLYOMINOES 129

22. J. G. Fletcher, A program to solve the pentomino problem by the recursive use of
macros, Communications of the ACM 8 (1965), no. 10, 621–623.
23. A. Fontaine and G. E. Martin, Polymorphic polyominoes, Math. Mag. 57 (1984), no. 5,
275–283.
24. D. Gale, H. W. Kuhn, and A. W. Tucker, Linear programming and the theory of
games, Activity Analysis of Production and Allocation (T.C. Koopmans, ed.), John
Wiley & Sons, New York, 1951, pp. 317–329.
25. M. R. Garey and D. S. Johnson, Computers and intractability: A guide to the theory
of NP-Completeness, W. H. Freeman and Company, San Francisco, 1979.
26. S. W. Golomb, Checker boards and polyominoes, Amer. Math. Monthly 61 (1954),
no. 10, 675–682.
27. , Tiling with polyominoes, J. Combinatorial Theory 1 (1966), 280–296.
28. , Polyominoes which tile rectangles, J. Combin. Theory Ser. A 51 (1987), 117–
124.
29. , Tiling rectangles with polyominoes, Math. Intelligencer 18 (1996), no. 2, 38–
47.
30. S. W. Golomb and L. D. Baumert, Backtrack programming, J. Ass. Comp. Machinery
12 (1965), no. 4, 516–524.
31. S. W. Golomb and D. A. Klarner, Polyominoes, Handbook of discrete and compu-
tational geometry (J.E. Goodman and J. O’Rourke, eds.), Chapman & Hall / CRC,
Atlanta, GA, 2nd ed., 2004, pp. 331–352.
32. S.W. Golomb, Polyominoes, Scribner, New York, 1965.
33. , Tiling with sets of polyominoes, J. Combinatorial Theory 9 (1970), 60–71.
34. , Polyominoes, second ed., Princeton University Press, Princeton, NJ, 1994.
35. A. Goupil, H. Cloutier, and F. Nouboud, Enumeration of polyominoes inscribed in a
rectangle, Discrete Appl. Math. 158 (2010), no. 18, 2014–2023.
36. D. O. Grekov, Polyomino tilings, http://polyominoes.org/data/ (3 August 2018).
37. B. Grünbaum and G.C. Shephard, Tilings and patterns, W. H. Freeman and Company,
New York, 1987.
38. V. Gruslys, I. Leader, and T. S. Tan, Tiling with arbitrary tiles, Proc. London Math.
Soc. 3 (2016), no. 112, 1019–1039.
39. A. J. Guttman, History and introduction to polygon models and polyominoes, Polygons,
Polyominoes and Polycubes (A.J. Guttman, ed.), Lecture Notes in Physics, vol. 775,
Springer, Dordrecht, 2009.
40. C. B. Haselgrove and J. Haselgrove, A computer program for pentominoes, Eureka 23
(1960), no. 2, 16–18.
41. I. Hui-Ru and H.-Y. Chang, Multiple patterning layout decomposition considering com-
plex coloring rules and density balancing, IEEE transactions on computer-aided design
of integrated circuits and systems 36 (2017), no. 12, 2080–2092.
42. D. A. Klarner, Packing a rectangle with congruent n-ominoes, J. Combinatorial Theory
7 (1969), 107–115.
43. D. A. Klarner and R. L. Rivest, A procedure for improving the upper bound for the
number of n-ominoes, Can. J. Math. 25 (1973), no. 3, 585–602.
44. , Asymptotic bounds for the number of convex n-ominoes, Can. J. Math. 25
(1974), no. 8, 31–40.
45. D. Knuth, Dancing links, Millennial Perspectives in Computer Science, proceedings
of the 1999 Oxford-Microsoft Symposium in honour of Professor Sir Antony Hoare
(J. Davies, B. Roscoe, and J. Woodcock, eds.), Cornerstones of Computing, Palgrave
Macmillan, 2000, p. 432.
46. , Selected papers on fun & games, CSLI Lecture Notes; no. 192, CSLI Publica-
tions, Stanford, CA, 2011.
130 MARCUS R. GARVIE AND JOHN BURKARDT

47. , The art of computer programming, fascicle 5: Mathematical preliminaries

redux; introduction to backtracking; dancing links, vol. 4, Addison-Wesley, Boston,
2020.
48. T. Koch, T. Achterberg, E. Andersen, O. Bastert, T. Berthold, and R. E. Bixby,
Mixed integer programming library version 5, Math. Prog. Comp. 3 (2011), 103–163.
49. M. Korn and I. Pak, Tilings of rectangles with T-tetrominoes, Theoret. Comput. Sci.
319 (2004), no. 1-3, 3–27.
50. S. Z. Kovalsky, D. Glasner, and R. Basri, A global approach for solving edge-matching
puzzles, SIAM J. Imaging Sciences 8 (2015), no. 2, 916–938.
51. P. Leroux, E. Rassart, and A. Robitaille, Enumeration of symmetry classes of convex
polyominoes in the square lattice, Adv. in Appl. Math. 21 (1998), no. 3, 343–380.
52. D. K. Lilly, Solving general lattice puzzles, Frontiers in Algorithmics, Book Series:
Lecture Notes in Computer Science, vol. 6213, Conference: 4th International Frontiers
of Algorithmics, Wuhan Univ, Wuhan, China, 2010, pp. 124 –.
53. D.K. Lilly, Complexity of solvable cases of the decision problem for predicate calculus,
19th Annual Symposium on Foundations of Computer Science, IEEE, Long Beach,
Calif., 1978, pp. 35–47.
54. A. Lodi, Mixed integer programming computation, 50 Years of Integer Programming
1958-2008 (M. Jünger, T.M. Liebling, D. Naddef, G.L. Nemhauser, W.R. Pulleyblank,
G. Reinelt, G. Rinaldi, and L.A. Wolsey, eds.), Springer-Verlag, Berlin, 2010, pp. 410–
420.
55. W. R. Marshall, Packing rectangles with congruent polyominoes, J. Combin. Theory
Ser. A 77 (1997), 181–192.
56. B.-M. Mireille, Codage des polyominos convexes et équations pour l‘énumération suiv-
ant l‘aire, Discrete Appl. Math. 48 (1994), no. 1, 21–43.
57. C. Moore and J. M. Robson, Hard tiling problems with simple tiles, Discrete Comput.
Geom. 26 (2001), 573–590.
58. D. R. Morrison, S. H. Jacobson, J. J. Sauppe, and E. C. Sewell, Branch-and-bound
algorithms: A survey of recent advances in searching, branching, and pruning, Discrete
Optim. 19 (2016), 79–102.
59. G. L. Nemhauser and L. A. Wolsey, Integer and combinatorial optimization, John
Wiley & Sons, New York, 1988.
60. I. Pak, Ribbon tile invariants, Trans. Amer. Math. 352 (2000), no. 2, 5525–5561.
61. , Tile invariants: new horizons, Theoret. Comput. Sci. 303 (2003), 303–331.
62. C. H. Papadimitriou and K. Stieglitz, Combinatorial optimization: algorithms and
complexity, Prentice-Hall, Inc., Englewood Cliffs, N.J., 1982.
63. C. Peter-Orth, All solutions of the soma cube puzzle, Discrete Math. 57 (1985), no. 1-2,
105–121.
64. J. L. Ramı́rez Alfonsin, The Diophantine Frobenius problem, Oxford Lecture Series in
Mathematics and its Applications, vol. 30, Oxford University Press, Oxford, 2005.
65. D. A. Rawsthorne, Tiling complexity of small n-ominoes (n < 10), Discrete Math. 70
(1988), no. 1, 71–75.
66. D. H. Redelmeier, Counting polyominoes: yet another attack, Discrete Math. 36
(1981), no. 2, 191–203.
67. M. Reid, Tiling rectangles and half strips with congruent polyominoes, J. Combin.
Theory Ser. A 80 (1997), no. 1, 106–123.
68. , Tile homotopy groups, L’ Enseignement Mathématique 49 (2003), 123–155.
69. , Klarner systems and tiling boxes with polyominoes, J. Combin. Theory Ser.
A 111 (2005), 89–105.
70. , Asymptotically optimal box packing theorems, Electron. J. Combin. 15 (2008),
no. 1, 1–19.
71. , Many L-shaped polyominoes have odd rectangular packings, Ann. Comb. 18
(2014), 341–357.
 A NEW MODEL FOR TILING WITH POLYOMINOES 131

72. G. C. Rhoads, Planar tilings by polyominoes, polyhexes, and polyiamonds, J. Comput.

Appl. Math. 174 (2005), 329–353.
73. R. M. Robinson, Undecidability and nonperiodicity of tilings of the plane, Invent.
Math. 12 (1971), 177–209.
74. J. Rosenhouse and L. Taalman, Taking Sudoku seriously. the math behind the world’s
most popular pencil puzzle, Oxford University Press, Oxford, 2011.
75. D. Schattschneider, Will it tile? Try the conway criterion!, Math. Mag. 53 (1980),
no. 4, 224–233.
76. W. P. Thurston, Conway’s tiling groups, Amer. Math. Monthly 97 (1990), no. 8,
757–773.
77. S. Wagon, Fourteen proofs of a result about tiling a rectangle, Amer. Math. Monthly
94 (1987), no. 7, 601–617.
78. A. Winslow, An optimal algorithm for tiling the plane with a translated polyomino,
Algorithms and Computation: 26th International Symposium, ISAAC 2015 Nagoya,
Japan, December 9-11, 2015 Proceedings (K. Elbassioni and K. Makino, eds.), Lecture
Notes in Comput. Sci., vol. 9472, Springer, Heidelberg, 2015, pp. 3–13.
79. W. Xiao-Ran, Z. Yu-He, and G. Guo-Hua, No-infill 3D printing, 3D Research 7 (2016),
no. 3, 7–24.

Department of Mathematics & Statistics, University of Guelph, ON Canada

N1G 2W1
E-mail address: [email protected]

Department of Mathematics, University of Pittsburgh, Pittsburgh, PA 15260

E-mail address: [email protected]