Sets, Relations, Graphs

CS154

Chris Pollett

Jan 29, 2020

Outline

Sets and how to have more sets
In-Class Exercise
Relations
Graphs

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.
There is a whole area of mathematics called foundations which looks at questions like: What are the best frameworks for formally developing mathematical arguments?
Such a framework should be able to: (1) express a wide variety of mathematics and (2) not be a pain to use.
You can think of this like the situation with computer programming. A good language for a project: needs to be able to (1) express the kinds of programs we want (fast enough, clear enough, etc), and (2) not be too much of pain to code these programs.
From about the 1920s, set theory (usually, ZFC) has been the most common framework ot formalize mathematical objects. (There are others, for example, type theory.)
So that's what we'll start learning about today...

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 }`.
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).`
You'll notice we will tend to (but not always) write the sets we are given in capital letters ("free variables"), and the sets or elements which are quantified over using lower case letters ("bound variables").
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.

In-Class Exercise

Express in the language of set theory that the set `A` has exactly two elements.

Post your solution ot the Jan 29 In-class Exercise Thread.

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)`.

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.