# Exact real arithmetic

### From HaskellWiki

EndreyMark (Talk | contribs) m (``Chaitin's construction'' misspelled) |
(→Theory: about the paper - it's very good! read it!) |
||

(11 intermediate revisions by 4 users not shown) | |||

Line 2: | Line 2: | ||

== Introduction == |
== Introduction == |
||

− | Exact real arithmetic is an interesting area: it is a deep connection between |
+ | Exact real arithmetic is an interesting area: it is based on a deep connection between |

* numeric methods |
* numeric methods |
||

− | * and deep theoretic fondations of algorithms (and mathematics). |
+ | * and deep theoretic foundations of algorithms (and mathematics). |

Its topic: computable real numbers raise a lot of interesting questions rooted in mathematical analysis, arithmetic, but also [[Computer science#Computability theory|Computability theory]] (see numbers-as-programs approaches). |
Its topic: computable real numbers raise a lot of interesting questions rooted in mathematical analysis, arithmetic, but also [[Computer science#Computability theory|Computability theory]] (see numbers-as-programs approaches). |
||

Line 14: | Line 14: | ||

Exact reals must allow us to run a huge series of computations, prescribing only the precision of the end result. Intermediate computations, and determining their necessary precision must be achieved automatically, dynamically. |
Exact reals must allow us to run a huge series of computations, prescribing only the precision of the end result. Intermediate computations, and determining their necessary precision must be achieved automatically, dynamically. |
||

− | Maybe another problem, but it was that lead me to think on exact real arithmetic: |
+ | Maybe another problem, but it was that lead me to think about exact real arithmetic: |

− | using some Mandelbrot-plotting programs, the number of iterations must be prescribed by the user at the beginning. And when we zoom too deep into these Mandelbrot worlds, it will become ragged or smooth. Maybe solving this particular problem does not need necessarily the concept of exact real arithmetic, but it was the first time I began to think on such problems. |
+ | using some Mandelbrot-plotting programs, the number of iterations must be prescribed by the user at the beginning. And when we zoom too deep into these Mandelbrot worlds, it will become ragged or smooth. Maybe solving this particular problem does not necessarily need the concept of exact real arithmetic, but it was the first time I began to think about such problems. |

See other numeric algorithms at [[Libraries and tools/Mathematics]]. |
See other numeric algorithms at [[Libraries and tools/Mathematics]]. |
||

− | === Why, are there reals at all, which are defined exactly, but are not computable? === |
+ | === Why are there reals at all which are defined exactly, but are not computable? === |

− | See Wikipedia article on [http://en.wikipedia.org/wiki/Chaitin%27s_constant Chaitin's construction], referring to e.g. |
+ | See e.g. [[Chaitin's construction]]. |

− | * [http://www.expmath.org/expmath/volumes/11/11.3/Calude361_370.pdf Computing a Glimpse of Randomness] (written by Cristian S. Calude, Michael J. Dinneen, and Chi-Kou Shu) |
||

− | * [http://www.plus.maths.org.uk/issue37/features/omega/index.html Omega and why math has no TOEs] (Gregory Chaitin). |
||

− | Some more direct relatedness to functional programming: we can base <math>\Omega</math> on [[combinatory logic]] (instead of a [[Turing machine]]), see the prefix coding system described in [http://homepages.cwi.nl/~tromp/cl/cl.html Binary Lambda Calculus and Combinatory Logic] (page 20) written by John Tromp: |
+ | == Theory == |

− | :<math>\widehat{\mathbf S} \equiv 00</math> |
||

− | :<math>\widehat{\mathbf K} \equiv 01</math> |
||

− | :<math>\widehat{\left(x y\right)} \equiv 1 \widehat x \widehat y</math> |
||

− | of course, <math>c</math>, <math>d</math> are metavariables, and also some other notations are changed slightly. |
||

− | Now, Chaitin's construction will be here |
+ | * Jean Vuillemin's [http://www.inria.fr/rrrt/rr-0760.html Exact real computer arithmetic with continued fractions] is very good article on the topic itself. It can also serve as a good introductory article, because it presents the connections to both mathematical analysis and [[Computer science#Computability theory|Computability theory]]. It discusses several methods, and it describes some of them in more details. |

− | :<math>\sum_{p\in \mathrm{Rng}_\mathrm{dc},\;\mathrm{hnf}\left(\mathrm{dc}\;p\right)} 2^{-\left|p\right|}</math> |
||

− | where |
||

− | ;<math>\mathrm{hnf}</math> |
||

− | :should denote an unary predicate “has normal form” (“terminates”) |
||

− | ;<math>\mathrm{dc}</math> |
||

− | :should mean an operator “decode” (a function from bit finite bit sequences to [[combinatory logic]] terms) |
||

− | ;<math>2\!\;^{*}</math> |
||

− | :should denote the set of all finite bit sequences |
||

− | ;<math>\mathrm{Rng}_\mathrm{dc}</math> |
||

− | :should denote the range of decoding function, e.g. the syntactically correct bit sequences (semantically, they may either terminate or diverge), |
||

− | ;“Absolut value” |
||

− | :should mean the length of a bit sequence (not [[combinatory logic]] term evaluation!) |
||

− | Here, <math>\mathrm{dc}</math> is a partial function (from finite bit sequences). If this is confusing, then we can choose a more Haskell-like approach, making <math>\mathrm{dc}</math> a total function: |
+ | * [http://www.cs.bham.ac.uk/~mhe/ Martín Escardó]'s project [http://www.dcs.ed.ac.uk/home/mhe/plume/ A Calculator for Exact Real Number Computation] -- its chosen functional language is Haskell, mainly because of its purity, lazyness, presence of lazy lists, pattern matching. Martín Escardó has many exact real arithetic materials also among his many [http://www.cs.bham.ac.uk/~mhe/papers/index.html papers]. |

− | <haskell> |
||

− | dc :: [Bit] -> Maybe CL |
||

− | </haskell> |
||

− | then, Chaitin's construction will be |
||

− | :<math>\sum_{p\in 2^*,\;\mathrm{maybe}\;\downarrow\;\mathrm{hnf}\;\left(\mathrm{dc}\;p\right)} 2^{-\left|p\right|}</math> |
||

− | where <math>\downarrow</math> should denote false truth value. |
||

− | == Theory == |
+ | * [http://users.info.unicaen.fr/~karczma/arpap/ Jerzy Karczmarczuk]'s ''(wonderful, wonderful! gem of a)'' paper with the funny title [http://users.info.unicaen.fr/~karczma/arpap/lazypi.ps.gz The Most Unreliable Technique in the World to compute pi] describes how to compute Pi as a lazy list of digits. |

− | Jean Vuillemin's [http://www.inria.fr/rrrt/rr-0760.html Exact real computer arithmetic with continued fractions] is very good article on the topic itself. It can serve also as a good introductory article, too, because it presents the connections to both mathematical analysis and [[Computer science#Computability theory|Computability theory]]. It discusses several methods, and it describes some of them in more details. |
+ | |

+ | == Implementations == |
||

− | [http://www.cs.bham.ac.uk/~mhe/ Martín Escardó]'s project [http://www.dcs.ed.ac.uk/home/mhe/plume/ A Calculator for Exact Real Number Computation] -- its chosen functional language is Haskell, mainly because of its purity, lazyness, presence of lazy lists, pattern matching. |
+ | See [[Libraries and tools/Mathematics]] |

− | Martín Escardó has many exact real arithetic materials also among his many [http://www.cs.bham.ac.uk/~mhe/papers/index.html papers]. |
||

== Portal-like homepages == |
== Portal-like homepages == |
||

− | === [http://wwwhomes.doc.ic.ac.uk/~ae/exact-computation/ Exact Computation] === |
+ | * [http://wwwhomes.doc.ic.ac.uk/~ae/exact-computation/ Exact Computation]: There are functional programming materials too, even with downloadable Haskell source. |

− | There are functional programming materials too, even with downloadable Haskell source. |
||

− | === [http://www.haskell.org/hawiki/ExactRealArithmetic ExactRealArithmetic] === |
||

− | This HaWiki article provides links to many implementations. |
||

+ | [[Category:Mathematics]] |
||

[[Category:theoretical foundations]] |
[[Category:theoretical foundations]] |

## Latest revision as of 19:45, 26 December 2012

## Contents |

## [edit] 1 Introduction

Exact real arithmetic is an interesting area: it is based on a deep connection between

- numeric methods
- and deep theoretic foundations of algorithms (and mathematics).

Its topic: computable real numbers raise a lot of interesting questions rooted in mathematical analysis, arithmetic, but also Computability theory (see numbers-as-programs approaches).

Computable reals can be achieved by many approaches -- it is not one single theory.

### [edit] 1.1 What it is *not*

Exact real arithmetic is not the same as *fixed* arbitrary precision reals (see `Precision(n)`

of Yacas).

Exact reals must allow us to run a huge series of computations, prescribing only the precision of the end result. Intermediate computations, and determining their necessary precision must be achieved automatically, dynamically.

Maybe another problem, but it was that lead me to think about exact real arithmetic: using some Mandelbrot-plotting programs, the number of iterations must be prescribed by the user at the beginning. And when we zoom too deep into these Mandelbrot worlds, it will become ragged or smooth. Maybe solving this particular problem does not necessarily need the concept of exact real arithmetic, but it was the first time I began to think about such problems.

See other numeric algorithms at Libraries and tools/Mathematics.

### [edit] 1.2 Why are there reals at all which are defined exactly, but are not computable?

See e.g. Chaitin's construction.

## [edit] 2 Theory

- Jean Vuillemin's Exact real computer arithmetic with continued fractions is very good article on the topic itself. It can also serve as a good introductory article, because it presents the connections to both mathematical analysis and Computability theory. It discusses several methods, and it describes some of them in more details.

- Martín Escardó's project A Calculator for Exact Real Number Computation -- its chosen functional language is Haskell, mainly because of its purity, lazyness, presence of lazy lists, pattern matching. Martín Escardó has many exact real arithetic materials also among his many papers.

- Jerzy Karczmarczuk's
*(wonderful, wonderful! gem of a)*paper with the funny title The Most Unreliable Technique in the World to compute pi describes how to compute Pi as a lazy list of digits.

## [edit] 3 Implementations

See Libraries and tools/Mathematics

## [edit] 4 Portal-like homepages

- Exact Computation: There are functional programming materials too, even with downloadable Haskell source.