Wallpaper groups (#23)

Reviewed-on: #23

src/Advanced/Wallpaper/parts/00 intro.typ

@@ -0,0 +1,151 @@
+#import "@local/handout:0.1.0": *
+#import "@preview/cetz:0.3.1"
+
+= Wallpaper Symmetries
+
+#definition()
+A _Euclidean isometry_ is a transformation of the plane that preserves distances. \
+Intuitively, an isometry moves objects on the plane without deforming them.
+
+There are four classes of Euclidean isometries:
+- translations
+- reflections
+- rotations
+- glide reflections
+#note([We can prove there are no others, but this is beyond the scope of this handout.]) \
+A simple example of each isometry is shown below:
+
+#let demo(c) = {
+  let s = 0.5
+  cetz.draw.line(
+    (0, 0),
+    (3 * s, 0),
+    (3 * s, 1 * s),
+    (1 * s, 1 * s),
+    (1 * s, 2 * s),
+    (0, 2 * s),
+    close: true,
+    fill: c,
+    stroke: black + 0mm * s,
+  )
+}
+
+#table(
+  stroke: none,
+  align: center,
+  columns: (1fr, 1fr),
+  rows: (3.5cm, 3.5cm),
+  row-gutter: 2mm,
+  [
+    #cetz.canvas({
+      import cetz.draw: *
+
+      demo(ored)
+      translate(x: -1.0, y: -1.0)
+      demo(oblue)
+    })
+    #v(1fr)
+    Translation
+  ],
+  [
+    #cetz.canvas({
+      import cetz.draw: *
+
+      circle((-2, 0), radius: 0.1, stroke: none, fill: black)
+      arc(
+        (-2, 0),
+        radius: 1,
+        anchor: "origin",
+        start: 0deg,
+        stop: -30deg,
+        mode: "PIE",
+      )
+
+      demo(ored)
+      rotate(z: -30deg, origin: (-2, 0))
+      demo(oblue)
+    })
+    #v(1fr)
+    Rotation
+  ],
+
+  [
+    #cetz.canvas({
+      import cetz.draw: *
+
+      line((-2, 0), (4, 0))
+
+      translate(x: 0, y: 0.25)
+      demo(ored)
+      set-transform(none)
+
+      set-transform((
+        (1, 0, 0, 0),
+        (0, 1, 0, 0),
+        (0, 0, 1, 0),
+        (0, 0, 0, 1),
+      ))
+
+      translate(x: 0, y: 0.25)
+      demo(oblue)
+    })
+    #v(1fr)
+    Reflection
+  ],
+  [
+    #cetz.canvas({
+      import cetz.draw: *
+
+
+      demo(ored)
+
+      set-transform((
+        (1, 0, 0, 0),
+        (0, 1, 0, 0),
+        (0, 0, 0, 0),
+        (0, 0, 0, 0),
+      ))
+      translate(x: 2, y: 0)
+
+      demo(oblue)
+
+      set-transform(none)
+      line((-1, 0), (5, 0))
+    })
+    #v(1fr)
+    Glide reflection
+  ],
+)
+
+#definition()
+A _wallpaper_ is a two-dimensional pattern that...
+- has translational symmetry in at least two non-parallel directions (and therefore fills the plane) \
+  #note[
+    "Translational symmetry" means that we can slide the entire wallpaper in some direction, \
+    eventually mapping the pattern to itself.]
+- has a countable number of reflection, rotation, or glide symmetries. \
+
+#v(1fr)
+#pagebreak()
+
+#problem()
+Is a plain square grid a valid wallpaper?
+
+#solution([
+  Yes!
+  - It has translational symmetry in the horizontal and vertical directions
+  - It has a countable number of symmetries---namely, six distinct mirror lines (horizontal, vertical, and diagonal) duplicated once per square.
+  - A square grid is #sym.convolve`442`
+])
+
+#v(1fr)
+
+
+#problem()
+Is the empty plane a valid wallpaper?
+
+#solution([
+  No, since it has uncountably many symmetries.
+])
+
+#v(1fr)

src/Advanced/Wallpaper/parts/01 reflect.typ

