Outline

• Power and Successor Sets
• Natural Numbers
• Functions
• O-Notation
• Equivalence Relations
• Quiz
• Graphs
• Strings
• Proofs and Proof Strategies

Introduction

• Last week, we said we were going to develop algorithms for string processing using the formalism of set theory.
• This formalism will also make it easier to reason about the algorithms and data structures we develop.
• We defined a notion of set as a collection of objects where order and repetition don't matter.
• We said what it meant for one set to be a subset of another and for one set to be equal to another.
• We said that the set without elements, denoted `{}` or `emptyset`, is called the emptyset.
• We gave new ways to build sets from existing sets using set comprehension, union, intersection, difference.
• We said how to defined ordered tuples using sets, defining ordered pair `(a,b)` as the set `{a, {a,b}}`, and then used this to define the cartesian product and power of sets, `A times B`, and `A^n`.
• We said an n-ary relation `R` is a subset of `A_1 times A_2 times ... times A_n` for sets `A_i`.
• Let's continue from there...

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.
• As writing expressions like `S(S(S(... S(\emptyset)...)))` can quickly become tedious, we use the notation `S^n(x)` to denote `n` applications of the `S` operation to `x`.

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 checks 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) = {emptyset}` which we define to be 1,` S(S(emptyset))` which we define to be 2, `ldots`, `S^n(emptyset)` which we define to be `n`, `ldots`. `omega` 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.

Quiz

Which of the following is true?

1. XML is a web language that can only be used to specify regular expressions.
2. The statement `A \cup B subseteq A` is never true.
3. There exists more than one partition of the set `{1,2,3}`.

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 countable if it is either finite or countably infinite.
• We call a set uncountably infinite, if it is not finite and it is not countable infinite.

Growth Rates of Functions

In this class we will frequently examine the efficiency of algorithms. We will use the notions on this slide to do this.

Definition: Let `NN` be the nonnegative integers. Let `f` and `g` be functions from `NN` to `NN`.

• We write `f(n) = O(g(n))` if there are positive integers `c`, `m` such that `f(n) leq c cdot g(n)` for all `n geq m`. "f grows as g or slower"
• We write `f(n) = Omega (g(n))` if `g(n) = O(f(n))`.
• We write `f(n) = Theta (g(n))` if `f(n) = Omega(g(n))` and `f(n) = O(g(n))`.

For example, `n^2+1 = O(n^2)`.

To see this notice, for all `n geq 1`, `n^2+1 leq n^2+ n^2 leq 2cdot n^2`. So `m=1`, `c=2` work for the above definition.

You might want to convince yourself that: `n^3 = Omega(n^2+n+1)` and `n^3 + n^2= Theta(n^3)`.

Equivalence Relations

• One particularly useful kind of relation is an equivalence relation. Such a relation acts like `=` in situations where we might not usually have an equals around.
• Like the binary relation equals we will write equivalence relations in infix notation. i.e., we'll write `xRy` rather than `(x,y) in R` or `R(x,y)`.
• A binary relation `R` is an equivalence relation if for each `x`, `y`, `z`:
  • `R` is reflexive, that is, `xRx`.
  • `R` is symmetric, that is, `xRy` implies `yRx`.
  • `R` is transitive, that is, `xRy` and `yRz` implies `xRz`.
• The equivalence class of `x`, denoted `[x]`, is the set: `{y | xRy }`
• We often write `equiv` or `~` rather than `R` for equivalence relations.

Example Equivalence Relations

• We defined the natural numbers in terms of sets.
• Let `-` be coded as `0`, and `+` be coded as `1`.
• The integers `ZZ` are defined as `{[(sgn,n)]| sgn in {-,+} ^^ n in NN}` under the equivalence relation: `(sgn, n)~(sgn', n')` if `n=n'` and `sgn = sgn'` or if `n=n'=0`.
• To keep things simple we abbreviate `(+, n)` as `n` and `(-, n)` as `-n`. The `n=n'=0` case is so that `-0~0`.
• You might want to think how addition, subtraction, and less than can be defined within this definition of the integers.
• Once we do this, we get the usual view of the integers as `ldots -2, -1, 0, 1, 2 ldots`
• The rationals, `QQ`, are defined as the set of equivalence classes of pairs of integers `(p,q)` (which we write as `frac(p)(q)`) such that `q geq 1` and where `frac(p)(q) ~ frac(p')(q')` if and only if `p cdot q'= p' cdot q`.
• For example, `frac(1)(2) ~ frac(2)(4)` as `1cdot 4 = 2cdot 2`.
• The real numbers `RR` can be defined in terms equivalence classes of Cauchy sequences `{a_n}` of rationals. (A Cauchy sequence is a function `a:NN rightarrow QQ`, where `a(n)` is usually written `a_n`, such that for any positive rational `epsilon` we can find an `N` such that for all `n`, `m` bigger than `N`, `|a_n -a_m| lt epsilon` ). Two reals are said to be equivalent if their defining Cauchy sequence converges to the same value. So the equivalence class of the sequence `9/10, 99/100, 999/1000, ldots` and that of `1, 1, 1, 1, ldots` would be the same.
• One can show that both the integers and the rationals are countable; however, the reals are not. (We'll do this later in the semester).

Graphs

• A graph (sometimes called a directed graph) is a pair `G=(V,E)` where `V` is a set of vertices (aka points or nodes) and `E subseteq V times V` is a set of edges between points. For example, `({1,2,3,4}, {(1,2),(2,4), (1,1),(3,4)})`.
• We can draw a graph like this pictorially:
  
• An edge of the form `(v,v)` is called a loop. For example, `(1,1)` above.
• An undirected graph (or just a graph) is agraph in which we can ignore the direction on the edges. One way to do this is to require that if `(v,w)` is in `E` then `(w,v)` is also in `E`.
• For example, the undirected version of the above graph would be : `({1,2,3,4}, {(1,2),(2,1), (2,4),(4,2), (1,1),(3,4), (4,3)})`