Outline

• Sets and how to have more sets
• Quiz
• Relations
• Graphs
• Power and Successor Sets
• Natural Numbers
• Functions

Introduction

• In order to begin learning about automata theory and computability we need to first fix some common notations based on sets as well as learn about various methods of proof.
• So that's what we'll start learning about today.
• These slides use ASCIIMathML.js to output math as MathML. If your browser is Gecko-based (Firefox), or if you use IE with MathPlayer, they should render correctly. Eventually, hopefully, Webkit-based browsers and Opera will support MathML, but for the time-being they don't -- except in nightly-builds.

Sets

• A set is a group of objects represented together as a unit. For example:
  • `{7, 21, 57}` -- the set containing the number `7`, `21`, `57`.
  • `{ {}, {a}, mbox{apple}}` -- the set containing the empty set, the set `{a}`, and an apple.
• We use `\in` to mean element of and `!in` to mean not element of. For example, `7 in {7,21, 57}`, `5 !in {7,21, 57 }`.

Subsets

To make statements (true or false propositions) about sets we will often use abbreviations:

• We write `forall` to mean "for all", write `exists` to mean "exists", and we will write `^^`, `vv`, `not`, `implies` for "and", "or", "not", and "implies".
• As an example, consider the symbol `subseteq` which means subset of. The statement `A subseteq B` can be defined using the symbols above as `forall x (x in A implies x in B)`
• So `{7, 21} subseteq {3, 7, 5, 21, 82}` is a true statement since `7 in {3, 7, 5, 21, 82}\ ^^ \ 21 in {3, 7, 5, 21, 82}`.
• We write `A=B` to mean `A subseteq B ^^ B subseteq A`
• We write `A subset B` (`A` is proper subset of `B` ) to mean `A subseteq B ^^ not B subseteq A`

More on sets

• Order of elements doesn't matter for sets. For example, `{1,5} = {5,1}`.
• Repetitions also don't matter: `{1,1,1,4,4,5} = {1, 4, 5}`.
• If we want repetitions to matter but still don't care about order then we have a multiset.
• To get a better grasp of how sets work, you might think about how you would implement them as a class in a computer language like Java.
• In the next few slides we will define operations on sets which would need to be implemented as methods.

Set comprehension and basic ways to make new sets

• The set which doesn't have any elements in it is called the empty set and is denoted by either `{}` or `emptyset`.
• To create new sets we will sometimes write `{x | P(x) }` which should be read as "the set of objects `x` such that property `P(x)` holds." (Sometimes this is called set comprehension)
• Let's look at some examples of using set comprehension to define new ways of making sets.
• Given two sets A and B, we can:
  • Take their union `A cup B = {x | x in A vv x in B}`.
  • Take their intersection `A cap B = {x | x in A ^^ x in B}`.
  • Take their difference `A - B = {x | x in A ^^ x !in B}` You will also often see this written `A \\ B`.
• If we have a universe, `U`, under consideration, then taking the difference with respect to this set is called taking a complement. This is written as `bar A = U - A`.

Examples, Partitions, and DeMorgan's Laws

