Computing Square Roots using the Babylonian Method

Size: px

Start display at page:

Download "Computing Square Roots using the Babylonian Method"

Jade Mitchell
6 years ago
Views:

1 Computing Square Roots using the Babylonian Method René Thiemann February 16, 2013 Abstract We implement the Babylonian method [1] to compute square roots of numbers. We provide precise algorithms for naturals, integers and rationals, and offer an approximation algorithm for linear ordered fields. Contents 1 Introduction 2 2 The Babylonian method 2 3 The Babylonian method using integer division 2 4 Square roots for the naturals 5 5 Square roots for the rationals 5 6 Approximating square roots 5 7 Some tests 7 theory Sqrt-Babylonian imports Rat begin This research is supported by FWF (Austrian Science Fund) project P22767-N13. 1

2 1 Introduction This theory provides executable algorithms for computing square-roots of numbers which are all based on the Babylonian method (which is also known as Heron s method or Newton s method). For integers / naturals / rationals precise algorithms are given, i.e., here sqrt x delivers a list of all integers / naturals / rationals y where y 2 = x. To this end, the Babylonian method has been adapted by using integerdivisions. In addition to the precise algorithms, we also provide one approximation algorithm for arbitrary linear ordered fields, where some number y is computed such that y 2 x < ε. The major motivation for developing the precise algorithms was given by CeTA [2], a tool for certifiying termination proofs. Here, non-linear equations of the form (a 1 x a n x n ) 2 = p had to be solved over the integers, where p is a concrete polynomial. For example, for the equation (ax + by) 2 = 4x 2 12xy + 9y 2 one easily figures out that a 2 = 4, b 2 = 9, and ab = 6, which results in a possible solution a = 4 = 2, b = 9 = 3. 2 The Babylonian method The Babylonian method for computing n iteratively computes x i+1 = n x i + x i 2 until x 2 i n. Note that if x2 0 n, then for all i we have both x2 i n and x i x i+1. 3 The Babylonian method using integer division First, the algorithm is developed for the non-negative integers. Here, the division operation x y is replaced by x div y = of-int x / of-int y. Note that replacing of-int x / of-int y by of-int x / of-int y would lead to non-termination in the following algorithm. We explicititly develop the algorithm on the integers and not on the naturals, as the calculations on the integers have been much easier. For example, y x+x = y on the integers, which would require the side-condition y x for the naturals. These conditions will make the reasoning much more tedious as we have experienced in an earlier state of this development where everything was based on naturals. For the main algorithm we use the auxiliary guard (x < 0 n < 0 ) to ensure that we do not have to worry about negative numbers for the 2

3 termination argument and during the soundness proof. Moreover, since the elements x 0, x 1, x 2,... are monotone decreasing, we abort as soon as x 2 i n. function sqrt-babylon-int-main :: int int int option where sqrt-babylon-int-main x n = (if (x < 0 n < 0 ) then None else (if x x n then (if x x = n then Some x else None) else sqrt-babylon-int-main ((n div x + x) div 2 ) n)) For the executable algorithm we omit the guard and use a let-construction partial-function (tailrec) sqrt-int-main :: int int int option where [code]: sqrt-int-main x n = (let x2 = x x in if x2 n then (if x2 = n then Some x else None) else sqrt-int-main ((n div x + x) div 2 ) n) Once we have proven soundness of sqrt-babylon-int-main and equivalence to sqrt-int-main, it is easy to assemble the following algorithm which computes all square roots for arbitrary integers. definition sqrt-int :: int int list where sqrt-int x if x < 0 then [] else case sqrt-int-main x x of Some y if y = 0 then [0 ] else [y, y] None [] For proving soundness, we first need some basic properties of integers. lemma int-lesseq-square: (z :: int) z z lemma square-int-pos-mono: assumes x: 0 (x :: int) and y: 0 y shows (x x y y) = (x y) lemma square-int-pos-inj : assumes x: 0 (x :: int) and y: 0 y and id: x x = y y shows x = y lemma mod-div-equality-int: (n :: int) div x x = n n mod x lemma iteration-mono-eq: assumes xn: x x = (n :: int) shows (n div x + x) div 2 = x The following property is the essential property for proving termination of sqrt-babylon-int-main. lemma iteration-mono-less: assumes x: x 0 and n: n 0 and xn: x x > (n :: int) shows (n div x + x) div 2 < x 3

