Outline

• More on Graphs and Types of Graphs
• Strings
• In-Class Exercise
• Proofs and Proof Strategies

More on Graphs

• At the end of last day, we had defined directed and undirected graphs using sets.
• We will use graphs when drawing our various automata for string recognition. So it is useful to fix some more terminology for graphs.
• We have defined the Cartesian power of a set `A^n=A stackrel(n)(\hat(times cdots times)) A`.
• A sequence of elements from a set `A` is a tuple in `A^n` for some `n`.
• A sequence of edges of the form `( (v_1, v_2), (v_2, v_3), ...,(v_(n-1),v_n))` in a graph is called a walk. For example, `w=(` `(1,2), (2,4), (4,1), (1,2)` `)` is a walk in the graph from last day..
• The length of a walk is the number of edges in it. `mbox(length(w)) = 4`.
• A path is a walk in which no edge is repeated. For example, `p=(` `(1,2), (2,4), (4,1), (1,3)` `)` is a path but `w` is not.
• A simple path is a path that does not go out of any vertex more than once. For example, `p'=(` `(1,2), (2,4), (4,3)` `)` is a simple path, but `p` is not a simple path.
• A cycle is a path which begins and ends at the same node. A cycle is simple if it does not repeat nodes except the end point twice. For example,
  `(` `(1,2), (2,5), (5,1), (1,3), (3,4), (4,1)` `)`
  is a cycle but is not simple; whereas, `(` `(1,2), (2,4), (4,1)` `)` is a simple cycle.

Finding Simple Paths

• In this course, we will find it useful to have an algorithm which on inputs a graph `G=(V,E)` and two vertices `s`, `t`, computes a simple path from `s` to `t` -- provided, of course, that there is a simple path between these points.
• To do this we maintain a set `A` of active nodes and a set `S` of seen nodes.
  • Initialize `A={s}`, `S = emptyset`.
  • Repeat until either `t in A` or `A = emptyset`.
    • Pick an `x in A`, set `S:=S cup{x}`
    • Let `mbox(UnseenChild(x)) := {y | (x,y) in E ^^ y !in S}`
    • Set `A := (A cup mbox(UnseenChild(x))) - {x}`
  • If `A = emptyset` then output "there is no path s to t"
  • Otherwise, we can find a path in reverse order by looking in `S` for some `x` such that `(x,t) in E`, then looking in `S` for some `y` such that `(y,x) in E`, and so on until we get back to `s`. This will be a simple path.

Trees

• A tree is a graph without cycles, and that has one distinct vertex, called the root, such that there is exactly one path from the root to every other vertex.
• The root has no incoming edges.
• Any node without outgoing edges is called a leaf.
• If `(v,w)` is an edge in a tree, then `v` is called the parent of `w` and `w` is called the child of `v`.
• The level of a vertex is the number of edges in the path from the root to that vertex.
• The height of a tree is the largest level number of any vertex.
  

Definitions, Theorems, Proofs

• To give a more rigorous development of string algorithms, we are using the language of mathematics. So that everyone is on the same page, let's fix some common math terminology.
• Definitions describe the objects and notions that we use. We want our definitions to be as precise as possible. Ideally, we might want something of the form: `mbox(mydefn(x)) iff P(x)`, where `P` is a first-order formula in whatever system we are working in. For example, we defined `A subseteq B iff P(A,B)` where `P(A,B)` was the first order formula `forall x (x in A => x in B)`.
• Once we have made some definitions we make mathematical statements involving them:
  • A proof is a convincing logical argument that a statement is true.
  • A theorem is a mathematical statement which has been proved true.
  • A lemma is a simple mathematical statement which has been proved true and which will be used in the proof of a theorem.
  • A proposition is a mathematical statement with an easy proof. One can view it like a warm-up result, which does not immediately lead to the proof of a theorem.
  • A corollary is a mathematical statement which can be proved easily once some theorem is known.

Strings

• For this class, we will define an alphabet to be some nonempty finite set `Sigma`. As examples, one could have:
  `Sigma = {0, 1}` or
  `Sigma = {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}`.
• The members of this set are called the symbols of the alphabet.
• A string over an alphabet is a finite sequence of symbols from that alphabet. For example, `0100`.
• The length of a string `w`, `|w|` is the number of symbols it contains.
• The empty string is written as `epsilon`.

Strings and Languages

• The reverse of a string `w`, `w^R` ,is the string consisting of the symbols of `w` in reverse order: `001^R = 100`.
• The concatenation of two strings `x` and `y`, `xy`, is the string consisting of the symbols in `x` followed by the symbols of `y`.
• We write `x^k` to denote `x` concatenated to itself `k` times.
• A language is a set of string.

Example Languages