• Let `A={1,2}` and `B={2,3}`, then `A cup B= {1, 2, 3}`, `A cap B={2}`, and `A-B = {1}`.
• If `U={1,2,3}`, then `bar A ={3}`.
• Notice for any set `C`, `C =bar bar C` .
• Given two sets `C` and `D`. If `C cap D = emptyset`, we say `C` and `D` are disjoint.
• If `S_1, ldots, S_n` are each subsets of `S` such that:
  1. `S_1 cup S_2 cdots cup S_n = S`,
  2. For each `i` and `j`, `S_i cap S_j = emptyset,
  3. For each `i`, `S_i != emptyset`;
  then we call `S_1, ldots, S_n` a partition of `S`.
• DeMorgan gave some useful relationships between the set creation operations we have defined so far. Namely, for any sets `C` and `D`, `C cap D= bar(bar C cup bar D)` and `C cup D = bar(bar C cap bar D)`.

Quiz

Which of the following is true?

1. XML is a web-based language for specifying Turing Machines.
2. Context-Free Grammars are useful in the design of compression algorithms.
3. Regular Expressions are too simple to be useful for string matching.

Cartesian Product and Relations

• Another useful way to create sets is to be able to create the set of ordered pairs from two sets `A`, `B` denoted: `A times B={(a,b) | a in A ^^ b in B}` .
• Here `(a,b)` abbreviates `{a, {a,b}}`.
• This operation is called Cartesian product.
• We can iterate it to make 3-tuples, 4-tuples, etc: `A times B times C = A times (B times C)`, `A times B times C times D`, etc.
• If rather than use different sets we always use the same set, then we are taking the Cartesian power.
• We define `A^1 := A`, `A^(n+1) := A^n times A`. This is an example of an inductive definition. You could imagine implementing such a definition with a for loop in a programming language. We start with a base case and we iterate `1`, `2`, `3`, until we get to the `n+1` we want.
• Given sets `A_1, A_2, ldots, A_n` a subset `R subseteq A_1 times ldots times A_n` is called an `n`-ary relation. (For `n=1`, unary relation; for `n=2`, binary relation).
• For example, a graph is an ordered pair `(V, E)` where `V` is a set of vertices and `E` is a set of edges on `V`. An edge is a pair `(v,w) in V times V`. So `E` is an example of a binary relation.

Power Set

• Given a set `A`, we define its power set, `2^A` (also written `P(A)`), to be the set of all subsets of `A`. i.e.,
  `2^A := {X | X subseteq A}`.
• For example, if `A={a,b,c}`, then `2^A` is `{emptyset, {a}, {b}, {c}, {a,b}, {a,c}, {b,c}, {a,b,c}}`.

Successor sets

• Define `S(x):= x cup {x}`.
• Notice `S(x)` is a set with one more element than the set `x`. For instance: `S(emptyset) = emptyset cup {emptyset}={emptyset}`, `S(S(emptyset))=S({emptyset})= {emptyset} cup {{emptyset}}= {emptyset, {emptyset}}`, `S(S(S(emptyset))) = {emptyset, {emptyset}, {emptyset, {emptyset}}}`, etc.
• As we will see we can use this successor operation to define the natural numbers.

Axiom of Infinity

• In a similar fashion to set comprehension, we will sometimes create new sets by believing in the existence of a set which satisfies some list of properties.
• For instance, the axiom of infinity says there is a set satisfying:
  1. `emptyset in N`
  2. if `x in N` then `S(x) in N`.
• You might ask yourself how exactly one could implement this axiom on a computer?
  • The most important property of a set is what elements it contains.
  • We could define a class InfiniteSet.
  • Its constructor could take a Set of starting elements, start.
  • InfiniteSet's isIn(x) method takes a Set x and returns whether it is in the instance of InfiniteSet or not.
  • To do this, it first checks if `x` is `emptyset` or if `x in mbox{start}`, if so it returns true.
  • If not, it check if `x=S(y)`, for some `y` (this check is implementable if `y` is not too complicated). If not, then isIn(x) returns false.
  • If yes, then isIn(x) returns the values of isIn(y).

The Set of Natural Numbers

• The smallest set satisfying the axiom of infinity is called `omega`.
• To make this smallest set we can take start to be just `emptyset` in our constructor of InfiniteSet from the last slide.
• Its elements are called the natural numbers.
• `omega` is called the set of natural numbers also written `NN`.
• We interpret `emptyset` to mean `0` and `S(x)` to mean `x+1`.
• `omega` contains `emptyset = 0, S(emptyset) = 1, S(S(emptyset)) = 2, ldots, S^n(emptyset) = n ldots`. It is in fact the union of these finite successor sets.
• For two natural numbers `x`, `y` we say `x < y` if `x in y`.
• Notice we can define addition and multiplication on the natural numbers with rules: (a) `x + 0 = x` (b) `x+ S(y) = S(x+y)`, (c) `x cdot 0 = 0`, (d) `x cdot S(y) = x cdot y + x`.
• These rules give us algorithms for computing `+` and `cdot` based on our definition of `S(x)`.
• If you wanted to, you could keep going and take `S(omega), S(S(omega)), ldots`, if you were careful enough you would have a definition of what's known as the class of ordinal numbers.

Functions

• A function is a binary relation `f subseteq D times R` such that each `x in D` occurs in exactly one pair `(x,y) in f`.
• Rather than write `f subseteq D times R`, we write `f:D rightarrow R` to say `f` is a function or mapping from `D` (called the domain) to `R` (called the range).
• We write `f(a)=b` to say that `f` maps the element `a` of `D` to `b` of `R`.
• For example, `f:NN rightarrow NN`, where `f(x)=x^2` is a function.

Types of Functions

• A function is one-to-one (aka injective), if for every `x, y` in its domain `f(x) != f(y)`.
• For example, `f:NN rightarrow NN`, where `f(x)=2x` is injective.
• A function is onto (aka surjective), if for every `y` in its range there is some `x` in such that `f(x)=y`.
• For example, `f: NN rightarrow NN`, `f(x)= lfloor x/2 rfloor` is surjective.
• A function is a bijection if it is one-to-one and onto.

Size of sets

• A set is called finite if there is a bijection between it and an element of `omega`.
• The cardinality (aka size) of a finite set `A`, denoted `|A|`, is the natural number it is bijective with.
• For example, suppose `A={a,b}`. Consider `f:{a,b} rightarrow {emptyset,{emptyset}}=S(S(emptyset)) =2` defined by `f(a) = emptyset` and `f(b) ={emptyset}`. This is a bijection and shows `|A| = 2`.
• We call a set countably infinite if there is a bijection between it and the set of natural numbers.
• We call a set uncountably infinite, if it is not finite and it is not countable infinite.