Compare commits
3 Commits
095c4b314c
...
typst-quan
Author | SHA1 | Date | |
---|---|---|---|
df91fd9f96 | |||
121780df6c | |||
99344f9aed |
35
src/Advanced/Introduction to Quantum/main.typ
Normal file
@ -0,0 +1,35 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
#show: handout.with(
|
||||
title: [Intro to Quantum Computing],
|
||||
by: "Mark",
|
||||
)
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
#include "src/parts/01 bits.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/02 qubit.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/03 two qubits.typ"
|
||||
#pagebreak()
|
||||
|
||||
// DONE UNTIL HERE
|
||||
|
||||
#include "src/parts/04 logic gates.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/05 quantum gates.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/06 hxh.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/07 superdense.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "src/parts/08 teleport.typ"
|
349
src/Advanced/Introduction to Quantum/src/parts/01 bits.typ
Normal file
@ -0,0 +1,349 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
#import "@preview/cetz:0.4.2"
|
||||
|
||||
= Probabilistic Bits
|
||||
|
||||
#definition()
|
||||
As we already know, a _classical bit_ may take the values `0` and `1`.
|
||||
|
||||
We can model this with a two-sided coin, one face of which is labeled `0`, and the other, `1`.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Of course, if we toss such a "bit-coin," we'll get either `0` or `1`.
|
||||
|
||||
We'll denote the probability of getting `0` as $p_0$, and the probability of getting `1` as $p_1$.
|
||||
|
||||
As with all probabilities, $p_0 + p_1$ must be equal to 1.
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#definition()
|
||||
Say we toss a "bit-coin" and don't observe the result. We now have a _probabilistic bit_, with a probability $p_0$ of being `0`, and a probability $p_1$ of being `1`.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
We'll represent this probabilistic bit's _state_ as a vector: $mat(p_0; p_1)$
|
||||
|
||||
We do *not* assume this coin is fair, and thus $p_0$ might not equal $p_1$.
|
||||
|
||||
#note[This may seem a bit redundant: since $p_0 + p_1 = 1$, we can always calculate one probability given the other. We'll still include both probabilities in the state vector, since this provides a clearer analogy to quantum bits.]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#definition()
|
||||
The simplest probabilistic bit states are of course $[0]$ and $[1]$, defined as follows:
|
||||
- $[0] = mat(1; 0)$
|
||||
- $[1] = mat(0; 1)$
|
||||
|
||||
That is, $[0]$ represents a bit that we known to be `0`, and $[1]$ represents a bit we know to be `1`.
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#definition()
|
||||
$[0]$ and $[1]$ form a _basis_ for all possible probabilistic bit states:
|
||||
|
||||
Every other probabilistic bit can be written as a _linear combination_ of $[0]$ and $[1]$:
|
||||
|
||||
$ mat(p_0; p_1) = p_0 mat(1; 0) + p_1 mat(0; 1) = p_0 [0] + p_1 [1] $
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Every possible state of a probabilistic bit is a two-dimensional vector.
|
||||
|
||||
Draw all possible states on the axis below.
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(200%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 0), radius: 0.6mm, fill: black, name: "00")
|
||||
content("00.south", $mat(0; 0)$, anchor: "north")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $[1]$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $[0]$, anchor: "north")
|
||||
})),
|
||||
)
|
||||
|
||||
#solution[
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (
|
||||
frame: "rect",
|
||||
stroke: none,
|
||||
fill: none,
|
||||
padding: .25,
|
||||
))
|
||||
scale(200%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
|
||||
line(
|
||||
(1, 0),
|
||||
(0, 1),
|
||||
stroke: ored + 1mm,
|
||||
)
|
||||
|
||||
circle((0, 0), radius: 0.6mm, fill: black, name: "00")
|
||||
content("00.south", $mat(0; 0)$, anchor: "north")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $[1]$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $[0]$, anchor: "north")
|
||||
})),
|
||||
)
|
||||
|
||||
]
|
||||
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
= Measuring Probabilistic Bits
|
||||
|
||||
#definition()
|
||||
As we noted before, a probabilistic bit represents a coin we've tossed but haven't looked at.
|
||||
|
||||
We do not know whether the bit is `0` or `1`, but we do know the probability of both of these outcomes.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
If we _measure_ (or _observe_) a probabilistic bit, we see either `0` or `1`—and thus our knowledge of its state is updated to either $[0]$ or $[1]$, since we now certainly know what face the coin landed on.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Since measurement changes what we know about a probabilistic bit, it changes the probabilistic bit's state. When we measure a bit, its state _collapses_ to either $[0]$ or $[1]$, and the original state of the bit vanishes. We _cannot_ recover the state $[x_0, x_1]$ from a measured probabilistic bit.
|
||||
|
||||
#definition("Multiple bits")
|
||||
Say we have two probabilistic bits, $x$ and $y$, with states $[x] = [x_0, x_1]$ and $[y] = [y_0, y_1]$
|
||||
|
||||
#v(2mm)
|
||||
|
||||
The _compound state_ of $[x]$ and $[y]$ is exactly what it sounds like: It is the probabilistic two-bit state $|x y angle.r$, where the probabilities of the first bit are determined by $[x]$, and the probabilities of the second are determined by $[y]$.
|
||||
|
||||
#problem(label: "firstcompoundstate")
|
||||
Say $[x] = [2/3, 1/3]$ and $[y] = [3/4, 1/4]$.
|
||||
|
||||
- If we measure $x$ and $y$ simultaneously, what is the probability of getting each of `00`, `01`, `10`, and `11`?
|
||||
|
||||
- If we measure $y$ first and observe `1`, what is the probability of getting each of `00`, `01`, `10`, and `11`?
|
||||
|
||||
#note[*Note:* $[x]$ and $[y]$ are column vectors, but I've written them horizontally to save space.]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Say $[x] = [2/3, 1/3]$ and $[y] = [3/4, 1/4]$.
|
||||
|
||||
What is the probability that $x$ and $y$ produce different outcomes?
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
= Tensor Products
|
||||
|
||||
#definition("Tensor Products")
|
||||
The _tensor product_ of two vectors is defined as follows:
|
||||
$
|
||||
mat(x_1; x_2) times.circle mat(y_1; y_2) = mat(x_1 mat(y_1; y_2); x_2 mat(y_1; y_2)) = mat(x_1 y_1; x_1 y_2; x_2 y_1; x_2 y_2)
|
||||
$
|
||||
|
||||
That is, we take our first vector, multiply the second vector by each of its components, and stack the result. You could think of this as a generalization of scalar multiplication, where scalar multiplication is a tensor product with a vector in $RR^1$:
|
||||
|
||||
$
|
||||
a mat(x_1; x_2) = mat(a_1) times.circle mat(y_1; y_2) = mat(a_1 mat(y_1; y_2)) = mat(a_1 y_1; a_1 y_2)
|
||||
$
|
||||
|
||||
#problem()
|
||||
Say $x in RR^n$ and $y in RR^m$.
|
||||
|
||||
What is the dimension of $x times.circle y$?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem(label: "basistp")
|
||||
What is the following pairwise tensor product?
|
||||
#v(4mm)
|
||||
$
|
||||
{mat(1; 0; 0), mat(0; 1; 0), mat(0; 0; 1)}
|
||||
times.circle
|
||||
{mat(1; 0), mat(0; 1)}
|
||||
$
|
||||
#v(4mm)
|
||||
|
||||
#hint[Distribute the tensor product between every pair of vectors.]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
What is the _span_ of the vectors we found in @basistp?
|
||||
|
||||
In other words, what is the set of vectors that can be written as linear combinations of the vectors above?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Say $[x] = [2/3, 1/3]$ and $[y] = [3/4, 1/4]$.
|
||||
|
||||
What is $[x] times.circle [y]$? How does this relate to @firstcompoundstate?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
The compound state of two vector-form bits is their tensor product.
|
||||
|
||||
Compute the following. Is the result what we'd expect?
|
||||
- $[0] times.circle [0]$
|
||||
- $[0] times.circle [1]$
|
||||
- $[1] times.circle [0]$
|
||||
- $[1] times.circle [1]$
|
||||
|
||||
#hint[Remember that $[0] = mat(1; 0)$ and $[1] = mat(0; 1)$.]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem(label: "fivequant")
|
||||
Writing $[0] times.circle [1]$ is a bit tedious. We'll shorten this notation to $[01]$.
|
||||
|
||||
In fact, we could go further: if we wanted to write the set of bits $[1] times.circle [1] times.circle [0] times.circle [1]$, \
|
||||
we could write $[1101]$—but a shorter alternative is $[13]$, since $13$ is `1101` in binary.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Write $[5]$ as a three-bit probabilistic state.
|
||||
|
||||
#solution[
|
||||
$[5] = [101] = [1] times.circle [0] times.circle [1] = [0,0,0,0,0,1,0,0]^T$ \
|
||||
|
||||
Notice how we're counting from the top, with $[000] = [1,0,...,0]$ and $[111] = [0, ..., 0, 1]$.
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Write the three-bit states $[0]$ through $[7]$ as column vectors.
|
||||
|
||||
#hint[You do not need to compute every tensor product. Do a few and find the pattern.]
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
|
||||
|
||||
= Operations on Probabilistic Bits
|
||||
|
||||
Now that we can write probabilistic bits as vectors, we can represent operations on these bits with linear transformations—in other words, as matrices.
|
||||
|
||||
#definition()
|
||||
Consider the NOT gate, which operates as follows:
|
||||
- $"NOT"[0] = [1]$
|
||||
- $"NOT"[1] = [0]$
|
||||
|
||||
What should NOT do to a probabilistic bit $[x_0, x_1]$?
|
||||
|
||||
If we return to our coin analogy, we can think of the NOT operation as flipping a coin we have already tossed, without looking at its state. Thus,
|
||||
$ "NOT" mat(x_0; x_1) = mat(x_1; x_0) $
|
||||
|
||||
#review_box("Review: Multiplying vectors by matrices")[
|
||||
#v(2mm)
|
||||
|
||||
$
|
||||
A v = mat(1, 2; 3, 4) mat(v_0; v_1) = mat(1 v_0 + 2 v_1; 3 v_0 + 4 v_1)
|
||||
$
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Note that each element of $A v$ is the dot product of a row in $A$ and a column in $v$.
|
||||
]
|
||||
|
||||
#problem()
|
||||
Compute the following product:
|
||||
$ mat(1, 0.5; 0, 1) mat(3; 2) $
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#remark()
|
||||
Also, recall that every matrix is linear map, and that every linear map may be written as a matrix. We often use the terms _matrix_, _transformation_, and _linear map_ interchangeably.
|
||||
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Find the matrix that represents the NOT operation on one probabilistic bit.
|
||||
|
||||
#solution[
|
||||
$
|
||||
mat(0, 1; 1, 0)
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem("Extension by linearity")
|
||||
Say we have an arbitrary operation $M$.
|
||||
|
||||
If we know how $M$ acts on $[1]$ and $[0]$, can we compute $M[x]$ for an arbitrary state $[x]$?
|
||||
|
||||
Say $[x] = [x_0, x_1]$.
|
||||
- What is the probability we observe $0$ when we measure $x$?
|
||||
- What is the probability that we observe $M[0]$ when we measure $M x$?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem(label: "linearextension")
|
||||
Write $M[x_0, x_1]$ in terms of $M[0]$, $M[1]$, $x_0$, and $x_1$.
|
||||
|
||||
#solution[
|
||||
$
|
||||
M mat(x_0; x_1) = x_0 M mat(1; 0) + x_1 M mat(0; 1) = x_0 M[0] + x_1 M[1]
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#remark() Every matrix represents a _linear_ map, so the following is always true:
|
||||
$ A times (p x + q y) = p A x + q A y $
|
||||
|
||||
@linearextension is just a special case of this fact.
|
514
src/Advanced/Introduction to Quantum/src/parts/02 qubit.typ
Normal file
@ -0,0 +1,514 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
#import "@preview/cetz:0.4.2"
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= One Qubit
|
||||
|
||||
Quantum bits (or _qubits_) are very similar to probabilistic bits, but have one major difference: probabilities are replaced with _amplitudes_.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Of course, a qubit can take the values `0` and `1`, which are denoted $#ket("0")$ and $#ket("1")$.
|
||||
|
||||
Like probabilistic bits, a quantum bit is written as a linear combination of $#ket("0")$ and $#ket("1")$:
|
||||
$ #ket([$psi$]) = psi_0 #ket("0") + psi_1 #ket("1") $
|
||||
|
||||
Such linear combinations are called _superpositions_.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
The $#ket("")$ you see in the expressions above is called a "ket," and denotes a column vector.
|
||||
|
||||
$#ket("0")$ is pronounced "ket zero," and $#ket("1")$ is pronounced "ket one." This is called bra-ket notation.
|
||||
|
||||
#note[*Note:* $#bra("0")$ is called a "bra," but we won't worry about that for now.]
|
||||
|
||||
#v(2mm)
|
||||
|
||||
This is very similar to the "box" $[#h(1.5mm)]$ notation we used for probabilistic bits.
|
||||
|
||||
As before, we will write $#ket("0") = mat(1; 0)$ and $#ket("1") = mat(0; 1)$.
|
||||
|
||||
#v(8mm)
|
||||
|
||||
Recall that probabilistic bits are subject to the restriction that $p_0 + p_1 = 1$.
|
||||
|
||||
Quantum bits have a similar condition: $psi_0^2 + psi_1^2 = 1$.
|
||||
|
||||
Note that this implies that $psi_0$ and $psi_1$ are both in $[-1, 1]$.
|
||||
|
||||
Quantum amplitudes may be negative, but probabilistic bit probabilities cannot.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
If we plot the set of valid quantum states on our plane, we get a unit circle centered at the origin:
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(150%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
circle((0, 0), radius: 1, stroke: (
|
||||
paint: black,
|
||||
thickness: 0.25mm,
|
||||
dash: "dashed",
|
||||
))
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $#ket("1")$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $#ket("0")$, anchor: "north")
|
||||
|
||||
circle((0.87, 0.5), radius: 0.6mm, fill: ored, stroke: ored, name: "00")
|
||||
content("00.east", $#ket(math.psi)$, anchor: "west")
|
||||
})),
|
||||
)
|
||||
|
||||
|
||||
Recall that the set of probabilistic bits forms a line instead:
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(150%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
|
||||
line(
|
||||
(1, 0),
|
||||
(0, 1),
|
||||
stroke: ored + 1mm,
|
||||
)
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 0), radius: 0.6mm, fill: black, name: "00")
|
||||
content("00.south", $mat(0; 0)$, anchor: "north")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $[1]$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $[0]$, anchor: "north")
|
||||
})),
|
||||
)
|
||||
|
||||
|
||||
#problem()
|
||||
In the above unit circle, the counterclockwise angle from $#ket("0")$ to $#ket([$psi$])$ is $30°$.
|
||||
|
||||
Write $#ket([$psi$])$ as a linear combination of $#ket("0")$ and $#ket("1")$.
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#definition("Measurement I")
|
||||
Just like a probabilistic bit, we must observed $#ket("0")$ or $#ket("1")$ when we measure a qubit.
|
||||
|
||||
If we were to measure $#ket([$psi$]) = psi_0 #ket("0") + psi_1 #ket("1")$, we'd observe either $#ket("0")$ or $#ket("1")$, with the following probabilities:
|
||||
- $cal(P)(#ket("1")) = psi_1^2$
|
||||
- $cal(P)(#ket("0")) = psi_0^2$
|
||||
|
||||
#note[Note that $cal(P)(#ket("0")) + cal(P)(#ket("1")) = 1$.]
|
||||
|
||||
#v(2mm)
|
||||
|
||||
As before, $#ket([$psi$])$ _collapses_ when it is measured: its state becomes that which we observed in our measurement, leaving no trace of the previous superposition.
|
||||
|
||||
#problem()
|
||||
- What is the probability we observe $#ket("0")$ when we measure $#ket([$psi$])$?
|
||||
- What can we observe if we measure $#ket([$psi$])$ a second time?
|
||||
- What are these probabilities for $#ket([$phi$])$?
|
||||
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(200%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
circle((0, 0), radius: 1, stroke: (
|
||||
paint: black,
|
||||
thickness: 0.25mm,
|
||||
dash: "dashed",
|
||||
))
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $#ket("1")$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $#ket("0")$, anchor: "north")
|
||||
|
||||
circle((0.87, 0.5), radius: 0.6mm, fill: ored, stroke: ored, name: "00")
|
||||
content("00.east", $#ket(math.psi)$, anchor: "west")
|
||||
|
||||
arc(
|
||||
(0, 0),
|
||||
start: 0deg,
|
||||
stop: -135deg,
|
||||
anchor: "origin",
|
||||
radius: 0.3,
|
||||
name: "a135",
|
||||
stroke: gray,
|
||||
)
|
||||
mark(
|
||||
"a135.end",
|
||||
135deg,
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
content("a135.center", text(fill: gray)[$135degree$], anchor: "north")
|
||||
|
||||
|
||||
line((0, 0), (-0.607, -0.607), stroke: (
|
||||
paint: gray,
|
||||
thickness: 0.4mm,
|
||||
dash: "dotted",
|
||||
))
|
||||
mark(
|
||||
(-0.627, -0.627),
|
||||
(-0.708, -0.708),
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
|
||||
|
||||
arc(
|
||||
(0, 0),
|
||||
start: 0deg,
|
||||
stop: 30deg,
|
||||
anchor: "origin",
|
||||
radius: 0.6,
|
||||
name: "a30",
|
||||
stroke: gray,
|
||||
)
|
||||
mark(
|
||||
"a30.end",
|
||||
120deg,
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
content("a30.end", text(fill: gray)[$30degree$], anchor: "south")
|
||||
|
||||
|
||||
line((0, 0), (0.87, 0.5), stroke: (
|
||||
paint: gray,
|
||||
thickness: 0.4mm,
|
||||
dash: "dotted",
|
||||
))
|
||||
mark(
|
||||
(0.80, 0.46),
|
||||
(0.87, 0.5),
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
|
||||
circle(
|
||||
(-0.707, -0.707),
|
||||
radius: 0.6mm,
|
||||
fill: ored,
|
||||
stroke: ored,
|
||||
name: "00",
|
||||
)
|
||||
content("00.west", $#ket(math.phi)$, anchor: "east")
|
||||
})),
|
||||
)
|
||||
|
||||
|
||||
|
||||
#v(1fr)
|
||||
|
||||
As you may have noticed, we don't need two coordinates to fully define a qubit's state. We can get by with one coordinate just as well.
|
||||
|
||||
Instead of referring to each state using its cartesian coordinates $psi_0$ and $psi_1$, we can address it using its _polar angle_ $theta$, measured from $#ket("0")$ counterclockwise:
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(180%)
|
||||
|
||||
line(
|
||||
(0, 1.5),
|
||||
(0, 0),
|
||||
(1.5, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.5), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.5, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
circle((0, 0), radius: 1, stroke: (
|
||||
paint: black,
|
||||
thickness: 0.25mm,
|
||||
dash: "dashed",
|
||||
))
|
||||
|
||||
content((0, 1.5), $p_1$, anchor: "south")
|
||||
content((1.5, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 1), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $#ket("1")$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.6mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $#ket("0")$, anchor: "north")
|
||||
|
||||
circle((0.87, 0.5), radius: 0.6mm, fill: ored, stroke: ored, name: "00")
|
||||
content("00.east", $#ket(math.psi)$, anchor: "west")
|
||||
|
||||
|
||||
arc(
|
||||
(0, 0),
|
||||
start: 0deg,
|
||||
stop: 30deg,
|
||||
anchor: "origin",
|
||||
radius: 0.6,
|
||||
name: "a30",
|
||||
stroke: gray,
|
||||
)
|
||||
mark(
|
||||
"a30.end",
|
||||
120deg,
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
content("a30.mid", text(fill: gray)[$theta$], anchor: "west")
|
||||
|
||||
|
||||
line((0, 0), (0.87, 0.5), stroke: (
|
||||
paint: gray,
|
||||
thickness: 0.4mm,
|
||||
dash: "dotted",
|
||||
))
|
||||
mark(
|
||||
(0.80, 0.46),
|
||||
(0.87, 0.5),
|
||||
symbol: ")>",
|
||||
fill: gray,
|
||||
stroke: gray,
|
||||
)
|
||||
})),
|
||||
)
|
||||
|
||||
|
||||
#problem()
|
||||
Find $psi_0$ and $psi_1$ in terms of $theta$ for an arbitrary qubit $psi$.
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Consider the following qubit states:
|
||||
|
||||
#grid(
|
||||
columns: (1fr, 1fr),
|
||||
$ #ket("+") = (#ket("0") + #ket("1"))/sqrt(2) $,
|
||||
$ #ket("-") = (#ket("0") - #ket("1"))/sqrt(2) $,
|
||||
)
|
||||
|
||||
- Where are these on the unit circle?
|
||||
- What are their polar angles?
|
||||
- What are the probabilities of observing $#ket("0")$ and $#ket("1")$ when measuring $#ket("+")$ and $#ket("-")$?
|
||||
|
||||
|
||||
|
||||
#table(
|
||||
columns: (1fr,),
|
||||
align: center,
|
||||
stroke: none,
|
||||
align(center, cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
set-style(content: (frame: "rect", stroke: none, fill: none, padding: .25))
|
||||
scale(300%)
|
||||
|
||||
line(
|
||||
(0, 1.3),
|
||||
(0, 0),
|
||||
(1.3, 0),
|
||||
stroke: black + 0.25mm,
|
||||
)
|
||||
mark((0, 1.3), (0, 2), symbol: ")>", fill: black)
|
||||
mark((1.3, 0), (2, 0), symbol: ")>", fill: black)
|
||||
|
||||
circle((0, 0), radius: 1, stroke: (
|
||||
paint: black,
|
||||
thickness: 0.25mm,
|
||||
dash: "dashed",
|
||||
))
|
||||
|
||||
content((0, 1.3), $p_1$, anchor: "south")
|
||||
content((1.3, 0), $p_0$, anchor: "west")
|
||||
|
||||
circle((0, 1), radius: 0.4mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.west", $#ket("1")$, anchor: "east")
|
||||
|
||||
circle((1, 0), radius: 0.4mm, fill: oblue, stroke: oblue, name: "00")
|
||||
content("00.south", $#ket("0")$, anchor: "north")
|
||||
})),
|
||||
)
|
||||
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#v(1fr)
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
= Operations on One Qubit
|
||||
|
||||
We may apply transformations to qubits just as we apply transformations to probabilistic bits. Again, we'll represent transformations as $2 times 2$ matrices, since we want to map one qubit state to another.
|
||||
|
||||
#note[In other words, we want to map elements of $RR^2$ to elements of $RR^2$.]
|
||||
|
||||
We will call such maps _quantum gates,_ since they are the quantum equivalent of classical logic gates.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
There are two conditions a valid quantum gate $G$ must satisfy:
|
||||
- For any valid state $#ket([$psi$])$, $G #ket([$psi$])$ is a valid state. Namely, $G$ must preserve the length of any vector it is applied to. Recall that the set of valid quantum states is the set of unit vectors in $RR^2$
|
||||
|
||||
- Any quantum gate must be _invertible_. We'll skip this condition for now, and return to it later.
|
||||
|
||||
In short, a quantum gate is a linear map that maps the unit circle to itself. There are only two kinds of linear maps that do this: reflections and rotations.
|
||||
|
||||
#problem()
|
||||
The $X$ gate is the quantum analog of the `not` gate, defined by the following table:
|
||||
- $X #ket("0") = #ket("1")$
|
||||
- $X #ket("1") = #ket("0")$
|
||||
|
||||
Find the matrix $X$.
|
||||
|
||||
#solution[
|
||||
$
|
||||
mat(0, 1; 1, 0)
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
What is $X #ket("+")$ and $X #ket("-")$?
|
||||
|
||||
#hint[Remember that all matrices are linear maps. What does this mean?]
|
||||
|
||||
#solution[
|
||||
$X #ket("+") = #ket("+")$ and $X #ket("-") = - #ket("-")$ (that is, a negative ket-minus). \
|
||||
Most notably, rememver that $G(a#ket("0") + b #ket("1")) = a G #ket("0") + b G #ket("1")$.
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
In terms of geometric transformations, what does $X$ do to the unit circle?
|
||||
|
||||
#solution[
|
||||
It is a reflection about the $45degree$ axis.
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Let $Z$ be a quantum gate defined by the following table:
|
||||
- $Z #ket("0") = #ket("0")$,
|
||||
- $Z #ket("1") = -#ket("1")$.
|
||||
|
||||
What is the matrix $Z$? What are $Z #ket("+")$ and $Z #ket("-")$?
|
||||
|
||||
What is $Z$ as a geometric transformation?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Is the map $B$ defined by the table below a valid quantum gate?
|
||||
- $B #ket("0") = #ket("0")$
|
||||
- $B #ket("1") = #ket("+")$
|
||||
|
||||
#hint[Find a $#ket([$psi$])$ so that $B #ket([$psi$])$ is not a valid qubit state]
|
||||
|
||||
#solution[
|
||||
$ B #ket("+") = (1 + sqrt(2))/(2) #ket("0") + 1/2 #ket("1") $
|
||||
|
||||
This has a non-unit length of
|
||||
$
|
||||
(sqrt(2) + 1)/(2)
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem("Rotation")
|
||||
As we noted earlier, any rotation about the center is a valid quantum gate. Let's derive all transformations of this form.
|
||||
|
||||
- Let $U_theta$ be the matrix that represents a counterclockwise rotation of $theta$ degrees. What is $U #ket("0")$ and $U #ket("1")$?
|
||||
|
||||
- Find the matrix $U_theta$ for an arbitrary $theta$.
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Say we have a qubit that is either $#ket("+")$ or $#ket("-")$. We do not know which of the two states it is in.
|
||||
|
||||
Using one operation and one measurement, how can we find out, for certain, which qubit we received?
|
||||
|
||||
#v(1fr)
|
126
src/Advanced/Introduction to Quantum/src/parts/03 two qubits.typ
Normal file
@ -0,0 +1,126 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= Two Qubits
|
||||
|
||||
#definition()
|
||||
Just as before, we'll represent multi-qubit states as linear combinations of multi-qubit basis states.
|
||||
|
||||
For example, a two-qubit state $#ket("ab")$ is the four-dimensional unit vector
|
||||
$ mat(a; b; c; d) = a #ket("00") + b #ket("01") + c #ket("10") + d #ket("11") $
|
||||
|
||||
As always, multi-qubit states are unit vectors. Thus, $a^2 + b^2 + c^2 + d^2 = 1$ in the two-bit case above.
|
||||
|
||||
#problem()
|
||||
Say we have two qubits $#ket([$psi$])$ and $#ket([$phi$])$.
|
||||
|
||||
Show that $#ket([$psi$]) times.circle #ket([$phi$])$ is always a unit vector (and is thus a valid quantum state).
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#definition("Measurement II")<measureii>
|
||||
Measurement of a two-qubit state works just like measurement of a one-qubit state:
|
||||
|
||||
If we measure $a #ket("00") + b #ket("01") + c #ket("10") + d #ket("11")$, we get one of the four basis states with the following probabilities:
|
||||
|
||||
- $cal(P)(#ket("00")) = a^2$
|
||||
- $cal(P)(#ket("01")) = b^2$
|
||||
- $cal(P)(#ket("10")) = c^2$
|
||||
- $cal(P)(#ket("11")) = d^2$
|
||||
|
||||
As before, the sum of all the above probabilities is $1$.
|
||||
|
||||
#problem()
|
||||
Consider the two-qubit state
|
||||
$#ket([$psi$]) = 1/sqrt(2) #ket("00") + 1/2 #ket("01") + sqrt(3)/4 #ket("10") + 1/4 #ket("11")$
|
||||
|
||||
- If we measure both bits of $#ket([$psi$])$ simultaneously, what is the probability of getting each of $#ket("00")$, $#ket("01")$, $#ket("10")$, and $#ket("11")$?
|
||||
|
||||
- If we measure the ONLY the first qubit, what is the probability we get $#ket("0")$? How about $#ket("1")$?
|
||||
|
||||
#hint[There are two basis states in which the first qubit is $#ket("0")$.]
|
||||
|
||||
- Say we measured the second bit and read $#ket("1")$. If we now measure the first bit, what is the probability of getting $#ket("0")$?
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#problem()
|
||||
Again, consider the two-qubit state
|
||||
$#ket([$psi$]) = 1/sqrt(2) #ket("00") + 1/2 #ket("01") + sqrt(3)/4 #ket("10") + 1/4 #ket("11")$
|
||||
|
||||
If we measure the first qubit of $#ket([$psi$])$ and get $#ket("0")$, what is the resulting state of $#ket([$psi$])$?
|
||||
|
||||
What would the state be if we'd measured $#ket("1")$ instead?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Consider the three-qubit state $#ket([$psi$]) = c_0 #ket("000") + c_1 #ket("001") + ... + c_7 #ket("111")$.
|
||||
|
||||
Say we measure the first two qubits and get $#ket("00")$. What is the resulting state of $#ket([$psi$])$?
|
||||
|
||||
#solution[
|
||||
We measure $#ket("00")$ with probability $c_0^2 + c_1^2$, and $#ket(math.psi)$ collapses to
|
||||
|
||||
#v(3mm)
|
||||
|
||||
$
|
||||
(c_0 #ket("000") + c_1 #ket("001"))/(sqrt(c_0^2 + c_1^2))
|
||||
$
|
||||
]
|
||||
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#definition("Entanglement")
|
||||
Some product states can be factored into a tensor product of individual qubit states. For example,
|
||||
$
|
||||
1/2 (#ket("00") + #ket("01") + #ket("10") + #ket("11")) = 1/sqrt(2) (#ket("0") + #ket("1")) times.circle 1/sqrt(2) (#ket("0") + #ket("1"))
|
||||
$
|
||||
|
||||
Such states are called _product states._ States that aren't product states are called _entangled_ states.
|
||||
|
||||
#problem()
|
||||
Factor the following product state:
|
||||
$
|
||||
1/(2sqrt(2)) (sqrt(3) #ket("00") - sqrt(3) #ket("01") + #ket("10") - #ket("11"))
|
||||
$
|
||||
|
||||
#solution[
|
||||
|
||||
$
|
||||
(1)/(2 sqrt(2)) (sqrt(3) #ket("00") - sqrt(3) #ket("01") + #ket("10") - #ket("11"))
|
||||
= (sqrt(3)/2 #ket("0") + 1/2 #ket("1") )
|
||||
times.circle
|
||||
( 1/sqrt(2) #ket(0) - 1/sqrt(2) #ket("1"))
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Show that the following is an entangled state.
|
||||
$ 1/sqrt(2) #ket("00") + 1/sqrt(2) #ket("11") $
|
||||
|
||||
#solution[
|
||||
$
|
||||
mat(a_0; a_1)
|
||||
times.circle
|
||||
mat(b_0; b_1)
|
||||
=
|
||||
a_0b_0 #ket(00) + a_0b_1 #ket(01) + a_1b_0 #ket(10) + a_1b_1 #ket(11)
|
||||
$
|
||||
|
||||
#v(2mm)
|
||||
|
||||
So, we have that $a_1b_1 = a_0b_0 = sqrt(2)^(-1)$ \
|
||||
But $a_0b_1 = a_1b_0 = 0$, so one of $a_0$ and $b_1$ must be zero. \
|
||||
We thus have a contradiction.
|
||||
]
|
||||
|
||||
#v(1fr)
|
@ -0,0 +1,169 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= Logic Gates
|
||||
|
||||
#definition("Matrices")
|
||||
Throughout this handout, we've been using matrices. Again, recall that every linear map may be written as a matrix, and that every matrix represents a linear map. For example, if $f: RR^2 -> RR^2$ is a linear map, we can write it as follows:
|
||||
|
||||
$
|
||||
f(#ket("x")) = mat(m_1, m_2; m_3, m_4) mat(x_1; x_2) = mat(m_1 x_1 + m_2 x_2; m_3 x_1 + m_4 x_2)
|
||||
$
|
||||
|
||||
#definition()
|
||||
Before we discussing multi-qubit quantum gates, we need to review to classical logic.
|
||||
|
||||
Of course, a classical logic gate is a linear map from ${0,1}^m$ to ${0,1}^n$
|
||||
|
||||
#problem()<notgatex>
|
||||
The `not` gate is a map defined by the following table:
|
||||
|
||||
- $X #ket("0") = #ket("1")$
|
||||
- $X #ket("1") = #ket("0")$
|
||||
|
||||
Write the `not` gate as a matrix that operates on single-bit vector states.
|
||||
|
||||
That is, find a matrix $X$ so that $X mat(1; 0) = mat(0; 1)$ and $X mat(0; 1) = mat(1; 0)$
|
||||
|
||||
#solution[
|
||||
$
|
||||
X = mat(0, 1; 1, 0)
|
||||
$
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
The `and` gate is a map $BB^2 -> BB$ defined by the following table:
|
||||
|
||||
#align(center, table(
|
||||
columns: 3,
|
||||
stroke: none,
|
||||
table.hline(),
|
||||
[`a`], [`b`], [`a` and `b`],
|
||||
table.hline(),
|
||||
[0], [0], [0],
|
||||
[0], [1], [0],
|
||||
[1], [0], [0],
|
||||
[1], [1], [1],
|
||||
table.hline(),
|
||||
))
|
||||
|
||||
Find a matrix $A$ so that $A #ket("ab")$ works as expected.
|
||||
|
||||
#hint[Remember, we write bits as vectors.]
|
||||
|
||||
#solution[
|
||||
$
|
||||
A = mat(1, 1, 1, 0; 0, 0, 0, 1)
|
||||
$
|
||||
|
||||
#instructornote[
|
||||
Because of the way we represent bits here, we also have the following property: \
|
||||
The columns of $A$ correspond to the output for each input---i.e, $A$ is just a table of outputs. \
|
||||
|
||||
#v(2mm)
|
||||
|
||||
For example, if we look at the first column of $A$ (which is $[1, 0]$), we see: \
|
||||
$A#ket(00) = A[1,0,0,0] = [1,0] = #ket(0)$
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Also with the last column (which is $[0,1]$): \
|
||||
$A#ket(00) = A[0,0,0,1] = [0,1] = #ket(1)$
|
||||
]
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#remark()
|
||||
The way a quantum circuit handles information is a bit different than the way a classical circuit does. We usually think of logic gates as _functions_: they consume one set of bits, and return another/
|
||||
|
||||
// TODO: and gate (input a, input b, output)
|
||||
|
||||
#v(2mm)
|
||||
|
||||
This model, however, won't work for quantum logic. If we want to understand quantum gates, we need to see them not as _functions_, but as _transformations_. This distinction is subtle, but significant:
|
||||
- functions _consume_ a set of inputs and _produce_ a set of outputs
|
||||
- transformations _change_ a set of objects, without adding or removing any elements
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Our usual logic circuit notation models logic gates as functions—we thus can't use it. We'll need a different diagram to draw quantum circuits.
|
||||
|
||||
#v(1fr)
|
||||
|
||||
First, we'll need a set of bits. For this example, we'll use two, drawn in a vertical array. We'll also add a horizontal time axis, moving from left to right:
|
||||
|
||||
#align(center)[
|
||||
// Quantum circuit diagram showing two qubits over time
|
||||
#box(width: 10cm, height: 4cm)[
|
||||
_[Quantum circuit diagram with time axis would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
In the diagram above, we didn't change our bits—so the labels at the start match those at the end.
|
||||
|
||||
#v(1fr)
|
||||
|
||||
Thus, our circuit forms a grid, with bits ordered vertically and time horizontally. If we want to change our state, we draw transformations as vertical boxes. Every column represents a single transformation on the entire state:
|
||||
|
||||
#align(center)[
|
||||
// Quantum circuit with transformations
|
||||
#box(width: 10cm, height: 4cm)[
|
||||
_[Quantum circuit with transformations $T_1$, $T_2$, $T_3$ would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
Note that the transformations above span the whole state. This is important: we cannot apply transformations to individual bits—we always transform the _entire_ state.
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
*Setup:* Say we want to invert the first bit of a two-bit state. That is, we want a transformation $T$ so that
|
||||
|
||||
#align(center)[
|
||||
// Circuit showing bit flip
|
||||
#box(width: 8cm, height: 3cm)[
|
||||
_[Circuit diagram showing first bit flip would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
In other words, we want a matrix $T$ satisfying the following equalities:
|
||||
- $T #ket("00") = #ket("10")$
|
||||
- $T #ket("01") = #ket("11")$
|
||||
- $T #ket("10") = #ket("00")$
|
||||
- $T #ket("11") = #ket("01")$
|
||||
|
||||
#problem()
|
||||
Find the matrix that corresponds to the above transformation.
|
||||
|
||||
#hint[Remember that $#ket("0") = mat(1; 0)$ and $#ket("1") = mat(0; 1)$. Also, we found earlier that $X = mat(0, 1; 1, 0)$, and of course $I = mat(1, 0; 0, 1)$.]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
*Remark:* We could draw the above transformation as a combination $X$ and $I$ (identity) gate:
|
||||
|
||||
#align(center)[
|
||||
// Circuit with X and I gates
|
||||
#box(width: 6cm, height: 3cm)[
|
||||
_[Circuit diagram with X gate on first qubit, I gate on second would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
We can even omit the $I$ gate, since we now know that transformations affect the whole state:
|
||||
|
||||
#align(center)[
|
||||
// Simplified circuit with just X gate
|
||||
#box(width: 6cm, height: 3cm)[
|
||||
_[Simplified circuit diagram with just X gate on first qubit would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
We're now done: this is how we draw quantum circuits. Don't forget that transformations _always_ affect the whole state—even if our diagram doesn't explicitly state this.
|
||||
|
||||
#pagebreak()
|
@ -0,0 +1,42 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= Quantum Gates
|
||||
|
||||
In the previous section, we stated that a quantum gate is a linear map. Let's complete that definition.
|
||||
|
||||
#definition()
|
||||
A quantum gate is a _orthonormal matrix_, which means any gate $G$ satisfies $G G^T = I$.
|
||||
|
||||
This implies the following:
|
||||
|
||||
- $G$ is square. In other words, it has as many rows as it has columns.
|
||||
|
||||
#note[If we think of $G$ as a map, this means that $G$ has as many inputs as it has outputs. This is to be expected: we stated earlier that quantum gates do not destroy or create qubits.]
|
||||
|
||||
- $G$ preserves lengths; i.e $|x| = |G x|$.
|
||||
|
||||
#note[This ensures that $G #ket([$psi$])$ is always a valid state.]
|
||||
|
||||
(You will prove all these properties in any introductory linear algebra course. This isn't a lesson on linear algebra, so you may take them as given today.)
|
||||
|
||||
*Remark:* Let $G$ be a quantum gate. Since quantum gates are, by definition, _linear_ maps, the following holds:
|
||||
|
||||
$ G(a_0 #ket("0") + a_1 #ket("1")) = a_0 G #ket("0") + a_1 G #ket("1") $
|
||||
|
||||
#problem()<cnot>
|
||||
Consider the _controlled not_ (or _cnot_) gate, defined by the following table:
|
||||
- $X_c #ket("00") = #ket("00")$
|
||||
- $X_c #ket("01") = #ket("01")$
|
||||
- $X_c #ket("10") = #ket("11")$
|
||||
- $X_c #ket("11") = #ket("10")$
|
||||
|
||||
In other words, the cnot gate inverts its second bit if its first bit is $#ket("1")$.
|
||||
|
||||
Find the matrix that applies the cnot gate.
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
53
src/Advanced/Introduction to Quantum/src/parts/06 hxh.typ
Normal file
@ -0,0 +1,53 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= HXH
|
||||
|
||||
Let's return to the quantum circuit diagrams we discussed a few pages ago. Keep in mind that we're working with quantum gates and proper qubits—not classical bits, as we were before.
|
||||
|
||||
#definition("Controlled Inputs")
|
||||
A _control input_ or _inverted control input_ may be attached to any gate. These are drawn as filled and empty circles in our circuit diagrams:
|
||||
|
||||
#align(center)[
|
||||
#grid(columns: (1fr, 1fr),
|
||||
[
|
||||
// Non-inverted control circuit diagram would go here
|
||||
#box(width: 6cm, height: 4cm)[
|
||||
_[Non-inverted control input circuit would go here]_
|
||||
]
|
||||
],
|
||||
[
|
||||
// Inverted control circuit diagram would go here
|
||||
#box(width: 6cm, height: 4cm)[
|
||||
_[Inverted control input circuit would go here]_
|
||||
]
|
||||
]
|
||||
)]
|
||||
|
||||
#v(2mm)
|
||||
|
||||
An $X$ gate with a (non-inverted) control input behaves like an $X$ gate if _all_ its control inputs are $#ket("1")$, and like $I$ otherwise. An $X$ gate with an inverted control inputs does the opposite, behaving like $I$ if its input is $#ket("1")$ and like $X$ otherwise. The two circuits above illustrate this fact—take a look at their inputs and outputs.
|
||||
|
||||
#v(2mm)
|
||||
|
||||
Of course, we can give a gate multiple controls. An $X$ gate with multiple controls behaves like an $X$ gate if...
|
||||
- all non-inverted controls are $#ket("1")$, and
|
||||
- all inverted controls are $#ket("0")$
|
||||
|
||||
...and like $I$ otherwise.
|
||||
|
||||
#problem()
|
||||
What are the final states of the qubits in the diagram below?
|
||||
|
||||
#align(center)[
|
||||
// Multi-control circuit diagram would go here
|
||||
#box(width: 8cm, height: 6cm)[
|
||||
_[Multi-control circuit diagram would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
@ -0,0 +1,48 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= Superdense Coding
|
||||
|
||||
Consider the following entangled two-qubit states, called the _bell states_:
|
||||
- $#ket([$Phi^+$]) = 1/sqrt(2) #ket("00") + 1/sqrt(2) #ket("11")$
|
||||
- $#ket([$Phi^-$]) = 1/sqrt(2) #ket("00") - 1/sqrt(2) #ket("11")$
|
||||
- $#ket([$Psi^+$]) = 1/sqrt(2) #ket("01") + 1/sqrt(2) #ket("10")$
|
||||
- $#ket([$Psi^-$]) = 1/sqrt(2) #ket("01") - 1/sqrt(2) #ket("10")$
|
||||
|
||||
#problem()
|
||||
The probabilistic bits we get when measuring any of the above may be called _anticorrelated bits_.
|
||||
|
||||
If we measure the first bit of any of these states and observe $1$, what is the resulting compound state?
|
||||
|
||||
What if we observe $0$ instead?
|
||||
|
||||
Do you see why we can call these bits anticorrelated?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
Show that the bell states are orthogonal
|
||||
|
||||
#hint[Dot product]
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()<bellmeasure>
|
||||
Say we have a pair of qubits in one of the four bell states.
|
||||
|
||||
How can we find out which of the four states we have, with certainty?
|
||||
|
||||
#hint[$H #ket("+") = #ket("0")$, and $H #ket("-") = #ket("1")$]
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
||||
|
||||
#definition()
|
||||
The $Z$ gate is defined as follows:
|
||||
$ Z mat(psi_0; psi_1) = mat(psi_0; -psi_1) $
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
@ -0,0 +1,31 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Define quantum notation macros
|
||||
#let ket(content) = $|#content angle.r$
|
||||
#let bra(content) = $angle.l #content|$
|
||||
|
||||
= Quantum Teleportation
|
||||
|
||||
Superdense coding lets us convert quantum bandwidth into classical bandwidth. Quantum teleportation does the opposite, using two classical bits and an entangled pair to transmit a quantum state.
|
||||
|
||||
*Setup:* Again, suppose Alice and Bob each have half of a $#ket([$Phi^+$])$ state. We'll call the state Alice wants to teleport $#ket(math.psi) = psi_0 #ket("0") + psi_1 #ket("1")$.
|
||||
|
||||
#problem()
|
||||
What is the three-qubit state $#ket(math.psi) #ket([$Phi^+$])$ in terms of $psi_0$ and $psi_1$?
|
||||
|
||||
#v(1fr)
|
||||
|
||||
#problem()
|
||||
To teleport $#ket(math.psi)$, Alice applies the following circuit to her two qubits, where $#ket([$Phi^+_"A"$])$ is her half of $#ket([$Phi^+$])$. She then measures both qubits and sends the result to Bob.
|
||||
|
||||
#align(center)[
|
||||
// Teleportation circuit diagram would go here
|
||||
#box(width: 8cm, height: 4cm)[
|
||||
_[Quantum teleportation circuit diagram would go here]_
|
||||
]
|
||||
]
|
||||
|
||||
What should Bob do so that $#ket([$Phi^+_"B"$])$ takes the state $#ket(math.psi)$ had initially?
|
||||
|
||||
#v(1fr)
|
||||
#pagebreak()
|
@ -1,5 +1,6 @@
|
||||
\definition{}
|
||||
The \textit{integer lattice} $\mathbb{Z}^n \subset \mathbb{R}^n$ is the set of points with integer coordinates.
|
||||
The \textit{integer lattice} $\mathbb{Z}^n$ is the set of points with integer coordinates in $n$ dimensions. \par
|
||||
For example, $\mathbb{Z}^3$ is the set of points $(a, b, c)$ where $a$, $b$, and $c$ are integers.
|
||||
|
||||
\problem{}
|
||||
Draw $\mathbb{Z}^2$.
|
||||
@ -8,12 +9,13 @@ Draw $\mathbb{Z}^2$.
|
||||
|
||||
|
||||
\definition{}
|
||||
We say a set of vectors $\{v_1, v_2, ..., v_k\}$ \textit{generates} $\mathbb{Z}^n$ if every lattice point can be written uniquely as
|
||||
We say a set of vectors $\{v_1, v_2, ..., v_k\}$ \textit{generates} $\mathbb{Z}^n$
|
||||
if every lattice point can be written as
|
||||
$$
|
||||
a_1v_1 + a_2v_2 + ... + a_kv_k
|
||||
$$
|
||||
for integer coefficients $a_i$. \par
|
||||
It is fairly easy to show that $k$ must be at least $n$.
|
||||
\textbf{Bonus:} show that $k$ must be at least $n$.
|
||||
|
||||
\problem{}
|
||||
Which of the following generate $\mathbb{Z}^2$?
|
||||
@ -30,8 +32,7 @@ Which of the following generate $\mathbb{Z}^2$?
|
||||
\vfill
|
||||
|
||||
\problem{}
|
||||
Find a set of two vectors that generates $\mathbb{Z}^2$. \\
|
||||
Don't say $\{ (0, 1), (1, 0) \}$, that's too easy.
|
||||
Find a set of two vectors other than $\{ (0, 1), (1, 0) \}$ that generates $\mathbb{Z}^2$. \\
|
||||
|
||||
\vfill
|
||||
|
||||
@ -44,7 +45,8 @@ Find a set of vectors that generates $\mathbb{Z}^n$.
|
||||
\pagebreak
|
||||
|
||||
\definition{}
|
||||
A \textit{fundamental region} of a lattice is the parallelepiped spanned by a generating set. The exact shape of this region depends on the generating set we use.
|
||||
Say we have a generating set of a lattice. \par
|
||||
The \textit{fundamental region} of this set is the $n$-dimensional parallelogram spanned by its members. \par
|
||||
|
||||
\problem{}
|
||||
Draw two fundamental regions of $\mathbb{Z}^2$ using two different generating sets. Verify that their volumes are the same.
|
||||
|
@ -1,6 +1,6 @@
|
||||
\section{Minkowski's Theorem}
|
||||
|
||||
\theorem{Blichfeldt's Theorem}
|
||||
\theorem{Blichfeldt's Theorem}<blich>
|
||||
Let $X$ be a finite connected region. If the volume of $X$ is greater than $1$, $X$ must contain two distinct points that differ by an element of $\mathbb{Z}^n$. In other words, there exist distinct $x, y \in X$ so that $x - y \in \mathbb{Z}^n$.
|
||||
|
||||
\vspace{2mm}
|
||||
@ -9,14 +9,22 @@ Intuitively, this means that you can translate $X$ to cover two lattice points a
|
||||
|
||||
|
||||
\problem{}
|
||||
Draw a region in $\mathbb{R}^2$ with volume greater than 1 that contains no lattice points. Find two points in that region which differ by an integer vector.
|
||||
Draw a connected region in $\mathbb{R}^2$ with volume greater than 1 that contains no lattice points. Find two points in that region which differ by an integer vector.
|
||||
\hint{Area is two-dimensional volume.}
|
||||
|
||||
\vfill
|
||||
|
||||
|
||||
\problem{}
|
||||
The following picture gives an idea for the proof of Blichfeldt's theorem in $\mathbb{Z}^2$. Explain the picture and complete the proof.
|
||||
Draw a \textit{disconnected} region in $\mathbb{R}^2$ with volume greater than 1 that contains no lattice points, \par
|
||||
and show that no two points in that region differ by an integer vector.
|
||||
\note{In other words, show that \ref{blich} indeed requires a connected region.}
|
||||
|
||||
\vfill
|
||||
|
||||
\problem{}
|
||||
The following picture gives an idea for the proof of Blichfeldt's theorem in $\mathbb{Z}^2$. \par
|
||||
Explain the picture and complete the proof.
|
||||
|
||||
\begin{center}
|
||||
\includegraphics[angle=90,width=0.5\linewidth]{proof.png}
|
||||
@ -48,10 +56,8 @@ Let $X$ be a region $\in \mathbb{R}^2$ of volume $k$. How many integral points m
|
||||
A region $X$ is \textit{convex} if the line segment connecting any two points in $X$ lies entirely in $X$.
|
||||
|
||||
\problem{}
|
||||
\begin{itemize}
|
||||
\item Draw a convex region in the plane.
|
||||
\item Draw a region that is not convex.
|
||||
\end{itemize}
|
||||
Draw a convex region in two dimensions. \par
|
||||
Then, draw a two-dimensional region that is \textit{not} convex.
|
||||
|
||||
\vfill
|
||||
\pagebreak
|
||||
@ -59,23 +65,28 @@ A region $X$ is \textit{convex} if the line segment connecting any two points in
|
||||
|
||||
|
||||
\definition{}
|
||||
We say a region $X$ is \textit{symmetric} if for all points $x \in X$, $-x$ is also in $X$.
|
||||
We say a region $X$ is \textit{symmetric with respect to the origin} if for all points $x \in X$, $-x$ is also in $X$. \par
|
||||
In the following problems, \say{\textit{symmetric}} means \say{symmetric with respect to the origin.}
|
||||
|
||||
\problem{}
|
||||
\begin{itemize}
|
||||
\item Draw a symmetric region.
|
||||
\item Draw an asymmetric region.
|
||||
\end{itemize}
|
||||
Draw a symmetric region. \par
|
||||
Then, draw an asymmetric region.
|
||||
|
||||
\vfill
|
||||
|
||||
\problem{}
|
||||
Show that a convex symmetric set always contains the origin.
|
||||
|
||||
\vfill
|
||||
|
||||
\theorem{Minkowski's Theorem}<mink>
|
||||
Every convex set in $\mathbb{R}^n$ that is symmetric with respect to the origin and which has a volume greater than $2^n$ contains an integral point that isn't zero.
|
||||
Every convex set in $\mathbb{R}^n$ that is symmetric and has a volume \par
|
||||
greater than $2^n$ contains an integral point that isn't zero.
|
||||
|
||||
|
||||
\problem{}
|
||||
Draw a few sets that satisfy \ref{mink} in $\mathbb{R}^2$. \par
|
||||
What is the simplest region that has the properties listed above?
|
||||
What is a simple class of regions that has the properties listed above?
|
||||
|
||||
\vfill
|
||||
|
||||
|
26
src/Advanced/Wallpaper/main.typ
Normal file
@ -0,0 +1,26 @@
|
||||
#import "@local/handout:0.1.0": *
|
||||
|
||||
// Resources:
|
||||
//
|
||||
// https://eschermath.org/wiki/Wallpaper_Patterns.html
|
||||
// https://mathworld.wolfram.com/WallpaperGroups.html
|
||||
// https://en.wikipedia.org/wiki/Wallpaper_group
|
||||
|
||||
#show: handout.with(
|
||||
title: [Wallpaper Symmetry],
|
||||
by: "Mark",
|
||||
)
|
||||
|
||||
#include "parts/00 intro.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "parts/01 reflect.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "parts/02 rotate.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "parts/03 problems.typ"
|
||||
#pagebreak()
|
||||
|
||||
#include "parts/04 theorem.typ"
|
7
src/Advanced/Wallpaper/meta.toml
Normal file
@ -0,0 +1,7 @@
|
||||
[metadata]
|
||||
title = "Wallpaper Symmetries"
|
||||
|
||||
|
||||
[publish]
|
||||
handout = true
|
||||
solutions = true
|
151
src/Advanced/Wallpaper/parts/00 intro.typ
Normal file
@ -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)
|
132
src/Advanced/Wallpaper/parts/01 reflect.typ
Normal file
@ -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)
|
181
src/Advanced/Wallpaper/parts/02 rotate.typ
Normal file
@ -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)
|
67
src/Advanced/Wallpaper/parts/03 problems.typ
Normal file
@ -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])
|
100
src/Advanced/Wallpaper/parts/04 theorem.typ
Normal file
@ -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)
|
BIN
src/Advanced/Wallpaper/res/**.png
Normal file
After Width: | Height: | Size: 535 KiB |
BIN
src/Advanced/Wallpaper/res/*632-a.png
Normal file
After Width: | Height: | Size: 484 KiB |
BIN
src/Advanced/Wallpaper/res/*632-b.png
Normal file
After Width: | Height: | Size: 280 KiB |
BIN
src/Advanced/Wallpaper/res/*x-a.png
Normal file
After Width: | Height: | Size: 666 KiB |
BIN
src/Advanced/Wallpaper/res/*x-b.png
Normal file
After Width: | Height: | Size: 160 KiB |
BIN
src/Advanced/Wallpaper/res/3*3.png
Normal file
After Width: | Height: | Size: 533 KiB |
BIN
src/Advanced/Wallpaper/res/333.png
Normal file
After Width: | Height: | Size: 568 KiB |
86
src/Advanced/Wallpaper/res/escher/pmm.svg
Normal file
@ -0,0 +1,86 @@
|
||||
<?xml version="1.0" standalone="no"?>
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20001102//EN" "http://www.w3.org/TR/2000/CR-SVG-20001102/DTD/svg-20001102.dtd">
|
||||
<svg xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="10.16cm" height="5.08cm" viewBox="0 0 384 192">
|
||||
<title>pmm</title>
|
||||
<desc>Exported by Tess 1.70.</desc>
|
||||
<clipPath id="mainclip"><rect x="0" y="0" width="384" height="192"/></clipPath>
|
||||
<g style="fill-rule:evenodd; stroke-linejoin:round; stroke-linecap:round; clip-path:url(#mainclip)">
|
||||
<defs>
|
||||
<g id="Tess0p">
|
||||
<path d="
|
||||
M7.1306642022,-41.0013191628
|
||||
L7.1306642022,-7.1306642022
|
||||
L89.1333025278,-7.1306642022
|
||||
L7.1306642022,-42.7839852134
|
||||
"/></g>
|
||||
<g id="Tess0" style="fill:none; stroke:none"><use xlink:href="#Tess0p"/></g>
|
||||
<g id="Tess1" style="fill:none; stroke:rgb(0,0,0); stroke-width:1.7826660506"><use xlink:href="#Tess0p"/></g>
|
||||
</defs>
|
||||
<g transform="translate(192,96) rotate(0) scale(0.5609575611,0.5609575611)">
|
||||
<g transform="translate(-405.2631578947,-100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,0)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,200)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,0)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,200)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-100)"><use xlink:href="#Tess1"/></g>
|
||||
<g><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,200)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,0)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,100)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,200)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-200) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,0) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-200) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-200) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,0) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,-200) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,-100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,0) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,100) rotate(180)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,0) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,200) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,200) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,0) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,200) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,-100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,0) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,100) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(405.2631578947,200) rotate(180) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,-200) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,-100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,0) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-405.2631578947,100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-200) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,-100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,0) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(-202.6315789474,100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-200) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,-100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(0,100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-200) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,-100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,0) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
<g transform="translate(202.6315789474,100) scale(1,-1)"><use xlink:href="#Tess1"/></g>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
After Width: | Height: | Size: 6.3 KiB |
BIN
src/Advanced/Wallpaper/res/wiki/Wallpaper_group-cm-4.jpg
Normal file
After Width: | Height: | Size: 800 KiB |
BIN
src/Advanced/Wallpaper/res/wiki/Wallpaper_group-p4g-2.jpg
Normal file
After Width: | Height: | Size: 436 KiB |
6662
src/Advanced/Wallpaper/res/wolfram/all.svg
Normal file
After Width: | Height: | Size: 991 KiB |
8784
src/Advanced/Wallpaper/res/wolfram/cm.svg
Normal file
After Width: | Height: | Size: 233 KiB |
8192
src/Advanced/Wallpaper/res/wolfram/cmm.svg
Normal file
After Width: | Height: | Size: 236 KiB |
6392
src/Advanced/Wallpaper/res/wolfram/p1.svg
Normal file
After Width: | Height: | Size: 196 KiB |
6958
src/Advanced/Wallpaper/res/wolfram/p2.svg
Normal file
After Width: | Height: | Size: 178 KiB |
7653
src/Advanced/Wallpaper/res/wolfram/p3.svg
Normal file
After Width: | Height: | Size: 205 KiB |
11315
src/Advanced/Wallpaper/res/wolfram/p31m.svg
Normal file
After Width: | Height: | Size: 299 KiB |
9995
src/Advanced/Wallpaper/res/wolfram/p3m1.svg
Normal file
After Width: | Height: | Size: 264 KiB |
10133
src/Advanced/Wallpaper/res/wolfram/p4.svg
Normal file
After Width: | Height: | Size: 268 KiB |
7894
src/Advanced/Wallpaper/res/wolfram/p4g.svg
Normal file
After Width: | Height: | Size: 204 KiB |
8247
src/Advanced/Wallpaper/res/wolfram/p4m.svg
Normal file
After Width: | Height: | Size: 229 KiB |
10580
src/Advanced/Wallpaper/res/wolfram/p6.svg
Normal file
After Width: | Height: | Size: 273 KiB |
13887
src/Advanced/Wallpaper/res/wolfram/p6m.svg
Normal file
After Width: | Height: | Size: 379 KiB |
6068
src/Advanced/Wallpaper/res/wolfram/pg.svg
Normal file
After Width: | Height: | Size: 176 KiB |
5703
src/Advanced/Wallpaper/res/wolfram/pgg.svg
Normal file
After Width: | Height: | Size: 147 KiB |
5985
src/Advanced/Wallpaper/res/wolfram/pm.svg
Normal file
After Width: | Height: | Size: 163 KiB |
6908
src/Advanced/Wallpaper/res/wolfram/pmg.svg
Normal file
After Width: | Height: | Size: 178 KiB |
8486
src/Advanced/Wallpaper/res/wolfram/pmm.svg
Normal file
After Width: | Height: | Size: 226 KiB |
BIN
src/Advanced/Wallpaper/res/xx-a.png
Normal file
After Width: | Height: | Size: 81 KiB |
BIN
src/Advanced/Wallpaper/res/xx-b.png
Normal file
After Width: | Height: | Size: 406 KiB |
@ -1,6 +1,7 @@
|
||||
[default]
|
||||
extend-words."LSAT" = "LSAT"
|
||||
extend-words."ket" = "ket"
|
||||
extend-words."typ" = "typ"
|
||||
|
||||
extend-ignore-re = [
|
||||
# spell:disable-line
|
||||
|