# Termination Checking: Comparing Structural Recursion and Sized Types by Examples

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Termination Checking: Comparing Structural Recursion and Sized Types by Examples David Thibodeau Decemer 3, 2011 Abstract Termination is an important property for programs and is necessary for formal proofs to make sense. In order to make sure that a program using recursion is terminating, one can use a termination checker that will use some strategy to verify the termination of a given program. Two very common strategies are structural recursion that makes an analysis on the structure of terms and sized types that use size annotation in the types. In this paper, we compare the two approaches to identify their strengths and limitations and to see how one can proceed to prove termination using each of the strategies. This analysis is done on different examples: a series of functions on the natural numbers and a mergesort algorithm. We also discuss the use of each of the approaches in the cases of proofs. 1 Introduction In order to ensure correctness, one needs to check that termination is achieved. One major, but unfortunate, result of computability theory is that the halting problem is undecidable. To enforce it, one can restrict its semantics to a normalizing calculus so that no non-terminating function can be written. As this approach prohibits the use of recursion, this limits greatly what programs can be implemented. For most purposes, this is inadequate. Instead, we allow recursion and pass a termination checker on the program. Such termination checker will make sure that the recursive calls are made on smaller arguments with respect to a wellfounded order. There are two main approaches that are used to implement termination checkers. These two approaches are structural recursion, which is used by systems such as Twelf [PS02] and Agda [AA02]; and sized types, used in MiniAgda [Abe10] and ATS [Xi04]. Structural recursion defines an order on the structure of terms. A term M is usually said to be smaller than a term N if we obtain N by applying one or more constructors C on M. The ordering appears directly by the use of pattern matching on the argument. Termination checking on the functions can be done without having to annotate function with extra information. The 1

2 ordering is infered from the terms themselves and wellfoundedness is infered from the constructors. With sized types, as it is presented in [Abe10], types are annotated with a size argument that determines an upper bound for term. The size annotation of a term represents the maximal height of a tree with nodes as constructors of the term. The size argument is a natural number or an ordinal since the height of the tree can be transfinite. The use of subtyping allows the use of different upper bounds for a term. Then, there is quantification over size variable in the type of a function definition and size arguments are passed through recursive calls, making sure each time that they get smaller. It is also possible to define size variables satisfying constraints such as defining a variable j such that j < i for some predefined i. Then termination is ensured by well-foundedness of the natural numbers. In this paper, we will study the use of structural recursion and sized types for termination checking. We wish to make a comparison between the two approaches to see how they work, what are their strengths and what are their limitations. A priori, the biggest advantage of structural recursion is that the process is done in background: assuming that the termination checker can find a suitable ordering on terms, there should be little overhead for the user, thus simplifying the code. Programmers would then be able to use such checker without having to modify their original code. However, this approach has its limitations. The termination checker could, in principle, be not able to assert the termination of a function because it is not obvious for the checker that the recursive calls are made on arguments that are strictly smaller. We also wish to analyse when this does happen. On the other side, it seems that sized types would shine by their flexibility and power: since more information is tracked through the program, it would probably be easier for sized types to identify that a function is indeed terminating. However, we would have to pay some cost, namely, having to carry around size annotations. We wish to verify if these preconceptions hold and, if so, to what extend. To do this, we will go through some examples of functions and test how do we achieve to obtain, for each approach, an implementation that is accepted. To study structural recursion, we will use the functional programming language Agda that uses the termination checker Foetus [AA02]. To study sized types, we will use MiniAgda [Abe10]. In section 2, we will have a look at different functions on the natural numbers such as the minus function, the division function and the Euclidean algorithm. In section 3, we will go through the merge sort algorithm. In section 4, we will discuss of the use of termination checkers for proofs. 2 Functions on Natural Numbers We first need to define our natural numbers within Agda and MiniAgda respectively. The definition is inductive, using zero and a successor function. In Agda, the representation is the following. 2

