1 / 34

Proof Methods

Proof Methods. Introduction Logical WFFs are to Proof as Control Structures are to Application Development They are the necessary building blocks They require a higher-level strategy for deciding which to use and when In logic, the higher-level strategy is called the proof method

bertha-dunlap
Download Presentation

Proof Methods

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Proof Methods

  2. Introduction • Logical WFFs are to Proof as Control Structures are to Application Development • They are the necessary building blocks • They require a higher-level strategy for deciding which to use and when • In logic, the higher-level strategy is called the proof method • Many proof methods exist however none is guaranteed to prove a true theorem • I.E., no general proof algorithm exists • Rather we must intelligently choose our proof technique based on the particulars of the problem • Important Terms • Inductive Reasoning – a general conclusion is drawn from a set of experiences. • Deductive Reasoning – a specific conclusion is shown to follow from a set of premises Hypothesis generation Hypothesis confirmation

  3. Exhaustive Proof • A single counterexample to a conjecture is sufficient to disprove that conjecture • Example: Finding large prime numbers (for cryptography) • We observe that f(n) = n2 – n + 41 produces prime numbers for n = 1 (41), 2 (43), 3 (47), and 4 (53) • Conjecture: f(n) is prime for all positive integers n. • Counterexample: n = 41 • f(41) = 412 – 41 + 41 = 412 • Can one prove a conjecture by example? • In general, no • In rare cases, yes • Conjecture deals with finite collection • Can show conjecture true for each element in collection • Called proof by exhaustion • Example: f(n) is prime where 0  n  40

  4. Direct Proof • To prove P  Q, assume P is true and use formal logic to show that Q is also true • Example: Our previous proofs were direct proofs • Problem: Too slow and cumbersome to be practical • Can use same idea of direct proof but less formal notation (called informal direct proof) • Example: Conjecture: “If an integer is divisible by 6, then twice that integer is divisible by 4” (taken from text, p.88) • Informal Proof • Let x be divisible by 6 • Then x = 6k where k is an integer • Then 2x = 2(6k) = 12k = 4(3k) • Since 3k is an integer, 2x is divisible by 4

  5. Contraposition Proof • To prove P  Q, prove that ¬Q  ¬P • (¬Q  ¬P)  (P  Q) is a tautology • Example: n2 is odd  n is odd • Contrapositive: n is even  n2 is even • If n is even, then n = 2k for some integer k • n2 = nn = (2k)(2k) = 2(2k2) • Therefore n2 is even • Converse • The contrapositive is not the converse • Converse of Q  P is P  Q • “If and only if” conjectures require • Proof of the implication • Proof of the converse

  6. Contradiction Proof (1) • A contradiction is a wff whose truth value is always false • Example: (¬A  A) • Notice the following is a tautology • (P  ¬Q  false)  (P  Q) • Try to develop the truth table for the above formula • To prove an conjecture true, prove that the negation of the conjecture is false • In other words, to prove P  Q, assume P and ¬Q and show that this leads to a contradiction • Remember this doesn’t prove that Q is true • only that P  Q is true

  7. Contradiction Proof (2) • Example: Prove that if 3n + 2 is odd then n is odd • Let P be “3n + 2 is odd” • Let Q be “n is odd” • Assume P  ¬Q • 3n + 2 is odd n is even • If n is even, then • n = 2k for some integer k • 3n + 2 = 3(2k) + 2 = 6k + 2 = 2(3k + 1) • Therefore 3n + 2 is even • But 3n + 2 is odd (see assumption) • Therefore 3n + 2 n is even leads to (implies) false • By contradiction, 3n + 2 n is odd must be true

  8. Contradiction Proof (3) • Example: The Halting Problem (1) • “There is an algorithm that takes as input a computer program and input to that program and determines whether the program will eventually stop when run with this input.” • Recall that an algorithm must terminate, therefore you can’t just run the program on the input to see if it terminates – what if it doesn’t? • Assume there is a solution to the Halting Problem, • call it H(P, I) • H(P,I) == “halt” when P terminates on I • H(P,I) == “never” when P does not terminate on I • Isn’t a program just 0s and 1s? • Aren’t 0s and 1s just data? • So we can run H(P,P) and according to our assumption, it will return either “halt” or “never”

  9. Contradiction Proof (4) • Example: The Halting Problem (2) • Consider the following algorithm K(P) • temp = H(P,P) • if temp == “halt” then • while (true) do {} • end if • What happens if we try K(K)? • if H(K,K) is “never”, then by definition K(K) halts • a contradiction • if H(K,K) is “halt”, then by definition K(K) doesn’t halt • a contradiction • Therefore, no such H(P, I) can exist! • Often used in computer science as the base line • “If we could write program X we could write H and therefore program X is not possible.”

  10. Contradiction Proof (5) • Example: The Halting Problem (3) • Does a general virus detection program exist? • Virus?(P,I) returns true if P with input I installs a virus and false if it does not • Assume Virus?(P, I) exists • Assume P(I) does not produce a virus • Define V(P,I) to be begin P(I), virus end • Use it to define Halts(P, I): • if (Virus?(V(P,I)),I)) then // P will install virus • return true // P must halt to get to virus • else • return false // P must not have halted • end if • We already know we can’t define Halts(P,I) and therefore we can’t define Virus?(P,I).

  11. Induction Proof (1) • Highly useful proof method in computer science • used in statement counting • used as basis of recursion • Induction involves the properties of positive integers • Proof by induction involves two steps • Prove conjecture for the first case • Prove that if the conjecture is true for a given case, it is true for the next case • Leads to the following first principle of induction • P(1) is true • k P(k) true  P(k+1) true Basis step Inductive step P(n) true for all positive integers n.

  12. Induction Proof (2) • Example: Use Induction to prove that n < 2n for all positive integers n. • Basis: P(1): 1 < 2 • Induction: P(k+1): Assume that if k < 2k, we can prove (k+1) < 2(k+1) • k < 2k • k + 1 < 2k + 1 add one to each side • k + 1  2k + 2kusing 1  2k • k + 1 < 2k+1 Note: Don’t be confused – mathematical induction is a deductive technique, not a method of inductive reasoning!

  13. Induction Proof (3) • Example: Use Induction to prove that • for all positive integers n. • Basis: 1 = 1(2) / 2 • Induction: You try it! Basic Process: 1. Establish theorem 2. Show true for base case 3. Assume inductive hypothesis LHSih = RHSih 4. State “want to show” as LHSwts = RHSwts 5. Give definition of LHSwts 6. Translate to use LHSih 7. Substitute RHSih for LHSih 8. Manipulate to find RHSwts

  14. Induction Proof (4) • Practice Problems • Sec 2.2, #1 • Sec 2.2, #22 • Sec 2.2, #29 • Sec 2.2, #43 • Try: • ∑ i = [n (n+1)]/2 1 ≤ i ≤ n • (b) ∑ i3 = [n2 (n+1)2]/4 1 ≤ i ≤ n

  15. Induction Proof (5) • Sometimes it is convenient to use the second principle of induction • P(1) is true • k[ P(r) true for 1  r  k  P(k+1) is true ] • Example: Show that if n is an integer greater than 1, then n can be written as the product of primes. • Let P(n) be the statement that “n can be written as a product of primes” • Basis: P(2) = 2 • Induction: Assume P(i) is true for all integers 1 < i  k. • Case 1: k + 1 is prime, therefore can be written as product of primes • Case 2: k + 1 is not prime • k+1 = a * b where 2  a  b < k + 1 • by inductive hypothesis, both P(a) and P(b) are true • therefore P(k+1) is true

  16. Induction Proof (6) • Example: Your bank ATM delivers cash using only $20 and $50 bills. Prove that you can collect, in addition to $20, any multiple of $10 that is $40 or greater (text, p. 109). • Let P(n) be that “$n(10) can be generated using only $20 and $50 bills”. • P(4): $40 = $20 + $20 • P(5): $50 • Assume P(r) is true for any r, 4  r  k and consider P(k+1) • We can assume k+1  6 (if not, use above cases). • so (k+1)-2  4 and by inductive hypothesis $[(k+1) -2](10) can be generated using only $20 and $50 bills. • Therefore $(k+1)(10) can be generated by adding another $20 • Therefore P(k+1) is true

  17. Application: Proof of Correctness (1) • Previously we studied how to prove a program was correct that involved only sequence and selection • If {Q}P1{R1}  {R1}P2{R2}  {R2}P3{R} • Then {Q}P1;P2;P3{R} • If {Q  B}P1{R}  {Q  ¬B}P2{R} • Then {Q}if B then P1 else P2{R} • What about iteration? • Centers on concept of loop invariant • Want to reason about a relationship that is true after each iteration of the loop, including the last iteration • Leads to the following loop rule definition • If {Q  B}P{Q} • Then {Q} while B do P {Q  ¬B} • Trick is to find a useful loop invariant that allows us to say what we wish to say loop invariant

  18. Application: Proof of Correctness (2) • Notice the need for induction • Wish to prove Q(n) is true for all n  0 (Q(0) means prior to first execution of P’s body) • Example: WTS the following code results in f = n! • i = 0; • f = 1; • while ( i <= n ) { • i = i + 1; • f = f * i; • } • Let fi be value of f after ith iteration • Desired “Q” is fk = k!, “B” is (i ≤ n)

  19. Application: Proof of Correctness (3) • Must prove Q is loop invariant • Q(0): prior to loop execution f0 = 1 = 0!, i0 = 0 • Q(k+1): after (k+1)th loop execution  • By inductive hyp, Q(k) says fk = k! and ik = k • By code, • ik+1 = ik + 1 = k + 1 • fk+1 = fk * ik+1 = fk * (k+1) = k! * (k+1) = (k+1)! • Therefore “loop rule” tells us that after n iterations, f = n! • Induction is similar to recursion. What is recursion?

  20. Recursive Algorithms • Special class of algorithms called recursion • Quite important in Computer Science • Process of solving a large problem by reducing it to one or • more subproblems that are: • Identical in structure to the original problem and • Somewhat easier to solve • Technique in general: • Subdivide into subproblems • Continue to subdivide each of these subproblems into newer ones that are less complex • Eventually, subproblems become so simple that you can solve them without further subdivision.:

  21. A Simple Recursive Example • Campaign funding • Get $1000 from single donor or • Get 1000 $1 donations. There is a potentially recursive solution. • void collect1000 { • for (int i = 0; i < 1000; i++ ) { • collect $1 from person i ; • } • }

  22. A Simple Recursive Example • Decomposed until you hit $1. That is where you will have to stop. • Divide and conquer paradim. • $1000 (goal) • $100 $100 $100 $100 $100 $100 $100 $100 $100 $100 • $10 $10…..$10 ………. $10 • $1 $1 ….. $1 ...

  23. A Simple Recursive Example • Campaign funding • Get $1000 from single donor or • Get 1000 $1 donations. There is a potentially recursive solution. • Potential solution: • Each non-leaf node in the solution tree can be designed as a Java function. • Notice that each node has the same structural similarity, • i.e., collect $x • Generaliza x

  24. A Simple Recursive Example • Task of collecting $x can be broken down into 2 cases: • When $x is $1 • When $x is greater than $1 • Informally: • void collect1000 { • if (x == 1) • contribute $1 directly; • else { • find 10 people ; • Have each collect x/10 dollars; • Return money to superior; • } • }

  25. How to develop recursive functions: • Test to see if current problem represents a simple case. • If it does, function can be implemented easily. • If not, divide into similar structured subproblems, • each of which is solved by applying the same recursive strategy.

  26. Characteristics of Recursive Algorithms: • Naturally suited for the divide-and-conquer strategy. • Recursiveness  property of the solution of the problem and not an attribute of the problem. • A problem must have three distinct properties: • (a) Must be possible to decompose the original problem into simpler • and smaller instances of the same problem. • As decompositions continues, a large problem can be broken downInto less complex one. They eventually become so simple that these functions can be solved without further decomposition. • (c) Once each of these simpler subproblems has been solved, it must be possible to combine these solutions to produce a solution to the original problem

  27. General Structure of Recursive Algorithms: • void solve(ProblemClass instance) { • if (instanceis simple) • solveinstancedirectly • else { • Divideinstancesinto new subinstancesi1, i2, …in; • solve(i1); • solve(i2); • solve(i3);// and so on…..for each subproblem • Reassemble subproblem solutions to solve entire problem; • } • }

  28. Application: Recursion (1) • Notice that induction is based on finding a smaller problem of the same type (and with a known solution) in a larger problem • For example, using the fact that involves • Induction is a form of wishful thinking • In attempting to prove the inductive case we assume (or wish) that we had already proven the smaller case • We can use this same approach in writing programs • For example, suppose we have a collection of values called l. • How could we find the length of the collection? • Write a “for-loop” to count the elements (iterative) • Wish we knew the length of the collection with the first item removed then add one to that (recursive)

  29. Application: Recursion (2) • Notice that we have found a smaller problem of the same type in the larger problem! • Of course, we can’t just wish we had the length of the smaller collection – we must actually find it • How does induction handle this? • It finds the “easiest answer” and builds each successive answers from it • The “easiest answer” is the basis (or base case) • What is the easiest case when calculating the length of a collection? • Length( empty collection ) == 0 • How do you build successive answers from it? • Length( [a | L] ) = 1 + Length(L)

  30. Application: Recursion (3) • Such a definition that involves itself is called a recursive definition • Example: Webster’s Definition of “inference” • “1: the act or process of inferring” • Of course, to be useful a concept must have at least one non-recursive definition • This is called the base definition • Example: Webster’s Definition of “inference” • “2: the act of passing from one proposition, statement, or judgment considered as true to another whose truth is believed to follow from that of the former” • A recursive algorithm is therefore an algorithm that uses itself to solve a problem. • Obviously must include both the recursive case and the base case

  31. Application: Recursion (4) • Euclid’s Method for Greatest Common Divisor • a common divisor of two numbers or determining if two numbers are relatively prime. • 1. Divide the larger by the smaller and note the remainder: • 2047/391 = (391 X 5) + 92 • 2. Divide the remainder (92) into the previous divisor (391): • 391/92 = (92 X 4) + 23 • 3. Repeat steps 1 and 2 until the remainder is 1 or zero. • a Divide the remainder (23) into the previous divisor (92): • 92/23 = (23 X 4) + 0 • 4. When the remainder is zero the last divisor is the GCD! • 23 X 89 =2047 and 23 X 17 = 391. • Therefore 89/17 = 2047/391 • 5. When the remainder is 1 the two numbers have NO common divisor and are • relatively prime.

  32. Application: Recursion (4) • Example: Euclid’s Method for Greatest Common Divisor (1) • GCD(a,b) where a  b > 0 • == b if a mod b == 0 • == GCD(b, a mod b) otherwise • In Java • public class Main { • public static int GCD(int a, int b){ • if ( a % b == 0 ){ • return b; • } • else { • return GCD(b, a % b); • } • } • … • } Unstructured!

  33. Application: Recursion (5) • Example: Euclid’s Method for Greatest Common Divisor (2) • Iterative version in Java • public class Main { • public static int GCD(int a, int b){ • int rem = a % b; • while ( rem != 0 ) • a = b; • b = rem; • rem = a % b; • } • return b; • } • … • } Which one follows more naturally from the definition?

  34. Application: Recursion (6) • Recursion is a powerful algorithmic technique used extensively in computer science • Follows naturally from recursive definitions (which occur more frequently than you might think) • Lends itself naturally to recursive data structures (which occur more frequently than you might think) • Fits naturally with the “run-time stack” memory model • Doesn’t always lead to most efficient solution • Efficiency hinges on recursive algorithm generating an iterative or recursive process • recursive process: A process that generates a chain of deferred operations • iterative process: A process that does not generate a chain of deferred operations • Do all programming languages support recursion? • Do all recursive programs generate recursive processes?

More Related