• Suppose `Sigma={0,1}` is our alphabet.
• Then `L= {1, 11, 101}` is an example language.
• We write `Sigma^star` for the set of all strings over `Sigma`.
• Given two languages `L`, `L'` we write `LL'` for the language consisting of the set of strings `wv` where `w` is in `L` and `v` is in `L'`.
• Recall we use `epsilon` to denote the empty string. Some books (and JFLAP by default) use `lambda` to denote the empty string.
• Given a language `L`, we define: `L^0 = {epsilon}`, `L^(n+1)={wv | w in L^n ^^ v in L}`. `L^star=cup_(n) L^n`. `L^+=L L^star`.
• Given these definitions for the `L` above, we have `epsilon` is `L^star`, but not usually in `L^+` , we have `11101` is in `L^2`, we have `1110111` is in `L^3`, `L^star`, and `L^+`, but not `L^2`.

In-Class Exercise

Using a fixed starting set of finite languages, language contenation, and the star operator of the last slide, express the language that consist of strings over the alphabet `{0,1}` which begin and end with a 1 and which have an even number of `0`'s within these end points.

Post your solutions to the Feb 5 In-Class Exercise Thread.

Boolean Logic

• Is a logic based on two values TRUE or FALSE. (sometimes we use 1 and 0).
• These are called Boolean values.
• We also have boolean operations:
  • NOT (negation) `not x` is TRUE iff `x` is FALSE
  • AND (conjunction aka `cdot mod 2`) `x ^^ y` iff both `x` and `y` are TRUE
  • OR (disjunction) `x vv y` iff at least one of `x` or `y` is TRUE
  • XOR (exclusive OR, aka parity, aka `+ mod 2`) `x oplus y` iff exactly one of `x` or `y` is TRUE.
  • Equality `x iff y` iff `x` and `y` have the same value
  • Implications `x implies y` iff `x` is less than or equal to `y`

Finding proofs

• Example: For every graph G, the sum of the degrees of all the nodes in G is an even number.
  • Might approach problem by checking cases like when graph has a small number of vertices. One might then notice each edge contributes two to the total sum and that the sum of degrees = ` 2 times` number of edges in graph.
• Types of proofs:

  By Construction

  For example, There is a graph consisting of `n` nodes with only one cycle. Proof: let `V={1, ldots ,n}`, let `E={{1,2}, {2,3}, ...{n- 1,n}} cup {{1,n}}`.

  By Contradiction (Aristotle 400ish BCE, based on Plato and others)

  The law of non-contradiction roughly says `neg (A ^^ neg A)` must hold. As an example, of using this in a proof we show `sqrt 2` cannot be expressed as `frac(m)(n)` where `m` and `n` are integers. i.e., it is irrationality. Proof Idea: If not, we can assume `sqrt 2 = frac(m)(n)` where `m` and `n` share no common factor. Squaring both sides gives: `2n^2 = m^2`, so `m` is even because the square of an odd number is odd. So `m=2 cdot k`, so `2n^2 = (2k)^2= 4k^2`. So `n^2= 2k^2` implying `n` is also even, giving a contradiction because this implies the two numbers share the common factor 2.

  By induction (Plato 370 BCE, Gersonides 1321)

  Induction is the principle that if we know a proposition `A(a)` holds for `A(0)`, and we can prove `(forall x in NN)(A(x) => A(S(x))` then we know `(forall y \in NN)A(y)`. As an example, we prove the following statementt using induction:
  
  `sum_(i = 1)^n i = frac(n(n+1))(2)`.
  Proof. When n =0, the left hand side is 0 and the right hand side is 0. So base case holds. Assume it is true of `n`, then `sum_(i = 1)^(n+1) i = n+1 + sum_(i = 1)^(n) i`. By the induction hypothesis, this last term is `frac(n(n+1))(2)`. So `sum_(i = 1)^(n+1) i = n+1 + frac(n(n+1))(2) = frac(2(n+1) + n(n+1))(2) = frac((n+1)(n+2))(2)`. So the induction step holds, thus, the statement holds for all `n`.

More Types of Proof

By Pigeonhole Principle (Leurechon 1624, Dirichlet 1834)

Pigeonhole principles are a family of related principles, the most common of which is the injective pigeonhole principle. This says that if we have a function `f:X->Y` with `|X| > |Y|` then there exists `x, x' in X` with `x != x'` such that `f(x)=f(x')`. i.e., if you have a function from pigeons to holes and you have more pigeons than holes, your function must map at lease two pigeons to the same hole. For example, a human head has less than 500,000 hairs on it, there are more than a million non-bald people in the Bay area, therefore, two non-bald people in the Bay area have the same number of hairs on their head.

Another type of pigeonhole principle is the surjective pigeonhole principle. This says that we have a function `f:X->Y` with `|X| < |Y|` then there exists `y in Y` such that for every `x in X`, `f(x) != y`. i.e., if we map fewer pigeons than holes then after mapping pigeons some hole will be empty. Later in the semester, we will see this principle is used to show there exists strings that couldn't have been output via some function on strings of shorter length. i.e., it is incompressible.