4 lemma iteration-mono-lesseq: assumes x: x 0 and n: n 0 and xn: x x (n :: int) shows (n div x + x) div 2 x termination We next prove that sqrt-int-main is a correct implementation of sqrt-babylon-int-main. We additionally prove that the result is always positive, which poses no overhead and allows to share the inductive proof. lemma sqrt-int-main-babylon-pos: x 0 = n 0 = sqrt-int-main x n = sqrt-babylon-int-main x n (sqrt-int-main x n = Some y y 0 ) lemma sqrt-int-main: x 0 = n 0 = sqrt-int-main x n = sqrt-babylon-int-main x n lemma sqrt-int-main-pos: x 0 = n 0 = sqrt-int-main x n = Some y = y 0 Soundness of sqrt-babylon-int-main is trivial. lemma sqrt-babylon-int-main-sound: sqrt-babylon-int-main x n = Some y = y y = n For completeness, we first need the following crucial inquality, which would be trivial if one would use standard division instead of integer division. (Proving this equation has required a significant amount of time during the development, as we first made several proof attemps which have been dead ends.) lemma square-inequality: 2 x y x x div y y + y (y :: int) lemma sqrt-babylon-int-main-complete: assumes x0 : x 0 shows x x = n = y y n = y 0 = n 0 = sqrt-babylon-int-main y n = Some x Having proven soundness and completeness of sqrt-babylon-int-main, it is easy to prove soundness of sqrt-int. lemma sqrt-int[simp]: set (sqrt-int x) = {y. y y = x} 4

5 4 Square roots for the naturals The idea is to use the algorithm for the integers and then convert between naturals and integers. In the following lemma, we first observe that the first result of sqrt-int is always non-negative. lemma sqrt-int-empty-0-pos-neg: y. y > 0 (sqrt-int x = [] sqrt-int x = [0 ] sqrt-int x = [y, y]) With this knowledge, it is easy to define a square-root function on the naturals. definition sqrt-nat :: nat nat list where sqrt-nat x case (sqrt-int (int x)) of [] [] x # xs [nat x] The soundness of sqrt-nat is straight-forward. lemma sqrt-nat[simp]: set (sqrt-nat x) = { y. y y = x} (is?l =?r) 5 Square roots for the rationals For the rationals, the idea again, to apply the algorithm for the integers and then convert between integers and rationals. Here, the essential idea is to compute the square-roots of the numerator and denominator separately. definition sqrt-rat :: rat rat list where sqrt-rat x case quotient-of x of (z,n) (case sqrt-int n of [] [] sn # xs map (λ sz. of-int sz / of-int sn) (sqrt-int z)) Whereas soundness of sqrt-rat is simple, it is a bit more tedious to show that all roots are computed, which uses facts on coprime. lemma sqrt-rat[simp]: set (sqrt-rat x) = { y. y y = x} (is?l =?r) 6 Approximating square roots The difference to the previous algorithms is that now we abort, once the distance is below ɛ. Moreover, here we use standard division and not integer division. We first provide the executable version without guard (0 :: a) < x as partial function, and afterwards prove termination and soundness for a similar algorithm that is defined within the upcoming locale. partial-function (tailrec) sqrt-approx-main-impl :: a :: linordered-field a a a where 5

6 [code]: sqrt-approx-main-impl ε n x = (if x x n < ε then x else sqrt-approx-main-impl ε n ((n / x + x) / 2 )) We setup a locale where we ensure that we have standard assumptions: positive ɛ and positive n. We require sort floor-ceiling, since x is used for the termination argument. locale sqrt-approximation = fixes ε :: a :: {linordered-field,floor-ceiling} and n :: a assumes ε : ε > 0 and n: n > 0 begin function sqrt-approx-main :: a a where sqrt-approx-main x = (if x > 0 then (if x x n < ε then x else sqrt-approx-main ((n / x + x) / 2 )) else 0 ) Termination essentially is a proof of convergence. Here, one complication is the fact that the limit is not always defined. E.g., if a is rat then there is no square root of 2. Therefore, the error-rate x n 1 is not expressible. Instead we use the expression x2 n any square-root operation. termination 1 as error-rate which does not require Once termination is proven, it is easy to show equivalence of sqrt-approx-main-impl and sqrt-approx-main. lemma sqrt-approx-main-impl: x > 0 = sqrt-approx-main-impl ε n x = sqrt-approx-main x Also soundness is not complicated. lemma sqrt-approx-main-sound: assumes x: x > 0 and xx: x x > n shows sqrt-approx-main x sqrt-approx-main x > n sqrt-approx-main x sqrt-approx-main x n < ε end It remains to assemble everything into one algorithm. definition sqrt-approx :: a :: {linordered-field,floor-ceiling} a a where sqrt-approx ε x if ε > 0 then (if x = 0 then 0 else let xpos = abs x in sqrt-approx-main-impl ε xpos (xpos + 1 )) else 0 6

7 lemma sqrt-approx: assumes ε: ε > 0 shows sqrt-approx ε x sqrt-approx ε x x < ε 7 Some tests Testing executabity and show that sqrt 2 is irrational lemma ( i :: rat. i i = 2 ) Testing speed lemma ( i :: int. i i = ) The following test value let ε = 1 / :: rat; s = sqrt-approx ε 2 in (s, s s 2, s s 2 < ε) end results in ( , e-14, True). References [1] T. Heath. A History of Greek Mathematics, volume 2, pages Clarendon Press, [2] R. Thiemann and C. Sternagel. Certification of termination proofs using CeTA. In Proc. TPHOLs 09, volume 5674 of LNCS, pages ,

Computing N-th Roots using the Babylonian Method

Computing N-th Roots using the Babylonian Method René Thiemann May 27, 2015 Abstract We implement the Babylonian method [1] to compute n-th roots of numbers. We provide precise algorithms for naturals,