@@ -0,0 +1,132 @@
+#import "@local/handout:0.1.0": *
+#import "@preview/cetz:0.3.1"
+
+= Mirror Symmetry
+
+#definition()
+A _reflection_ is a transformation of the plane obtained by reflecting all points about a line. \
+If this reflection maps the wallpaper to itself, we have a _mirror symmetry_. \
+
+If $n$ such mirror lines intersect at a point, they form a _mirror node of order $n$_. \
+#note[Mirror nodes with order 1 do not exist (i.e, $n >= 2$). A line does not intersect itself!]
+
+#v(2mm)
+
+Two mirror nodes on a wallpaper are identical if we can map one to the other with a translation and a rotation while preserving the pattern on that wallpaper.
+
+#problem(label: "pat333")
+Find all three distinct mirror nodes in the following pattern. \
+What is the order of each node? \
+#hint([
+  You may notice rotational symmetry in this pattern. \
+  Don't worry about that yet, we'll discuss it later.
+])
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 45mm,
+  image("../res/wolfram/p3m1.svg", height: 100%),
+)
+
+#solution([
+  The mirror nodes are:
+  - the center of the amber cross
+  - the center of each right-handed group of three adjacent hexagons
+  - the center of each left-handed group of three adjacent hexagons
+])
+
+#v(1fr)
+
+
+#definition()
+_Orbifold notation_ gives us a way to describe the symmetries of a wallpaper. \
+It defines a _signature_ that fully describes all the symmetries of a given pattern. \
+We will introduce orbifold notation one symmetry at a time.
+
+#definition()
+In orbifold notation, mirror nodes are denoted by a #sym.convolve followed by a list of integer. \
+Every integer $n$ following a #sym.convolve denotes a mirror node of order $n$.
+
+#v(2mm)
+
+The order of these integers doesn't matter. #sym.convolve`234` and #sym.convolve`423` are the same signature. \
+However, we usually denote $n$-fold symmetries in descending order (that is, like #sym.convolve`432`). \
+If we have many nodes of the same order, integers may be repeated.
+
+
+#problem()
+What is the signature of the wallpaper in @pat333? \
+#hint[Again, ignore rotational symmetry for now.]
+#solution([It is #sym.convolve`333`])
+
+
+// MARK: page
+#v(1fr)
+#pagebreak()
+
+#problem()
+Find the signature of the following pattern.
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 60mm,
+  image("../res/*632-a.png", height: 100%),
+)
+
+
+#solution([
+  It is #sym.convolve`632`:
+  #table(
+    stroke: none,
+    align: center,
+    columns: 1fr,
+    rows: 40mm,
+    image("../res/*632-b.png", height: 100%),
+  )
+])
+
+#v(1fr)
+
+#problem()
+Draw a wallpaper pattern with signature #sym.convolve`2222`
+
+#solution([
+  Sample solutions are below.
+
+  #table(
+    stroke: none,
+    align: center,
+    columns: (1fr, 1fr),
+    rows: 50mm,
+    image("../res/wolfram/pmm.svg", height: 100%),
+    image("../res/escher/pmm.svg", height: 100%),
+  )
+])
+
+#v(1fr)
+
+#pagebreak()
+
+
+#remark()
+In an exceptional case, we have two parallel mirror lines. \
+Consider the following pattern:
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 60mm,
+  image("../res/**.png", height: 100%),
+)
+
+The signature of this pattern is #sym.convolve#sym.convolve
+
+#problem()
+Draw another wallpaper pattern with signature #sym.convolve#sym.convolve.
+
+#v(1fr)

src/Advanced/Wallpaper/parts/02 rotate.typ

