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.
• Before we do that, let me briefly introduce the slide system I am using...
• These slides are written in HTML and use a Javascript program called MathJax to render math. The actual text form of the math used is ASCIIMathML variant of LaTeX. MathJax converts this text to MathML which your browser is supposed to render. This should work on all modern browsers, provided Javascript is turned on, but let me know if you have any problems
• In addition, these slides are written in HTML using an old hacked version of slidy.js to present the HTML as a slideshow. This hack version allows you to add notes to slides by clicking on the notes? link.
• Over the weekend, I hacked this version further so that it now, like modern slidy, supports touch events like swipes for switching slides. Unfortunately, I didn't code a beautiful animation for the transition between slides.

Sets

Now let's get started with some actual course material...

• 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 }`.
• We use both `{}` and `emptyset` to mean the empty set.

Propositions

To make statements (true or false propositions) about sets we will build up formulas starting with membership of some variables in sets, say `x in A` or `y in B`, and then use the connectives `forall`, `exists`, `^^`, `vv`, `not`, `implies`:

• 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".
• `^^` is true iff both its inputs are true. `vv` is true if any of its inputs are true. `not` is true if its input is false.
• We define `P_1 implies P_2` where `P_i` are propositions to be an abbreviation for `not P_1 vv P_2`.
• Two statements `P_1`, `P_2` are equivalent if one is true if only if the other is true.
• For example, `P_1` is equivalent to `not not P_1`, `P_1 ^^ P_2` is equivalent to `not (not P_1 vv not P_2)` (one of DeMorgan's rules), and `P_1 ^^(P_2 vv P_3)` is equivalent to `(P_1 ^^P_2) vv (P_1 ^^P_3)`.

Subsets

• 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`.
• Notice if we write out `not B subseteq A` we get `not forall x (x in B implies x in A)`.
• `exists x` is equivalent to `not forall x not` (DeMorgan). So the above is equivalent to `exists x not (x in B implies x in A)` and in turn (again, using DeMorgan's rules and what `implies` abbreviates) to `exists x (x in B ^^ x !in 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 (Sec 1)

Which of the following is true?

1. XML can only be used to specify regular expressions.
2. Computability theory is mainly concerned with which strings are compressible.
3. Regular expressions might be useful for string matching.

Quiz (Sec 3)

Which of the following is true?

1. Context-Free Grammars are useful in the design of compression algorithms.
2. XML is a tag-based language for defining Turing Machines.
3. We said in class that regular expressions are typically used to check the syntax of programs in a Java.

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.
• If `A={a,b}` and `B={1,2,3}`, then `A times B = {(a,1), (a, 2), (a,3), (b, 1), (b, 2), (b, 3)}`.
• We can iterate Cartesian product 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 ne 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.