3 data Nat : Set where zero : Nat succ : Nat -> Nat In MiniAgda, we define the natural numbers with size annotation sized data SNat : Size -> Set { zero : [i : Size] -> SNat (\$ i) ; succ : [i : Size] -> SNat i -> SNat (\$ i) We note that in MiniAgda, size arguments must be provided explicitely to the constructors. The reason is that MiniAgda is an experimental system whose goal is to investigate sized types which does not have reconstruction. According to [Abe10], in a mature system such as Agda, sized annotation would be reconstructed during runtime. This point is important for our analysis: size annotation will make the code more complicated and so harder to read, but size reconstruction would account for that problem. This raises several questions such as can all size annotations be reconstructed or would some size annotations still be required, and how would that affect the classe of programs that can be certified to be terminating. We first present a minus function in Agda minus : Nat -> Nat -> Nat minus zero y = zero minus x zero = x minus (succ x) (succ y) = minus x y and in MiniAgda fun minus : [i : Size] -> SNat i -> SNat # -> SNat i { minus i (zero (i > j)) y = zero j ; minus i (succ (i > j) x) (zero.#) = succ j x ; minus i (succ (i > j) x) (succ.# y) = minus j x y Both of these implementation are accepted by the termination checker. By striping off the constructor succ from each of the two arguments, we make a recursive call on an argument that is structurally smaller. It is also captured by the size argument. Since the size annotation represents the height of the derivation of our natural number, when we extract x from the equation succ x, we reduce the height of the derivation by one. Then, we present a division function for MiniAgda. fun div : [i : Size] -> SNat i -> SNat # -> SNat i { div i (zero (i > j)) y = zero j ; div i (succ (i > j) x) y = succ j (div j (minus j x y) y) 3

4 Here, we call recursively the division function with argument x y instead of (succ x) (succ y) Since the output of the minus function is of size as big as the first argument, the output will be smaller than the input argument succ x. Thus, the recursive call is made on smaller arguments. One cannot use the same idea with structural recursion since the termination checker has no way to identify if the result of minus x y is indeed smaller than succ x. In order to write a division function that is accepted by the termination checker, one needs to do more. The strategy that we present here is described in [BD09]. We will add a third argument to the division function. This argument must be a proof term of a domain predicate that expresses that for a given pair of natural numbers the division terminates. We define this predicate in the following way. data DivDom : Nat -> Nat -> Set where div-dom-lt : (m n : Nat) -> n > m -> DivDom m n div-dom-geq : (m n : Nat) -> n m -> DivDom (m - n) n -> DivDom m n The division function becomes div : (m n : Nat) -> DivDom m n -> Nat div.m.n (div-dom-lt m n p) = zero div.m.n (div-dom-geq m n p q) = (succ zero) + (div (m - n) n q) and is accepted by the termination checker since the proof term gets structurally smaller at each recursive call. While this provides a way to prove termination with structural recursion, in its current form it requires us to provide a proof term each time we want to use the function. This is unpractical. To not have to do that, we need to prove that for all m and all n > 0, there is a DivDom m n. Then, instead of giving a proof term, we invoke this theorem. Proving that DivDom holds for all natural numbers is not trivial. In addition, we have to consider how this approach scales with the complexity of the problem. For this example, the predicate was quite simple, it is believable that as the algorithms grow in complexity, the predicate will also grow in complexity since it must account for all the cases. In comparison, sized types did not need to provide such predicate and prove that they hold for all input and so appears to be more practical. We wish to see if these observations hold for a more complicated example. We now have a look to the Euclidean algorithm. 2.1 Greatest Common Divisor The Euclidean algorithm is the standard algorithm to find the greatest common divisor of two numbers. To get gcd(a, b), we first assume that a b. If it is not the case, we can always swap a and b. We compute the remainder of the division of a by b and write a = x 0 b + r 0, where x 0 is the quotient and r 0 is the remainder. Then, we compute gcd(b, r 0 ), that is, we write b = x 1 r 0 + r 1. We 4

5 continue this process until we get r n 1 = x n+1 r n + r n+1 and r n = x n+2 r n+1 so that r n+1 divides exactly r n. Then, since r n+1 divides both r n+1 and r n, it must also divide r n 1. And it also divide r i for all 0 i n + 1 so that it must also divide b and a. By construction, it is the greatest common divisor. To implement it in Agda, one might want to proceed in the following fashion. gcd : Nat -> Nat -> Nat gcd zero y = y gcd x zero = x gcd x y = if (y x) then (gcd (x - y) y) else (gcd y x) The two first cases handle special cases. The first one will actually be used at the last recursive call. Let us analyse what this code does. Supposing that x and y are not zero, we verify if y is smaller than x. It is the case, we call gcd again with argument x y and y. Instead of using a division with remainder, we substract successively y from x until we obtain an x strictly smaller than y. When x is strictly smaller than y, it corresponds to the remainder of the division of x by y. At this point, we compute the greatest common divisor of y and x. If we get to the point that x = y, x y = 0 is sent as first argument of the function, the function will return y. This function is terminating. If we want to prove that informally, we observe that if y x and y > 0, the first argument will pass from x to x y and so will get smaller and the second argument, y, will stay constant. But if y > x, then the second argument passes from y to x and so gets smaller by assumption and the first argument grows because it passes from x to y. Therefore, either the second argument decreases or it stays constant while the first argument decreases. Thus, the function is recursively called on smaller arguments with respect to a lexicographic order bases on the second argument. However, while we have that the arguments get smaller, they do not get structurally smaller as x y and y are not structurally smaller than x. Thus, Agda s termination checker cannot assert that the function is terminating. To obtain termination, we can use a domain predicate for the algorithm as we did for the division function. However, there exists another similar method that one can use to obtain termination with structural recursion. It consists of writing an accessibility predicate on a binary relation and defining a set of elements that have no infinite descending sequences with respect to this relation. We say that these elements are accessible. One can find a more detailed treatment of the accessibility predicate in [Nor88]. In Agda, we can define the accessibility predicate as follow. data acc {A (gt : A -> A -> Set) (n : A) : Set where nacc : ( {m -> gt n m -> acc gt m) -> acc gt n To prove the termination of our algorithm, we append a proof term that the input is accessible. In spirit, this method is very similar to the domain predicate 5

6 method: we create a proof term and this proof term will get structurally smaller at each recursive call. In our case, the binary relation is the relation > (greater than) for natural numbers. We note again that in order to not have to construct each time a proof that each of the input are accessible, we must prove that for all natural number n, there is a term acc > n. This proof can easily be done by strong induction. Then, we can use it to obtain the following code. gcd : (n : Nat) -> acc _>_ n -> (m : Nat) -> acc _>_ m -> Nat gcd x p y p2 with islessthan? y x gcd x (nacc y0) zero p2 less y = x gcd x (nacc y0) (succ y) p2 less y = gcd (x - (succ y)) (y0 (lem4 y ) ) (succ y) p2 gcd zero p y (nacc y1) greater y = y gcd (succ x) (nacc p) y (nacc y1) greater y0 = gcd y (nacc y1) (succ x) (y1 y0) This code is accepted by the termination checker. It has a lot of overhead; we pass two additional proofs of accessibility of n and m. Termination is ensured using these arguments. We also need to prove several lemmas including that if x > y then x > (x succ y), which make the algorithm more difficult to implement. This approach has the advantage that we can reuse the accessibility predicate for other functions with natural numbers such that the division function. However, it requires to prove that the argument that you use is indeed smaller than the one before. Let us have a look to the Euclidean algorithm in MiniAgda. We can write the following algorithm. fun gcd : [i : Size] -> [j : Size] -> SNat i -> SNat j -> SNat (max i j) { gcd i j (zero (i > k)) y = y ; gcd i j (succ (i > k) x) (zero (j > l)) = succ k x ; gcd i j (succ (i > k) x) (succ (j > l) y) = branch (max i j) (issmaller (max i j) x y) (gcd i l (succ k x) (minus l y x)) (gcd k j (minus k x y) (succ l y)) This algorithm is very similar to what we have presented at first. There is one distinction. We made the two branches somewhat symmetric and used the minus function on the two arguments with their successor constructed striped. Since at each recursive calls, one of the two arguments gets smaller. It is important to note that we could not have swapped the two arguments as we cannot verify that the size of one is indeed smaller than the other. To our knowledge, there is no way to obtain a proof that i < j given that x < y for x and y, natural numbers of size i and j respectively. The reason for this is that in MiniAgda, sizes live on another level. While this did not appear to cause problem here, one might find this limitating. However, this is specific 6

7 of MiniAgda: ATS [Xi04] asks that one provides a metric to every function to indicate what is the argument that gets smaller. In the case of natural numbers, one would use the system defined natural numbers and would provide as a metric one or both of the arguments. Then, by doing the computation that x < y, we obtain that the size is indeed smaller since there is no distinction between the two. Also, one would be able to know that x y < x for x, y > 0 since such constraint will be solved using the system s constraint solver. More details of this approach can be found in [Xi01]. With these examples in mind, it appears that sized types capture more naturally the termination of algorithms dealing with natural numbers. In the next section, we study how termination checking scales for lists and for the merge sort algorithm. 3 Merge Sort Let us now look at the merge sort algorithm on lists of natural numbers. Merge sort works in two parts, it first splits recursively the list in two lists of about equal length, then merges the two lists into one ordered list. Our lists are defined in Agda in the following way: data List : Set where [] : List _::_ : Nat -> List -> List While we define them in the following way for MiniAgda sized data List (Nat : Set) : Size -> Set { nil : [i : Size] -> List Nat \$i ; cons : [i : Size] -> Nat -> List Nat i -> List Nat \$i We implement the mergesort algorithm in Agda as presented in figure 1. Let us look at what this code does. The merge function calls itself recursively, but at each call, one of the argument gets smaller since we remove a cons operator. it is accepted by the termination checker. For the mergesort function, we use a split function to split the list in two parts of about the same size. Then, we call mergesort on each of these two lists. The function terminates since it is applied to arguments that are by construction smaller than the original ones. However, this assumes that the split function outputs a pair of lists of size smaller than the original one. Since the original list has at least 2 elements, we know it is the case. However, the termination checker has no information about the length of the output split and so cannot assert termination. To convince the termination checker, one would have to provide a proof that split actually reduces the size of the list. We now observe how one would implement the algorithm in MiniAgda. The implementation appears in figure 2. If we exclude size annotations and specifics constructs such as the case pattern, we observe that the implementation is very 7

8 merge : List -> List -> List merge [] ys = ys merge xs [] = xs merge (x :: xs) (y :: ys) = if x y then (x :: (merge xs (y :: ys)) else (y :: (merge (x :: xs) ys)) mergesort : List -> List mergesort [] = [] mergesort (x :: []) = x :: [] mergesort (x :: (y :: xs)) with split (x :: (y :: xs)) mergesort (x :: (y :: xs)) pair a b = merge (mergesort a) (mergesort b) Figure 1: Merge sort algorithm implemented in Agda fun merge : [i : Size] -> List Nat i -> List Nat i -> List Nat # { merge i (nil.nat (i > k)) b = b ; merge i a (nil.nat (i > k)) = a ; merge i (cons.nat (i > k) a as) (cons.nat (i > l) b bs) = case (issmaller a b) { true -> cons Nat # a (merge i as (cons Nat l b bs)) ; fale -> cons Nat # b (merge i (cons Nat k a as) bs) fun mergesort : [i : Size] -> List Nat i -> List Nat # { mergesort i (nil.nat (i > j)) = nil Nat j ; mergesort i (cons.nat (i > j) x (nil.nat (j > k))) = (cons Nat j x (nil Nat k)) ; mergesort i (cons.nat (i > j) x (cons.nat (j > k) y zs)) = case split k zs { (pair.(list Nat k).(list Nat k) xs ys) -> merge # (mergesort j (cons Nat k x xs)) (mergesort j (cons Nat k y ys)) Figure 2: Merge sort algorithm implemented in MiniAgda 8

9 similar to the one that we presented above for Agda. This code is accepted by MiniAgda s termination checker. The reason for that lies in the type of the split function which is fun split : [i : Size] -> List Nat i -> Pair (List Nat i) (List Nat i) It asserts that the size of each of the lists in the output is at most the size of the input list. Then, when we case analyse on the list zs, which has size k, we obtain two lists that xs and ys that have size at most k. We then call recursively mergesort on the list cons x xs and cons y ys which have both size j and then merge the two lists. Since our original list had size i and i > j, our recursive calls are decreasing. Thus, the termination checker accepts the program. 4 Proofs We now want to talk about using termination checking for proofs instead of programs. For this, we will use a proof that small-step semantics for numbers is deterministic. The implementation of the proof in Agda was written by Prof. Brigitte Pientka. We first define our semantics. data Tm : Set where z : Tm succ : Tm -> Tm pred : Tm -> Tm Since the definition is similar for MiniAgda, we omit it. We note that since we will not be using functions on these terms directly, we do not need to annotate them with sizes. Then, we define our reductions: data Step : Tm -> Tm -> Set where s_succ : {n : Tm -> {m : Tm -> Step n m -> Step (succ n) (succ m) s_pred_zero : Step (pred z) z s_pred_succ : {m : Tm -> Num_Value m -> Step (pred (succ m)) m s_pred : {n : Tm -> {m : Tm -> Step n m -> Step (pred n) (pred m) In MiniAgda, we annotate them with sizes: sized data Step : (i : Size) -> (n, m : Tm) -> Set { s_succ : [i : Size] -> [n, m : Tm] -> Step i n m -> Step \$i (succ n) (succ m) ; s_pred_zero : [i : Size] -> Step \$i (pred z) z ; s_pred_succ : [i : Size] -> [n : Tm] -> Step \$i (pred (succ n)) n ; s_pred : [i : Size] -> [n, m : Tm] -> Step i n m -> 9

10 Step \$i (pred n) (pred m) We note that in the MiniAgda implementation, the rule s pred succ does not take a term of type Num Value n. The reason for it is that in the Agda proof, we let Agda reconstruct that term. Since MiniAgda does not do any reconstruction, we could not write this rule in the proof as we did not find a way to write it explicitely. Since this is a limitation of MiniAgda that is not related to the termination checker, we chose to modify slightly the semantics to be able to write a proof. Now, let us have a look to the proof per se. We first start with the Agda implementation. det : {m : Tm -> {n1 : Tm -> {n2 : Tm -> Step m n1 -> Step m n2 -> Eq n1 n2 det (s_succ t) (s_succ t ) with det t t... ref = ref det (s_pred_zero) (s_pred_zero) = ref det (s_pred_succ _) (s_pred_succ _) = ref det (s_pred t) (s_pred t ) with det t t... ref = ref -- Impossible cases for pred det (s_pred t) (s_pred_succ nv) with values_dont_step t (v_s nv)... () det (s_pred_succ nv)(s_pred t) with values_dont_step t (v_s nv)... () det (s_pred ()) (s_pred_zero) det (s_pred_zero) (s_pred ()) This proof is accepted by the termination checker because at each recursive call, the term is struturally smaller. This kind of proof is done inductively. When these proofs are encoded in a program, a recursive call corresponds to the use of the induction hypothesis. Our terms being defined inductively with constructors, the induction hypothesis is on terms that are structurally smaller by construction. In this setting, structural recursion appears quite naturally. Let us look at the MiniAgda implementation fun det : [i : Size] -> [n, m1, m2 : Tm] -> Step i n m1 -> Step i n m2 -> Eq m1 m2 { det i.(succ n).(succ m1).(succ m2) (s_succ (i > k).n m1 t) (s_succ (i > l) n m2 t ) = cong_succ m1 m2 (det (max k l) n m1 m2 t t ) ; det i.(pred z).z.z (s_pred_zero (i > k)) (s_pred_zero (i > l)) = ref z ; det i.(pred (succ n)).n.n (s_pred_succ (i > k) n) (s_pred_succ (i > l).n) = ref n ; det i.(pred n).(pred m1).(pred m2) 10

11 (s_pred (i > k).n m1 t) (s_pred (i > l) n m2 t ) = cong_pred m1 m2 (det (max k l) n m1 m2 t t ) We left out the impossible cases since, as MiniAgda does not check for totality, there is no construct to indicate the empty pattern. We note that instead of using a case on det (max k l) n m1 m2 t t then using reflexivity, we call a function cong succ (or cong pred). This function is defined in the following way fun cong_succ : [n, m : Tm] -> Eq n m -> Eq (succ n) (succ m) { cong_succ.n.n (ref n) = ref (succ n) and is used since pattern matching in MiniAgda, unlike Agda s pattern matching, it does not unify m1 and m2 to allow the use of reflexivity. If we omit these specific distinctions between the two languages that are not related to their termination checkers, the implementation of the proof in MiniAgda has the same structure as the implementation in Agda. The only distinction is the size annotations. While they do make the code more difficult to understand, as we said before, we can assume that these would be hidden in a mature system. 5 Conclusion and Future Work We presented four examples of programs implemented in Agda and MiniAgda and studied how the termination checker of each of the systems react when trying to assert their termination. These programs were a minus function, a division function, a greatest common divisor algorithm and a merge sort algorithm. We also implemented a proof that small-step semantics for numbers is deterministic and discussed how termination checkers work when dealing with proofs. While we were able to make MiniAgda s termination checker accept all our programs without too much effort, things were different for Agda s termination checker. Since x y is not structurally smaller than x, both the division and the greatest common divisor functions were not accepted by it. The merge sort algorithm was also problematic for structural recursion since a split function does not produce lists that are structurally smaller. However, it was still possible to create implementations that were accepted. It required to create a predicate that stating the wellfoundedness of the ordering relation for the inputs or stating the termination of the algorithm on the input. Then we had to provide to the function an appropriate proof term for this predicate. To remove the necessity of constructing each time a proof term for the input, one would typically want to prove that the predicate hold for the entire domain of the function. This approach can be quite tedious and cause a lot of overhead in the implementation. When we studied the used of termination checkers on proofs, the situation appeared to be different. In this setting, the use of structural recursion was quite natural since recursive calls correspond to uses of the induction hypothesis. Thus, one needs the induction hypothesis to apply on terms that are structurally 11

12 smaller than what you are trying to prove. Hence, the use of structural recursion matches directly what you would expect in verifying a proof. Using sized types did not cause problem either. They are also able to represent proofs without much effort since the sizes represent the height of the derivations. Thus, if the size decreases, the argument is smaller and the induction hypothesis holds. However, for proofs, it seemed that the size annotations were unnecessary and were just making the code harder to read. We noted that, while in MiniAgda the size annotations are explicit, one would expect that in a mature system, these would be hidden and reconstructed automatically. One can therefore think that the implementation of a proof would be identical for each of the two approaches. While we have not investigated reconstruction, we believe that there would be a trade of between the power a termination checker that uses sized types and how much of the size annotations can be reconstructed. However, we believe that a completely automatic sized assignment would still allow the termination checker to accept programs that are accepted by a structural recursion analysis. The reason for that belief is that termination via structural recursion is done by an untyped analysis on the terms, this analysis can be done during reconstruction to infer the appropriate sizes for the terms. We therefore conclude that in addition of being more powerful than structural recursion, sized types are more flexible. We think that sized types should be prefered over structural recursion for termination checking. We would, however, investigate these two approaches in the case of coinduction. Since coinductive structures are infinite, it might be difficult to use sized types to represent coinductive structures. We would like to see if this would cause problems that do not occur with structural recursion and, if so, if these problems can be solved. This was not done here because this would require to investigate more on coinduction. If the investigation of the use of sized types for coinduction give positive results, we would like to have a look to reconstruction. We would like to see how it would be done and if there is indeed a trade-off between the power of termination checker and how much of size annotations must be provided. 6 Acknowledgements We would like to thank Andrew Cave for helping with the Agda code and Prof. Andreas Abel for answering my questions about MiniAgda. Presenting terminating algorithms for both Agda and MiniAgda would not have been possible without them. References [AA02] Andreas Abel and Thorsten Altenkirch. A predicative analysis of structural recursion. J. Funct. Program., 12:1 41, January

13 [Abe10] Andreas Abel. MiniAgda: Integrating sized and dependent types. In Workshop on Partiality And Recursion in Interactive Theorem Provers (PAR), July [BD09] Ana Bove and Peter Dybjer. Dependent Types at Work, pages Springer-Verlag, Berlin, Heidelberg, [Nor88] B. Nordström. Terminating general recursion. BIT, 28: , July [PS02] [Xi01] Frank Pfenning and Carsten Schürmann. Twelf User s Guide, 1.4 edition, December Available as Technical Report CMU-CS Hongwei Xi. Dependent types for program termination verification. In Proceedings of the 16th Annual IEEE Symposium on Logic in Computer Science, pages 231, Washington, DC, USA, IEEE Computer Society. [Xi04] Hongwei Xi. Applied type system (extended abstract. In In postworkshop Proceedings of TYPES 2003, pages ,

### Theorem (The division theorem) Suppose that a and b are integers with b > 0. There exist unique integers q and r so that. a = bq + r and 0 r < b.

Theorem (The division theorem) Suppose that a and b are integers with b > 0. There exist unique integers q and r so that a = bq + r and 0 r < b. We re dividing a by b: q is the quotient and r is the remainder,

### 2 The Euclidean algorithm

2 The Euclidean algorithm Do you understand the number 5? 6? 7? At some point our level of comfort with individual numbers goes down as the numbers get large For some it may be at 43, for others, 4 In

### 8 Divisibility and prime numbers

8 Divisibility and prime numbers 8.1 Divisibility In this short section we extend the concept of a multiple from the natural numbers to the integers. We also summarize several other terms that express

### ON THE FIBONACCI NUMBERS

ON THE FIBONACCI NUMBERS Prepared by Kei Nakamura The Fibonacci numbers are terms of the sequence defined in a quite simple recursive fashion. However, despite its simplicity, they have some curious properties

### Reading 7 : Program Correctness

CS/Math 240: Introduction to Discrete Mathematics Fall 2015 Instructors: Beck Hasti, Gautam Prakriya Reading 7 : Program Correctness 7.1 Program Correctness Showing that a program is correct means that

### Subsets of Euclidean domains possessing a unique division algorithm

Subsets of Euclidean domains possessing a unique division algorithm Andrew D. Lewis 2009/03/16 Abstract Subsets of a Euclidean domain are characterised with the following objectives: (1) ensuring uniqueness

### Factoring & Primality

Factoring & Primality Lecturer: Dimitris Papadopoulos In this lecture we will discuss the problem of integer factorization and primality testing, two problems that have been the focus of a great amount

### Section 4.2: The Division Algorithm and Greatest Common Divisors

Section 4.2: The Division Algorithm and Greatest Common Divisors The Division Algorithm The Division Algorithm is merely long division restated as an equation. For example, the division 29 r. 20 32 948

### CS 103X: Discrete Structures Homework Assignment 3 Solutions

CS 103X: Discrete Structures Homework Assignment 3 s Exercise 1 (20 points). On well-ordering and induction: (a) Prove the induction principle from the well-ordering principle. (b) Prove the well-ordering

### OPERATIONAL TYPE THEORY by Adam Petcher Prepared under the direction of Professor Aaron Stump A thesis presented to the School of Engineering of

WASHINGTON NIVERSITY SCHOOL OF ENGINEERING AND APPLIED SCIENCE DEPARTMENT OF COMPTER SCIENCE AND ENGINEERING DECIDING JOINABILITY MODLO GROND EQATIONS IN OPERATIONAL TYPE THEORY by Adam Petcher Prepared

### 4. Number Theory (Part 2)

4. Number Theory (Part 2) Terence Sim Mathematics is the queen of the sciences and number theory is the queen of mathematics. Reading Sections 4.8, 5.2 5.4 of Epp. Carl Friedrich Gauss, 1777 1855 4.3.

### 2. Integers and Algorithms Euclidean Algorithm. Euclidean Algorithm. Suppose a and b are integers

2. INTEGERS AND ALGORITHMS 155 2. Integers and Algorithms 2.1. Euclidean Algorithm. Euclidean Algorithm. Suppose a and b are integers with a b > 0. (1) Apply the division algorithm: a = bq + r, 0 r < b.

### Prime Numbers. Chapter Primes and Composites

Chapter 2 Prime Numbers The term factoring or factorization refers to the process of expressing an integer as the product of two or more integers in a nontrivial way, e.g., 42 = 6 7. Prime numbers are

### CS103X: Discrete Structures Homework Assignment 2: Solutions

CS103X: Discrete Structures Homework Assignment 2: Solutions Due February 1, 2008 Exercise 1 (10 Points). Prove or give a counterexample for the following: Use the Fundamental Theorem of Arithmetic to

### Elementary Number Theory and Methods of Proof. CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.

Elementary Number Theory and Methods of Proof CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.edu/~cse215 1 Number theory Properties: 2 Properties of integers (whole

### Elementary Number Theory We begin with a bit of elementary number theory, which is concerned

CONSTRUCTION OF THE FINITE FIELDS Z p S. R. DOTY Elementary Number Theory We begin with a bit of elementary number theory, which is concerned solely with questions about the set of integers Z = {0, ±1,

### Regression Verification: Status Report

Regression Verification: Status Report Presentation by Dennis Felsing within the Projektgruppe Formale Methoden der Softwareentwicklung 2013-12-11 1/22 Introduction How to prevent regressions in software

### A farmer raises rabbits. Each rabbit gives birth when 2 months old and then each month there after.

Fibonacci Problem: A farmer raises rabbits. Each rabbit gives birth when 2 months old and then each month there after. Question: How many rabbits will the farmer have after n months? Try it on small numbers.

### Class notes Program Analysis course given by Prof. Mooly Sagiv Computer Science Department, Tel Aviv University second lecture 8/3/2007

Constant Propagation Class notes Program Analysis course given by Prof. Mooly Sagiv Computer Science Department, Tel Aviv University second lecture 8/3/2007 Osnat Minz and Mati Shomrat Introduction This

### Homework until Test #2

MATH31: Number Theory Homework until Test # Philipp BRAUN Section 3.1 page 43, 1. It has been conjectured that there are infinitely many primes of the form n. Exhibit five such primes. Solution. Five such

### Induction. Mathematical Induction. Induction. Induction. Induction. Induction. 29 Sept 2015

Mathematical If we have a propositional function P(n), and we want to prove that P(n) is true for any natural number n, we do the following: Show that P(0) is true. (basis step) We could also start at

### Information Theory and Coding Prof. S. N. Merchant Department of Electrical Engineering Indian Institute of Technology, Bombay

Information Theory and Coding Prof. S. N. Merchant Department of Electrical Engineering Indian Institute of Technology, Bombay Lecture - 17 Shannon-Fano-Elias Coding and Introduction to Arithmetic Coding

### Foundational Proof Certificates

An application of proof theory to computer science INRIA-Saclay & LIX, École Polytechnique CUSO Winter School, Proof and Computation 30 January 2013 Can we standardize, communicate, and trust formal proofs?

### CIS 500 Software Foundations Midterm I. Answer key. October 10, 2007

CIS 500 Software Foundations Midterm I Answer key October 10, 2007 Functional Programming 1. (2 points) Consider the following Fixpoint definition in Coq. Fixpoint zip (X Y : Set) (lx : list X) (ly : list

### Discrete Mathematics, Chapter 5: Induction and Recursion

Discrete Mathematics, Chapter 5: Induction and Recursion Richard Mayr University of Edinburgh, UK Richard Mayr (University of Edinburgh, UK) Discrete Mathematics. Chapter 5 1 / 20 Outline 1 Well-founded

### 8 Primes and Modular Arithmetic

8 Primes and Modular Arithmetic 8.1 Primes and Factors Over two millennia ago already, people all over the world were considering the properties of numbers. One of the simplest concepts is prime numbers.

### Solutions to Homework Set 3 (Solutions to Homework Problems from Chapter 2)

Solutions to Homework Set 3 (Solutions to Homework Problems from Chapter 2) Problems from 21 211 Prove that a b (mod n) if and only if a and b leave the same remainder when divided by n Proof Suppose a

### Induction and Recursion

Induction and Recursion Jan van Eijck June 3, 2003 Abstract A very important proof method that is not covered by the recipes from Chapter 3 is the method of proof by Mathematical Induction. Roughly speaking,

### Factoring Algorithms

Factoring Algorithms The p 1 Method and Quadratic Sieve November 17, 2008 () Factoring Algorithms November 17, 2008 1 / 12 Fermat s factoring method Fermat made the observation that if n has two factors

### A single minimal complement for the c.e. degrees

A single minimal complement for the c.e. degrees Andrew Lewis Leeds University, April 2002 Abstract We show that there exists a single minimal (Turing) degree b < 0 s.t. for all c.e. degrees 0 < a < 0,

### Divide-and-Conquer Algorithms Part One

Divide-and-Conquer Algorithms Part One Announcements Problem Set One completely due right now. Solutions distributed at the end of lecture. Programming section today in Gates B08 from from 3:45PM 5:00PM.

### 11 Ideals. 11.1 Revisiting Z

11 Ideals The presentation here is somewhat different than the text. In particular, the sections do not match up. We have seen issues with the failure of unique factorization already, e.g., Z[ 5] = O Q(

### Basic building blocks for a triple-double intermediate format

Basic building blocks for a triple-double intermediate format corrected version) Christoph Quirin Lauter February 26, 2009 Abstract The implementation of correctly rounded elementary functions needs high

### Discrete Mathematics and Probability Theory Fall 2009 Satish Rao, David Tse Note 5

CS 70 Discrete Mathematics and Probability Theory Fall 2009 Satish Rao, David Tse Note 5 Modular Arithmetic One way to think of modular arithmetic is that it limits numbers to a predefined range {0,1,...,N

### CHAPTER 5. Number Theory. 1. Integers and Division. Discussion

CHAPTER 5 Number Theory 1. Integers and Division 1.1. Divisibility. Definition 1.1.1. Given two integers a and b we say a divides b if there is an integer c such that b = ac. If a divides b, we write a

### ECON20310 LECTURE SYNOPSIS REAL BUSINESS CYCLE

ECON20310 LECTURE SYNOPSIS REAL BUSINESS CYCLE YUAN TIAN This synopsis is designed merely for keep a record of the materials covered in lectures. Please refer to your own lecture notes for all proofs.

### 1 Die hard, once and for all

ENGG 2440A: Discrete Mathematics for Engineers Lecture 4 The Chinese University of Hong Kong, Fall 2014 6 and 7 October 2014 Number theory is the branch of mathematics that studies properties of the integers.

### Some Polynomial Theorems. John Kennedy Mathematics Department Santa Monica College 1900 Pico Blvd. Santa Monica, CA 90405 rkennedy@ix.netcom.

Some Polynomial Theorems by John Kennedy Mathematics Department Santa Monica College 1900 Pico Blvd. Santa Monica, CA 90405 rkennedy@ix.netcom.com This paper contains a collection of 31 theorems, lemmas,

### Chapter 7 Uncomputability

Chapter 7 Uncomputability 190 7.1 Introduction Undecidability of concrete problems. First undecidable problem obtained by diagonalisation. Other undecidable problems obtained by means of the reduction

### Verifying Specifications with Proof Scores in CafeOBJ

Verifying Specifications with Proof Scores in CafeOBJ FUTATSUGI, Kokichi 二 木 厚 吉 Chair of Language Design Graduate School of Information Science Japan Advanced Institute of Science and Technology (JAIST)

### 6.852: Distributed Algorithms Fall, 2009. Class 2

.8: Distributed Algorithms Fall, 009 Class Today s plan Leader election in a synchronous ring: Lower bound for comparison-based algorithms. Basic computation in general synchronous networks: Leader election

### ML for the Working Programmer

ML for the Working Programmer 2nd edition Lawrence C. Paulson University of Cambridge CAMBRIDGE UNIVERSITY PRESS CONTENTS Preface to the Second Edition Preface xiii xv 1 Standard ML 1 Functional Programming

### APPLICATIONS OF THE ORDER FUNCTION

APPLICATIONS OF THE ORDER FUNCTION LECTURE NOTES: MATH 432, CSUSM, SPRING 2009. PROF. WAYNE AITKEN In this lecture we will explore several applications of order functions including formulas for GCDs and

### COMP 250 Fall Mathematical induction Sept. 26, (n 1) + n = n + (n 1)

COMP 50 Fall 016 9 - Mathematical induction Sept 6, 016 You will see many examples in this course and upcoming courses of algorithms for solving various problems It many cases, it will be obvious that

### Program Correctness I

22c:111 Programming Language Concepts Fall 2008 Program Correctness I Copyright 2007-08, The McGraw-Hill Company and Cesare Tinelli. These notes were originally developed by Allen Tucker, Robert Noonan

### Math 2602 Finite and Linear Math Fall 14. Homework 9: Core solutions

Math 2602 Finite and Linear Math Fall 14 Homework 9: Core solutions Section 8.2 on page 264 problems 13b, 27a-27b. Section 8.3 on page 275 problems 1b, 8, 10a-10b, 14. Section 8.4 on page 279 problems

### Discrete Mathematics Lecture 3 Elementary Number Theory and Methods of Proof. Harper Langston New York University

Discrete Mathematics Lecture 3 Elementary Number Theory and Methods of Proof Harper Langston New York University Proof and Counterexample Discovery and proof Even and odd numbers number n from Z is called

### The Classes P and NP

The Classes P and NP We now shift gears slightly and restrict our attention to the examination of two families of problems which are very important to computer scientists. These families constitute the

### Notes from Week 1: Algorithms for sequential prediction

CS 683 Learning, Games, and Electronic Markets Spring 2007 Notes from Week 1: Algorithms for sequential prediction Instructor: Robert Kleinberg 22-26 Jan 2007 1 Introduction In this course we will be looking

### Algebra for Digital Communication

EPFL - Section de Mathématiques Algebra for Digital Communication Fall semester 2008 Solutions for exercise sheet 1 Exercise 1. i) We will do a proof by contradiction. Suppose 2 a 2 but 2 a. We will obtain

### CMPS 102 Solutions to Homework 1

CMPS 0 Solutions to Homework Lindsay Brown, lbrown@soe.ucsc.edu September 9, 005 Problem..- p. 3 For inputs of size n insertion sort runs in 8n steps, while merge sort runs in 64n lg n steps. For which

### Algebraic Structures II

MAS 305 Algebraic Structures II Notes 12 Autumn 2006 Factorization in integral domains Lemma If a, b, c are elements of an integral domain R and ab = ac then either a = 0 R or b = c. Proof ab = ac a(b

### Example Correctness Proofs

Example Correctness Proofs Kevin C. Zatloukal March 8, 2014 In these notes, we give three examples of proofs of correctness. These are intended to demonstrate the sort of proofs we would like to see in

### Analysis of Algorithms I: Binary Search Trees

Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary

### Fairness in Routing and Load Balancing

Fairness in Routing and Load Balancing Jon Kleinberg Yuval Rabani Éva Tardos Abstract We consider the issue of network routing subject to explicit fairness conditions. The optimization of fairness criteria

### MTH 382 Number Theory Spring 2003 Practice Problems for the Final

MTH 382 Number Theory Spring 2003 Practice Problems for the Final (1) Find the quotient and remainder in the Division Algorithm, (a) with divisor 16 and dividend 95, (b) with divisor 16 and dividend -95,

### Mathematical Induction. Lecture 10-11

Mathematical Induction Lecture 10-11 Menu Mathematical Induction Strong Induction Recursive Definitions Structural Induction Climbing an Infinite Ladder Suppose we have an infinite ladder: 1. We can reach

### Solutions to In-Class Problems Week 4, Mon.

Massachusetts Institute of Technology 6.042J/18.062J, Fall 05: Mathematics for Computer Science September 26 Prof. Albert R. Meyer and Prof. Ronitt Rubinfeld revised September 26, 2005, 1050 minutes Solutions

### 263-2200 Types and Programming Languages

263-2200 Types and Programming Languages 1 / 49 Outline Types Evaluation Rules Typing Rules Properties of the Typing Relation The Inversion Lemma Prolog Implementation Reasoning Involving Types Progress

### THE SEARCH FOR NATURAL DEFINABILITY IN THE TURING DEGREES

THE SEARCH FOR NATURAL DEFINABILITY IN THE TURING DEGREES ANDREW E.M. LEWIS 1. Introduction This will be a course on the Turing degrees. We shall assume very little background knowledge: familiarity with

### The Prime Numbers. Definition. A prime number is a positive integer with exactly two positive divisors.

The Prime Numbers Before starting our study of primes, we record the following important lemma. Recall that integers a, b are said to be relatively prime if gcd(a, b) = 1. Lemma (Euclid s Lemma). If gcd(a,

### U.C. Berkeley CS276: Cryptography Handout 0.1 Luca Trevisan January, 2009. Notes on Algebra

U.C. Berkeley CS276: Cryptography Handout 0.1 Luca Trevisan January, 2009 Notes on Algebra These notes contain as little theory as possible, and most results are stated without proof. Any introductory

### On strong fairness in UNITY

On strong fairness in UNITY H.P.Gumm, D.Zhukov Fachbereich Mathematik und Informatik Philipps Universität Marburg {gumm,shukov}@mathematik.uni-marburg.de Abstract. In [6] Tsay and Bagrodia present a correct

### Today s Topics. Primes & Greatest Common Divisors

Today s Topics Primes & Greatest Common Divisors Prime representations Important theorems about primality Greatest Common Divisors Least Common Multiples Euclid s algorithm Once and for all, what are prime

### Chapter 6. Number Theory. 6.1 The Division Algorithm

Chapter 6 Number Theory The material in this chapter offers a small glimpse of why a lot of facts that you ve probably nown and used for a long time are true. It also offers some exposure to generalization,

### Kevin James. MTHSC 412 Section 2.4 Prime Factors and Greatest Comm

MTHSC 412 Section 2.4 Prime Factors and Greatest Common Divisor Greatest Common Divisor Definition Suppose that a, b Z. Then we say that d Z is a greatest common divisor (gcd) of a and b if the following

### Logic and Language, Proposition and Types, Proofs and Computation

Logic and Language, Proposition and Types, Proofs and Computation The Particle Physics of Computer Science Andreas Abel Department of Computer Science and Engineering Chalmers and Gothenburg University

### Lecture 11 : Recursion DRAFT

CS/Math 40: Introduction to Discrete Mathematics /4/011 Lecture 11 : Recursion Instructor: Dieter van Melkebeek Scribe: Dalibor Zelený DRAFT Last time we started talking about recursion. It is convenient

### Type Classes with Functional Dependencies

Appears in Proceedings of the 9th European Symposium on Programming, ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782. Type Classes with Functional Dependencies Mark P. Jones Department

### Mathematics of Cryptography

CHAPTER 2 Mathematics of Cryptography Part I: Modular Arithmetic, Congruence, and Matrices Objectives This chapter is intended to prepare the reader for the next few chapters in cryptography. The chapter

### A Brief Overview of Agda A Functional Language with Dependent Types

A Brief Overview of Agda A Functional Language with Dependent Types Ana Bove, Peter Dybjer, and Ulf Norell e-mail: {bove,peterd,ulfn}@chalmers.se Chalmers University of Technology, Gothenburg, Sweden Abstract.

### 2015:07. Tree Approximation for hp- Adaptivity. Peter Binev

INTERDISCIPLINARY MATHEMATICS INSTITUTE 205:07 Tree Approximation for hp- Adaptivity Peter Binev IMI PREPRINT SERIES COLLEGE OF ARTS AND SCIENCES UNIVERSITY OF SOUTH CAROLINA Tree Approximation for hp-adaptivity

### Automated Theorem Proving - summary of lecture 1

Automated Theorem Proving - summary of lecture 1 1 Introduction Automated Theorem Proving (ATP) deals with the development of computer programs that show that some statement is a logical consequence of

### Definition 1 Let a and b be positive integers. A linear combination of a and b is any number n = ax + by, (1) where x and y are whole numbers.

Greatest Common Divisors and Linear Combinations Let a and b be positive integers The greatest common divisor of a and b ( gcd(a, b) ) has a close and very useful connection to things called linear combinations

### CLASS 3, GIVEN ON 9/27/2010, FOR MATH 25, FALL 2010

CLASS 3, GIVEN ON 9/27/2010, FOR MATH 25, FALL 2010 1. Greatest common divisor Suppose a, b are two integers. If another integer d satisfies d a, d b, we call d a common divisor of a, b. Notice that as

### Parametric Domain-theoretic models of Linear Abadi & Plotkin Logic

Parametric Domain-theoretic models of Linear Abadi & Plotkin Logic Lars Birkedal Rasmus Ejlers Møgelberg Rasmus Lerchedahl Petersen IT University Technical Report Series TR-00-7 ISSN 600 600 February 00

### SOLUTIONS FOR PROBLEM SET 2

SOLUTIONS FOR PROBLEM SET 2 A: There exist primes p such that p+6k is also prime for k = 1,2 and 3. One such prime is p = 11. Another such prime is p = 41. Prove that there exists exactly one prime p such

### Detecting Pattern-Match Failures in Haskell. Neil Mitchell and Colin Runciman York University www.cs.york.ac.uk/~ndm/catch

Detecting Pattern-Match Failures in Haskell Neil Mitchell and Colin Runciman York University www.cs.york.ac.uk/~ndm/catch Does this code crash? risers [] = [] risers [x] = [[x]] risers (x:y:etc) = if x

### POLYNOMIAL RINGS AND UNIQUE FACTORIZATION DOMAINS

POLYNOMIAL RINGS AND UNIQUE FACTORIZATION DOMAINS RUSS WOODROOFE 1. Unique Factorization Domains Throughout the following, we think of R as sitting inside R[x] as the constant polynomials (of degree 0).

### On every sheet please give your first name, last name, and matriculation number.

RHEINISCH- WESTFÄLISCHE TECHNISCHE HOCHSCHULE AACHEN LEHR- UND FORSCHUNGSGEBIET INFORMATIK 2 RWTH Aachen D-52056 Aachen GERMANY http://verify.rwth-aachen.de/ LuFG Informatik II Functional Programming Exam,

### PROBLEM SET # 2 SOLUTIONS

PROBLEM SET # 2 SOLUTIONS CHAPTER 2: GROUPS AND ARITHMETIC 2. Groups.. Let G be a group and e and e two identity elements. Show that e = e. (Hint: Consider e e and calculate it two ways.) Solution. Since

### The Tower of Hanoi. Recursion Solution. Recursive Function. Time Complexity. Recursive Thinking. Why Recursion? n! = n* (n-1)!

The Tower of Hanoi Recursion Solution recursion recursion recursion Recursive Thinking: ignore everything but the bottom disk. 1 2 Recursive Function Time Complexity Hanoi (n, src, dest, temp): If (n >

### Mathematical Induction

Mathematical Induction MAT30 Discrete Mathematics Fall 016 MAT30 (Discrete Math) Mathematical Induction Fall 016 1 / 19 Outline 1 Mathematical Induction Strong Mathematical Induction MAT30 (Discrete Math)

### FORMAL LANGUAGES, AUTOMATA AND COMPUTATION

FORMAL LANGUAGES, AUTOMATA AND COMPUTATION REDUCIBILITY ( LECTURE 16) SLIDES FOR 15-453 SPRING 2011 1 / 20 THE LANDSCAPE OF THE CHOMSKY HIERARCHY ( LECTURE 16) SLIDES FOR 15-453 SPRING 2011 2 / 20 REDUCIBILITY

### Homework 5 Solutions

Homework 5 Solutions 4.2: 2: a. 321 = 256 + 64 + 1 = (01000001) 2 b. 1023 = 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = (1111111111) 2. Note that this is 1 less than the next power of 2, 1024, which

### Continued Fractions and the Euclidean Algorithm

Continued Fractions and the Euclidean Algorithm Lecture notes prepared for MATH 326, Spring 997 Department of Mathematics and Statistics University at Albany William F Hammond Table of Contents Introduction

### The last three chapters introduced three major proof techniques: direct,

CHAPTER 7 Proving Non-Conditional Statements The last three chapters introduced three major proof techniques: direct, contrapositive and contradiction. These three techniques are used to prove statements

### Mathematical induction & Recursion

CS 441 Discrete Mathematics for CS Lecture 15 Mathematical induction & Recursion Milos Hauskrecht milos@cs.pitt.edu 5329 Sennott Square Proofs Basic proof methods: Direct, Indirect, Contradiction, By Cases,

### Is Sometime Ever Better Than Alway?

Is Sometime Ever Better Than Alway? DAVID GRIES Cornell University The "intermittent assertion" method for proving programs correct is explained and compared with the conventional method. Simple conventional

### Induction and Recursion

Induction and Recursion Winter 2010 Mathematical Induction Mathematical Induction Principle (of Mathematical Induction) Suppose you want to prove that a statement about an integer n is true for every positive

### Cpt S 223. School of EECS, WSU

Sorting Algorithms 1 Sorting methods Comparison based sorting On 2 ) methods E.g., Insertion, bubble Average time On log n) methods E.g., quick sort On logn) methods E.g., Merge sort, heap sort on-comparison

### Merge Sort and Recurrences. COSC 581, Algorithms January 14, 2014

Merge Sort and Recurrences COSC 581, Algorithms January 14, 2014 Reading Assignments Today s class: Chapter 2, 4.0, 4.4 Reading assignment for next class: Chapter 4.2, 4.5 3 Common Algorithmic Techniques

### CMSC 132: OBJECT-ORIENTED PROGRAMMING II

CMSC 132: OBJECT-ORIENTED PROGRAMMING II Recursive Algorithms Department of Computer Science University of Maryland, College Park Recursion Recursion is a strategy for solving problems A procedure that

### 2. Methods of Proof Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try.

2. METHODS OF PROOF 69 2. Methods of Proof 2.1. Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try. Trivial Proof: If we know q is true then

### Elementary Number Theory

Elementary Number Theory Ahto Buldas December 3, 2016 Ahto Buldas Elementary Number Theory December 3, 2016 1 / 1 Division For any m > 0, we define Z m = {0, 1,... m 1} For any n, m Z (m > 0), there are

### 12 Greatest Common Divisors. The Euclidean Algorithm

Arkansas Tech University MATH 4033: Elementary Modern Algebra Dr. Marcel B. Finan 12 Greatest Common Divisors. The Euclidean Algorithm As mentioned at the end of the previous section, we would like to

### Page 331, 38.4 Suppose a is a positive integer and p is a prime. Prove that p a if and only if the prime factorization of a contains p.

Page 331, 38.2 Assignment #11 Solutions Factor the following positive integers into primes. a. 25 = 5 2. b. 4200 = 2 3 3 5 2 7. c. 10 10 = 2 10 5 10. d. 19 = 19. e. 1 = 1. Page 331, 38.4 Suppose a is a

### CHAPTER 7 GENERAL PROOF SYSTEMS

CHAPTER 7 GENERAL PROOF SYSTEMS 1 Introduction Proof systems are built to prove statements. They can be thought as an inference machine with special statements, called provable statements, or sometimes