@@ -0,0 +1,181 @@
+#import "@local/handout:0.1.0": *
+#import "@preview/cetz:0.3.1"
+
+= Rotational Symmetry
+
+
+#definition()
+A wallpaper may also have $n$-fold rotational symmetry about a point.
+#v(2mm)
+This means there are no more than $n$ rotations around that point that map the wallpaper to itself.
+#v(2mm)
+As before, two points of rotational symmetry are identical if we can perform a translation and rotation that maps one to the other without changing the wallpaper.
+
+#definition()
+In orbifold notation, rotation is specified similarly to reflection, but uses the prefix #sym.diamond.stroked.small. \
+For example:
+- #sym.diamond.stroked.small`333` denotes a pattern with three distinct centers of rotation of order 3.
+- #sym.diamond.stroked.small`4`#sym.convolve`2` denotes a pattern with one rotation center of order 4 and one mirror node of order 2.
+
+#table(
+  stroke: none,
+  align: center,
+  columns: (1fr, 1fr),
+  rows: 50mm,
+  image("../res/333.png", height: 100%), image("../res/3*3.png", height: 100%),
+)
+
+
+#problem()
+Find the three rotation centers in the left wallpaper. \
+What are their orders?
+
+#solution([This is #sym.diamond.stroked.small`333`])
+
+#v(1fr)
+
+#problem()
+Find the signature of the pattern on the right.
+
+#solution([This is #sym.diamond.stroked.small`3`#sym.convolve`3`])
+
+#v(1fr)
+
+
+#remark()
+You may have noticed that we could have an ambiguous classification, since two reflections are equivalent to a translation and a rotation.
+We thus make the following distinction: _rotational symmetry that can be explained by reflection is not rotational symmetry._
+
+#v(2mm)
+
+In other words, when classifying a pattern...
+- we first find all mirror symmetries,
+- then all rotational symmetries that are not accounted for by reflection.
+
+#pagebreak()
+
+
+// MARK: glide
+
+= Glide Reflections
+
+#definition()
+Another type of symmetry is the _glide reflection_, denoted #sym.times.
+
+A glide reflection is the result of a translation along a line followed by reflection about that line.
+
+For example, consider the following pattern:
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 60mm,
+  image("../res/*x-a.png", height: 100%),
+)
+
+#problem()
+Convince yourself that all mirror lines in this pattern are _not_ distinct. /
+In other words, this pattern has only one mirror symmetry.
+
+#solution([
+  There may seem to be two, but they are identical. \
+  We can translate one onto the other.
+])
+
+#v(1fr)
+
+
+
+#problem()
+Use the following picture to find the glide reflection in the above pattern.
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 70mm,
+  image("../res/*x-b.png", height: 100%),
+)
+
+#v(1fr)
+
+#remark()
+The signature of this wallpaper is #sym.convolve#sym.times.
+
+#pagebreak()
+
+
+#definition()
+If none of the above symmetries appear in a pattern, then we only have simple translational symmetry. We denote this with the signature #sym.circle.small.
+
+#remark()
+In summary, to find the signature of a pattern:
+- find the mirror lines (#sym.convolve) and the distinct intersections;
+- then find the rotation centers (#sym.diamond.stroked.small) not explained by reflection;
+- then find all glide reflections (#sym.times) that do not cross a mirror line.
+- If we have none of the above, our pattern must be #sym.circle.small.
+
+
+
+#problem()
+Find the signature of the following pattern:
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 50mm,
+  image("../res/wiki/Wallpaper_group-cm-4.jpg", height: 100%),
+)
+
+#solution([
+  This is #sym.convolve#sym.times.
+])
+
+#v(1fr)
+
+
+#problem()
+Find the signature of the following pattern:
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 60mm,
+  image("../res/wiki/Wallpaper_group-p4g-2.jpg", height: 100%),
+)
+
+#solution([
+  This is #sym.diamond.stroked.small`4`#sym.convolve`2`
+])
+
+#v(1fr)
+
+
+
+#pagebreak()
+
+#problem()
+Find two glide reflections in the following pattern.\
+#note[(and thus show that its signature is #sym.times#sym.times.)]
+
+
+#table(
+  stroke: none,
+  align: center,
+  columns: 1fr,
+  rows: 70mm,
+  image("../res/xx-b.png", height: 100%),
+)
+
+#solution([
+  #table(
+    stroke: none,
+    align: center,
+    columns: 1fr,
+    rows: 40mm,
+    image("../res/xx-a.png", height: 100%),
+  )
+])
+
+#v(1fr)

src/Advanced/Wallpaper/parts/03 problems.typ

@@ -0,0 +1,67 @@
+#import "@local/handout:0.1.0": *
+#import "@preview/cetz:0.3.1"
+
+#let pat(img, sol) = {
+  problem()
+
+  table(
+    stroke: none,
+    align: center,
+    columns: (1fr, 1fr),
+    rows: 80mm,
+    image(img, height: 100%), image(img, height: 100%),
+  )
+
+  solution(sol)
+  v(1fr)
+}
+
+= A few problems
+
+Find the signatures of the following patterns. Mark all mirror nodes, rotation centers, and glide reflections. \
+Each pattern is provided twice for convenience.
+
+
+#pat("../res/wolfram/cm.svg", [#sym.times#sym.convolve])
+#pat("../res/wolfram/cmm.svg", [#sym.diamond.stroked`2`#sym.convolve`22`])
+#pagebreak()
+
+
+
+
+#pat("../res/wolfram/p3.svg", [#sym.diamond.stroked`333`])
+#pat("../res/wolfram/p3m1.svg", [#sym.convolve`333`])
+#pagebreak()
+
+#pat("../res/wolfram/p4.svg", [#sym.diamond.stroked`442`])
+#pat("../res/wolfram/p4m.svg", [#sym.convolve`442`])
+#pagebreak()
+
+#pat("../res/wolfram/p6.svg", [#sym.diamond.stroked`632`])
+#pat("../res/wolfram/p6m.svg", [#sym.convolve`632`])
+#pagebreak()
+
+#pat("../res/wolfram/p4g.svg", [#sym.diamond.stroked`4`#sym.convolve`2`])
+#pat("../res/wolfram/p31m.svg", [#sym.diamond.stroked`3`#sym.convolve`3`])
+#pagebreak()
+
+#problem()
+Draw a wallpaper with the signature #sym.convolve`442` \
+#note[Make sure there are no other symmetries!]
+#v(1fr)
+#pagebreak()
+
+
+#pat("../res/wolfram/pgg.svg", [#sym.diamond.stroked`22`#sym.times])
+#pat("../res/wolfram/pmg.svg", [#sym.diamond.stroked`22`#sym.convolve])
+#pagebreak()
+
+#pat("../res/wolfram/pg.svg", [#sym.times#sym.times])
+#pat("../res/wolfram/pm.svg", [#sym.convolve#sym.convolve])
+#pagebreak()
+
+#pat("../res/wolfram/p2.svg", [#sym.diamond.stroked`2222`])
+#pat("../res/wolfram/pmm.svg", [#sym.convolve`2222`])
+#pagebreak()
+
+#pat("../res/wolfram/p1.svg", [#sym.circle.small])

