636 lines
15 KiB
Typst
Executable File
636 lines
15 KiB
Typst
Executable File
#import "@local/handout:0.1.0": *
|
|
#import "@preview/cetz:0.4.2"
|
|
#import "../macros.typ": *
|
|
|
|
= Cycle Notation
|
|
|
|
#definition("Order")
|
|
The _order_ of a permutation $f$ is the smallest positive $n$ where $f^n (x) = x$ for all $x$. \
|
|
In other words, if we repeatedly apply a permutation with order $n$, \
|
|
we will get back to where we started after $n$ steps. \
|
|
|
|
#v(2mm)
|
|
|
|
For example, consider $[2134]$. This permutation has order $2$, as we can see below:
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.5 // scale
|
|
let del = 0.2 // small line
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (frame: "rect", stroke: none, fill: white, padding: .1))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
|
|
content((0 * s, 0 * s), $2$, name: "2b")
|
|
content((1 * s, 0 * s), $1$, name: "1b")
|
|
content((2 * s, 0 * s), $3$, name: "3b")
|
|
content((3 * s, 0 * s), $4$, name: "4b")
|
|
|
|
content((0 * s, -3 * s), $1$, name: "1c")
|
|
content((1 * s, -3 * s), $2$, name: "2c")
|
|
content((2 * s, -3 * s), $3$, name: "3c")
|
|
content((3 * s, -3 * s), $4$, name: "4c")
|
|
|
|
markline(s, "1a", "1b")
|
|
markline(s, "2a", "2b")
|
|
markline(s, "3a", "3b")
|
|
markline(s, "4a", "4b")
|
|
|
|
markline(s, "1b", "1c")
|
|
markline(s, "2b", "2c")
|
|
markline(s, "3b", "3c")
|
|
markline(s, "4b", "4c")
|
|
})),
|
|
)
|
|
|
|
Swapping the first two elements of a list twice changes nothing. \
|
|
Thus, $[2134]$ has an order of two.
|
|
|
|
|
|
#problem()
|
|
What is the order of $[2314]$? \
|
|
How about $[4321]$? \
|
|
#note(type: "Note")[Try to solve this problem without drawing any strings!]
|
|
|
|
#v(1fr)
|
|
|
|
#problem()
|
|
Find a permutation on five elements with order 4.
|
|
|
|
#v(1fr)
|
|
|
|
|
|
#problem(label: "finiteorder")
|
|
Show that all permutations on a finite set have a well-defined order. \
|
|
In other words, show that there must always be an integer $n$ where $f^n (x) = x$.
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
|
|
|
|
#definition("Composition", label: "compdef")
|
|
The _composition_ of two permutations $f$ and $g$ is the permutation $h(x) = f(g(x))$. \
|
|
We'll denote this by simply writing the permutations we're composing next to each other, like $f g$. \
|
|
Note that $g$ is applied _before_ $f$ in $f g$.
|
|
|
|
#problem()
|
|
Show that function composition is associative. \
|
|
That is, show that $f(g h) = (f g)h$.
|
|
|
|
#v(1fr)
|
|
|
|
#problem()
|
|
What is $[1324][4321]$? \
|
|
How about $[321][213][231]$? \
|
|
Rewrite these compositions as one permutation in square brackets.
|
|
|
|
#solution([
|
|
- $[1324][4321]$ is $[4321]$
|
|
- $[321][213][231]$ is $[123]$
|
|
])
|
|
|
|
|
|
#v(1fr)
|
|
|
|
|
|
As you may have noticed, the square-bracket notation we've been using thus far is a bit unwieldy.
|
|
Permutations are verbs---but we've been referring to them using a noun (i.e, their output).
|
|
|
|
Square-bracket notation fails to capture the structure of the permutation it identifies.
|
|
|
|
#v(2mm)
|
|
|
|
Is the permutation $[1234]$ different than the permutation $[12345]$? \
|
|
These permutations operate on different sets---but they are both the identity! \
|
|
Are $[5342761]$ and $[1342567][5234761]$ similar? What are their orders?
|
|
|
|
|
|
#v(2mm)
|
|
|
|
Good notation should help us understand the objects we are studying. \
|
|
We need something better than square brackets.
|
|
|
|
|
|
#pagebreak()
|
|
|
|
|
|
#remark("Cycles")
|
|
Any permutation is composed of a number of _cycles_. \
|
|
Reread @finiteorder to convince yourself of this fact.
|
|
|
|
|
|
#example()
|
|
Consider the permutation $[2134]$. \
|
|
It consists of one two-cycle: $1 arrow.r 2 arrow.r 1$, which we can see in the diagram below. \
|
|
#note(
|
|
type: "Note",
|
|
)[
|
|
$3 arrow.r 3$ and $4 arrow.r 4$ are also cycles, but we'll ignore them.
|
|
One-cycles aren't interesting.
|
|
]
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let del = 0.4 // small line
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (frame: "rect", stroke: none, fill: white, padding: .1))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
|
|
marklinetop(s, "1a", "2a")
|
|
marklinebot(s, "2a", "1a")
|
|
})),
|
|
)
|
|
|
|
#v(4mm)
|
|
|
|
The permutation $[431265]$ is a bit more interesting---it contains two cycles: \
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (frame: "rect", stroke: none, fill: white, padding: .1))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
content((4 * s, 3 * s), $5$, name: "5a")
|
|
content((5 * s, 3 * s), $6$, name: "6a")
|
|
|
|
|
|
marklinetop(s, "3a", "2a", del: 0.8)
|
|
marklinebot(s, "2a", "4a", del: 1.3)
|
|
marklinetop(s, "4a", "1a", del: 1.3)
|
|
marklinebot(s, "1a", "3a", del: 0.8)
|
|
marklinebot(s, "5a", "6a", del: 0.8, c: ogreen)
|
|
marklinetop(s, "6a", "5a", del: 0.8, c: ogreen)
|
|
})),
|
|
)
|
|
|
|
#remark()
|
|
Two-cycles may also be called _transpositions_. \
|
|
Any permutation that swaps two elements is a transposition.
|
|
|
|
#problem()
|
|
Find all cycles in $[5342761]$.
|
|
|
|
#solution[
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.5 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (
|
|
frame: "rect",
|
|
stroke: none,
|
|
padding: .1,
|
|
))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
content((4 * s, 3 * s), $5$, name: "5a")
|
|
content((5 * s, 3 * s), $6$, name: "6a")
|
|
content((6 * s, 3 * s), $7$, name: "7a")
|
|
|
|
|
|
marklinetop(s, "1a", "7a", del: 1.6)
|
|
marklinebot(s, "7a", "5a", del: 1.2)
|
|
marklinetopswap(s, "5a", "1a", del: 1.2)
|
|
|
|
|
|
marklinebot(s, "2a", "4a", del: 1.2, c: ogreen)
|
|
marklinetop(s, "4a", "3a", del: 0.8, c: ogreen)
|
|
marklinebotswap(s, "3a", "2a", del: 0.8, c: ogreen)
|
|
})),
|
|
)
|
|
|
|
There are two non-trivial cycles:
|
|
- $4 arrow.r 3 arrow.r 2 arrow.r 4$
|
|
- $1 arrow.r 7 arrow.r 5 arrow.r 1$
|
|
]
|
|
|
|
|
|
|
|
#v(1fr)
|
|
|
|
|
|
#problem()
|
|
What permutation on five objects is formed by the cycles $3 arrow.r 5 arrow.r 3$ and $1 arrow.r 2 arrow.r 4 arrow.r 1$? \
|
|
Write it in square-bracket notation.
|
|
|
|
#solution[
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (
|
|
frame: "rect",
|
|
stroke: none,
|
|
padding: .1,
|
|
))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
content((4 * s, 3 * s), $5$, name: "5a")
|
|
|
|
marklinetop(s, "3a", "5a", del: 0.8, c: ogreen)
|
|
marklinebot(s, "5a", "3a", del: 0.8, c: ogreen)
|
|
|
|
marklinebot(s, "1a", "2a", del: 0.8)
|
|
marklinetop(s, "2a", "4a", del: 1.2)
|
|
|
|
marklinebotswap(s, "4a", "1a", del: 1.2)
|
|
})),
|
|
)
|
|
|
|
|
|
This is $[41523]$.
|
|
]
|
|
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
|
|
#definition("Cycle Notation")
|
|
We can use cycles to develop better notation: \
|
|
Instead of identifying permutations using their output, we'll identify them using their _cycles_.
|
|
|
|
#v(2mm)
|
|
|
|
For example, we'll write $[2134]$ is $(12)$ in cycle notation, \
|
|
since it consists only of the cycle $1 arrow.r 2 arrow.r 1$:
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (
|
|
frame: "rect",
|
|
stroke: none,
|
|
padding: .1,
|
|
))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
|
|
marklinebot(s, "1a", "2a", del: 0.8)
|
|
marklinetop(s, "2a", "1a", del: 0.8)
|
|
})),
|
|
)
|
|
|
|
#v(2mm)
|
|
|
|
|
|
Permutations that consist of more than one cycle are written as a composition. \
|
|
$[2143]$ is written as $(12)(34)$. Applying the permutation $[2143]$ has the same effect as applying $(34)$, then applying $(12)$.
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (
|
|
frame: "rect",
|
|
stroke: none,
|
|
padding: .1,
|
|
))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
|
|
marklinetop(s, "1a", "2a", del: 0.8)
|
|
marklinebot(s, "2a", "1a", del: 0.8)
|
|
marklinetop(s, "3a", "4a", del: 0.8, c: ogreen)
|
|
marklinebot(s, "4a", "3a", del: 0.8, c: ogreen)
|
|
})),
|
|
)
|
|
|
|
|
|
|
|
#remark()
|
|
According to @finiteorder, any permutation may be written as a composition of disjoint cycles. \
|
|
Convince yourself of this fact.
|
|
|
|
#problem()
|
|
Rewrite $[431265]$ in cycle notation.
|
|
|
|
#solution[
|
|
$[431265]$ is $(1324)(56)$:
|
|
|
|
#table(
|
|
columns: (1fr,),
|
|
align: center,
|
|
stroke: none,
|
|
align(center, cetz.canvas({
|
|
import cetz.draw: *
|
|
|
|
let s = 0.6 // scale
|
|
let arrow = (
|
|
symbol: ")>",
|
|
scale: s * 2.2,
|
|
fill: oblue,
|
|
stroke: oblue,
|
|
)
|
|
|
|
set-style(content: (
|
|
frame: "rect",
|
|
stroke: none,
|
|
padding: .1,
|
|
))
|
|
content((0 * s, 3 * s), $1$, name: "1a")
|
|
content((1 * s, 3 * s), $2$, name: "2a")
|
|
content((2 * s, 3 * s), $3$, name: "3a")
|
|
content((3 * s, 3 * s), $4$, name: "4a")
|
|
content((4 * s, 3 * s), $5$, name: "5a")
|
|
content((5 * s, 3 * s), $6$, name: "6a")
|
|
|
|
marklinetop(s, "1a", "3a", del: 0.8, c: ogreen)
|
|
marklinebot(s, "4a", "1a", del: 1.3, c: ogreen)
|
|
marklinebot(s, "3a", "2a", del: 0.8, c: ogreen)
|
|
marklinetop(s, "2a", "4a", del: 1.3, c: ogreen)
|
|
|
|
marklinetop(s, "5a", "6a", del: 0.8)
|
|
marklinebot(s, "6a", "5a", del: 0.8)
|
|
})),
|
|
)
|
|
]
|
|
|
|
|
|
|
|
|
|
#remark()
|
|
The identity permutation $f(x) = x$ is written as $()$ in cycle notation.
|
|
|
|
|
|
|
|
#problem()
|
|
Convince yourself that disjoint cycles commute. \
|
|
That is, that $(1324)(56) = (56)(1324) = [431265]$ since $(1324)$ and $(56)$ do not overlap. \
|
|
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
#problem(label: "insquare")
|
|
Write the following in square-bracket notation.
|
|
|
|
- $(12)$ on a set of 2 elements
|
|
- $(12)(435)$ on a set of 5 elements
|
|
#v(2mm)
|
|
- $(321)$ on a set of 3 elements
|
|
- $(321)$ on a set of 6 elements
|
|
#v(2mm)
|
|
- $(1234)$ on a set of 4 elements
|
|
- $(3412)$ on a set of 4 elements
|
|
|
|
#note[
|
|
Note that $(12)$ refers the "swap first two" permutation on a set of _any_ size. \
|
|
We can use consistent notation for the same action on two different sets! \
|
|
]
|
|
|
|
#v(1fr)
|
|
|
|
|
|
|
|
#problem()
|
|
Write the following in square-bracket notation.
|
|
Pay attention!
|
|
- $(13)(243)$ on a set of 4 elements
|
|
- $(243)(13)$ on a set of 4 elements
|
|
|
|
#v(1fr)
|
|
|
|
|
|
|
|
#problem()
|
|
Consider the last two permutations in @insquare, $(1234)$ and $(3412)$. \
|
|
These are _identical_---they are the same cycle written in two different ways. \
|
|
List all other ways to write this cycle. \
|
|
#hint[There are two more.]
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
|
|
#definition("Inverse")
|
|
The _inverse_ of a permitation $f$ is a permutation $g$ that "un-does" $f$. \
|
|
This means that $g(f(x)) = x$ for all $x$.
|
|
|
|
#problem()
|
|
What is the inverse of $(12)$? \
|
|
How about $(123)$? And $(4231)$? \
|
|
#note[
|
|
Note we do not need to know the size of the set we are operating on. \
|
|
The inverse of $(12)$ is the same in sets of all sizes!
|
|
]
|
|
|
|
#v(1fr)
|
|
|
|
|
|
#problem()
|
|
Let $sigma$ be a permutation composed of disjoint cycles $sigma_1sigma_2...sigma_k$. \
|
|
Say we know the order of all $sigma_i$. What is the order of $sigma$?
|
|
|
|
#solution[
|
|
$
|
|
#text[lcm]\(#text[ord]\(sigma_1),#h(0.5em) #text[ord]\(sigma_2),#h(0.5em) ...,#h(0.5em) #text[ord]\(sigma_k))
|
|
$
|
|
]
|
|
|
|
|
|
#v(1fr)
|
|
|
|
#problem(label: "cycletrans")
|
|
Show that any cycle $(123...n)$ is equal to the product $(12)(23)...(n-1, n)$.
|
|
|
|
#solution[
|
|
*Intuition:*\
|
|
$(123...n)$ is a right-shift. Swapping all pairs from right to left achieves the same effect.
|
|
|
|
#v(2mm)
|
|
|
|
*Complete solution:* \
|
|
Consider $n-1$. After applying $(123...n)$, it takes the position of $n$.
|
|
|
|
After applying $(n-1, n)$, $n-1$ moves to the same position _and is never moved again!_ \
|
|
Repeat this argument for all other $n$.
|
|
]
|
|
|
|
#v(1fr)
|
|
|
|
#problem()
|
|
Write $(7126453)$ as a product of transpositions. \
|
|
|
|
#solution[
|
|
Move elements one at a time, and using the last position as temporary storage.
|
|
|
|
We get $(71)(72)(76)(74)(75)(73)$.
|
|
Other solutions are possible. \
|
|
|
|
#v(2mm)
|
|
|
|
*Bonus:* How can we do this in the fewest number of transpositions?
|
|
]
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
#problem(label: "simpletrans")
|
|
Show that any permutation is a product of transpositions.
|
|
|
|
#solution[
|
|
Re-use the argument in @cycletrans. \
|
|
Pick an arbitrary "working slot," and re-build all cycles. \
|
|
Use the "not touched again" argument for a proper proof.
|
|
]
|
|
|
|
#v(1fr)
|
|
|
|
|
|
#problem(label: "onetrans")
|
|
Show that any permutation is a product of transpositions of the form $(1, k)$. \
|
|
|
|
#solution[
|
|
Use @simpletrans to rewrite each $(a, b)$ as $(1, a)(1, b)(1, a)$. \
|
|
Showing that $(a, b) = (1, a)(1, b)(1, a)$ is fairly easy.
|
|
]
|
|
|
|
#v(1fr)
|
|
#pagebreak()
|
|
|
|
|
|
|
|
#problem(label: "oneplustrans")
|
|
Show that any transposition $(a, b)$ is equal to the product $(a, a+1)(a+1, b)(a, a+1)$.
|
|
|
|
#solution[
|
|
This is the same as @onetrans,
|
|
but we use $a + 1$ as a "working slot" instead of $1$.
|
|
]
|
|
|
|
#v(1fr)
|
|
|
|
|
|
|
|
#problem()
|
|
Show that any permutation is a product of adjacent transpositions. \
|
|
An _adjacent transposition_ swaps two adjacent elements, and thus looks like $(n, n+1)$.
|
|
|
|
#solution[
|
|
As before, we will use @simpletrans and rewrite the transpositions it produces in a convenient fashion.
|
|
To do this, we must show that every transposition $(a, b)$ is a product of adjacent transpositions.
|
|
|
|
#v(2mm)
|
|
|
|
In the proof below, assume that $a < b$ and perform induction on $b - a$. \
|
|
|
|
#v(4mm)
|
|
|
|
|
|
*Base Case:*\
|
|
If $b - a = 1$, $(a, b)$ is a product of adjacent transpositions. \
|
|
In fact, it _is_ an adjacent transposition.
|
|
|
|
#v(4mm)
|
|
|
|
*Induction:*\
|
|
Now, say $b - a = n + 1$. \
|
|
Assume that all $(a, b)$ where $b - a <= n$ are products of adjacent transpositions.\
|
|
By @oneplustrans, $(a, b) = (a, a+1)(a+1, b)(a, a+1)$.
|
|
|
|
#v(2mm)
|
|
|
|
$(a, a+1)$ is an adjacent transposition, and $b - (a+1) = n$. \
|
|
Thus, $(a, b)$ is a product of adjacent transpositions.
|
|
]
|
|
|
|
#v(1fr)
|