Sets

"set", "element-of" are undefined operations (just as point/line/plane in geometry; in fact "incident on a line" is really same as "element-of"); it all comes down to being able to answer, is a particular element in the set?

Two ways of writing sets:

• enumeration: { black, silver, gray, white, maroon, red, purple, fuchsia, green, lime, olive, yellow, navy, blue, teal, aqua }
• set builder: { c | c's rgb color components are each in {x00, x80, xFF}, each non-zero component is the same, or c is xC0C0C0 }
(xC0C0C0 is silver; see standard HTML color names)

Examples;
the empty set, ∅.
Standard names: B (booleans), N, Z, Q, ℜ strings: Σ^*

Code considerations, implementing these two views. (code)

Note that integer?, boolean?, etc just define sets — in programming languages, "type"s are just certain sets. (Imagine a prog.lang where a type is the set of primes, or the set {'black,'white,'blue,'red',green,'orange}. In fact, various languages allow for some such extensions.)

Subsets: for all x, x ∈ A implies x ∈ B.
Notation reminiscent of "≤".

Equal sets (two equivalent characterizations):

1. x ∈ A iff x ∈ B.
2. (ii) A ⊆ B, and B ⊆ A.

  (define (set= A B)
     (and (subset A B) (subset B A)))

BUT… while (i) and (ii) really do seem equivalent after a moment's reflection, it used to seem clear that 90 ≠ 100. Can we prove that (i) and (ii) are equivalent?

• Suppose def'n(i) holds, then show def'n(ii) holds.
  Recall def'n(i): x ∈ A iff x ∈ B. To show def'n(ii), we need to show two things:
  • Show that A ⊆ B.
    By def'n of ⊆, this means showing x ∈ A implies x ∈ B. This is indeed subsumed by the "only if" of (i).
  • Show that B ⊆ A.
    By def'n of ⊆, this means showing x ∈ B implies x ∈ A. This is indeed subsumed by the "if" (i).
• Now, suppose def'n(ii) holds, then show def'n(i) holds.
  Recall def'n(ii): A ⊆ B, and B ⊆ A. To show def'n(i), we need to show two things:
  • Show that "x ∈ A if x ∈ B", equivalently "x ∈ B implies x ∈ A".
    We are given that B ⊆ A, which (by def'n of ⊆) means that x ∈ B implies x ∈ A — yay!
  • Show that "x ∈ A only if x ∈ B", equivalently "x ∈ A implies x ∈ B".
    We are given that A ⊆ B, which (by def'n of ⊆) means that x ∈ A implies x ∈ B — yippee!

Okay, this was written out in great detail, with constant reminders of what was being assumed and what was to be shown. But step back and observe the structure of the proof: showing two parts of "(i) equivalent to (ii)" (each of which again further required an "if" and an "only if" direction.)

Granted, this is not an earthshaking fact (unlike 90=100, which not many people realize before seeing that proof). However, there is a tangible difference between the two definitions: If we try to write code for def'n(i), it's not clear how to test over all x. But the second translates immediately into two calls to subset?.

Def'n: proper subsets: not equal.
Def'n: nontrivial subset: non-empty proper subset.

With our two implementations of sets:

• how to write set=? Done (using subset?).
• how to write empty-set? Done (using set=?).
• how to write subset? Uh-oh!
  Special cases might work ({4k+1} subset of odds), but … these Can't be answered in general! (even if i give your program the code for my set-implemented-as-function)
  (How to prove that nobody will ever come up with a clever way? Later on this semester!)

How can we restrict our functions, to stay tractable? By and large — finite sets. (Leave predicates "even?" and "prime?" not as sets which we can call union, intersect on.)
Special cases:

• sets of numbers: ordered list or resizing-vector
• finite universes, with easy number function: bit-strings
• finite sets, infinite universe: dictionary (hash tables)

Set-constructor operations

• ∪, "union": x ∈ A∪B iff (x ∈ A ∨ x ∈ B) (code)
• ∩, "intersect": x ∈ A∩B iff (x ∈ Z ∧ x ∈ B)
• complementation: This is often relative to some "universe" — e.g. the complement of the odd integers relative to the integers is the even integers, but relative to all real numbers, the complement is the number line with a few points removed.
  [See below — discussion of "SuperU", the set that contains everything.]
• set-subtraction, A-B.
(Note that union,or look similar to each other; similarly for intersect,and. Sometimes (nonstandardly) ⋅,+ — cf booleans 0/1, and "and","or". Be careful about taking this too far though; in general, it's not the case that (A-B)∪B = A !
• Cartesian product ×: For example,
  • {vw, saab, bmw, audi} × {red, orange, yellow}
  • {ian, leebron} × Σ^*
  • {vw, saab, bmw, audi} × {}
  Of particular note: A×A (written "A²"), A×A×A ("A³").
  The "×" suggests multiplication — cardinality. |A×B| = ?
  Ordered tuples are structures (well, by pos'n rather than name).
• Power set. P(A), or (more abusive/suggestive) 2^A. |2^A| = ?

Our naive set theory:

Despite implementation problems of inf. sets, mathematically easy: as long as you can tell if a given item is in the set or not (whether or not it's convenient to compute it), you completely understand the set. Knowing the set's "indicator function" is tantamount to the knowing the set. ("isomorphic")

Not in text:
Consider the set whose indicator function is the constant function true — (λ (elt) true).
What set is this? We'll call it SuperU (for "universe"?). Note that not only are 4 and my car elements of SuperU, but so is the entire set ℜ is in SuperU, as well as the three-item set { {}, ℜ, ℜ∪Z }. (That's fine to have sets that contain sets, just as lists can contain lists.)
Somewhat disturbingly though, SuperU is itself contained in SuperU! A set containing itself?! A bit dizzying, but we'll let it in the door.

Uh-oh, logician/philosopher Bertrand Russell (around 1900) sees SuperU, and senses he can do something wicked.

First, he suggests SuperB ("bertrand"), the set of all sets which which contains themselves. The indicator function is even easy to code up: (define (SuperB elt) (element-of? elt elt)) For instance, SuperU is one of the elements of SuperB. (Think of "a book which lists all the books which mention their own title".) This discomfits us, but we don't kick Bertrand out; maybe if we just ignore him he'll go away and stop giving us a headache. [Interesting: does SuperB contain itself? Either answer is consistent, but it tips us off that our set's "easy condition" doesn't seem to fully specify the set.]

Not so lucky: encouraged by this success, Bertie cranks it up a notch, and suggests the set SuperR, of all sets which don't contain themselves. Again the indicator function is easy: (define (SuperR elt) (not (element-of? elt elt))) (Think of "a book which lists all the books which don't mention their own title".) SuperR seems to include relatively normal elements and sets, but our head is pounding more than ever. It's too late, for Bertrand jumps up and cackles as he asks:

Does SuperR contain itself?

• "Suppose SuperR does contain itself. But, if (element-of? SuperR SuperR), then then by the def'n of SuperR, it wouldn't contain SuperR."
"Crikee! So i guess it must be the case that:"
• "Suppose SuperR doesn't contain itself. But, if (not (element-of? SuperR SuperR)) is true, then by the def'n of SuperR, it would contain SuperR."

Indeed, this was very disturbing news to mathematicians around 1900: the concepts of sets, which underlies all of mathematics, has a paradox! Within mathematics, there could be no worse possible catastrophe. This began a program to re-vamp set theory.

Russell's own approach: a "tiered" classifications sets :
sets of atomic elts, sets containing sets of elts, …
It can be finagled to work, but is very unsatisfying.

Used today, when a rigorous foundation needed: a formalization ``Axiomatic set theory''. But for our purposes, we'll just use ``naive set theory'' —

• we'll take certain sets for granted (integers; the set of all functions from integers to booleans).
• We'll also allow ourselves to build new sets out of old ones (through union, cartesian product, etc).
• And, when using set-builder notation, we'll always specify a universe —
  • rather than { x | some-condition-on-x.. },
  • we'll write { x in U | some-condition-on-x.. } where U is some set we already have constructed. (which is how they all did it pre-1900)

Yes, this is deeply connected to the halting problem (though discovered 30yrs apart).

Reading: §§ 1.6(sets), 1.7(set ops), 1.8(functions)