src/Advanced/Wallpaper/parts/04 theorem.typ

@@ -0,0 +1,100 @@
+#import "@local/handout:0.1.0": *
+#import "@preview/cetz:0.3.1"
+
+= The Signature-Cost Theorem
+
+#definition()
+First, we'll associate a _cost_ to each type of symmetry in orbifold notation:
+
+#v(4mm)
+#align(
+  center,
+  table(
+    stroke: (1pt, 1pt),
+    align: center,
+    columns: (auto, auto, auto, auto),
+    [*Symbol*], [*Cost*], [*Symbol*], [*Cost*],
+    [#sym.circle.small], [2], [#sym.times or #sym.convolve], [1],
+    [#sym.diamond.stroked.small`2`], [1/2], [#sym.convolve`2`], [1/4],
+    [#sym.diamond.stroked.small`3`], [2/3], [#sym.convolve`3`], [1/3],
+    [#sym.dots], [#sym.dots], [#sym.dots], [#sym.dots],
+    [#sym.diamond.stroked.small`n`],
+    [$(n-1) / n$],
+    [#sym.convolve`n`],
+    [$(n-1) / (2n)$],
+  ),
+)
+
+
+We then calculate the total "cost" of a signature by adding up the costs of each component.
+
+For example, a pattern with signature #sym.convolve`333` has cost 2:
+
+#v(2mm)
+
+$
+  2 / 3 + 2 / 3 + 2 / 3 = 2
+$
+
+#problem()
+Calculate the costs of the following signatures:
+- #sym.diamond.stroked.small`3`#sym.convolve`3`
+- #sym.convolve#sym.convolve
+- #sym.diamond.stroked.small`4`#sym.convolve`2`:
+
+#solution([
+  - #sym.diamond.stroked.small`3`#sym.convolve`3`: $2/3 + 1 + 1/3 = 2$
+  - #sym.convolve#sym.convolve: $1 + 1 = 2$
+  - #sym.diamond.stroked.small`4`#sym.convolve`2`: $3/4 + 1 + 1/4 = 2$
+])
+
+#v(1fr)
+
+#theorem(name: "Signature Cost Theorem")
+The signatures of planar wallpaper patterns are exactly those with total cost 2. \
+#note([We will not prove this theorem today, accept it without proof.])
+
+#problem()
+Consider the 4 symmetries (translation, reflection, rotation, and glide reflection). \
+Which preserve orientation? Which reverse orientation?
+
+#solution([
+  - Reflections and glide reflections reverse orientation (directions of spirals).
+  - Translation and rotation preserve orientation.
+])
+
+#v(1fr)
+#pagebreak()
+
+#problem()
+Use the signature-cost theorem to find all the signatures consisting of only #sym.circle.small or rotational symmetries.
+
+#solution([
+  #sym.diamond.stroked.small`632`, #sym.diamond.stroked.small`442`, #sym.diamond.stroked.small`333`, #sym.diamond.stroked.small`2222`, #sym.circle.small
+])
+
+#v(1fr)
+
+
+#problem()
+Find all the signatures consisting of only mirror symmetries.
+
+#solution([
+  #sym.convolve`632`, #sym.convolve`442`, #sym.convolve`333`, #sym.convolve`2222`, #sym.convolve#sym.convolve
+])
+
+#v(1fr)
+
+
+#problem()
+Find all the remaining signatures. \
+Each must be a mix of of mirror symmetries, rotational symmetries, or glide reflections. \
+#hint([They are all shown in the problems section.])
+
+#solution([
+  #sym.diamond.stroked.small`3`#sym.convolve`3`, #sym.diamond.stroked.small`4`#sym.convolve`2`,
+  #sym.diamond.stroked.small`22`#sym.times, #sym.diamond.stroked.small`22`#sym.convolve,
+  #sym.times#sym.times, #sym.times#sym.convolve
+])
+
+#v(1fr)