17 Teorie van Berekening

Transcription

1 17 Teorie van Berekening 17.1 Foundations of Computer Science Cengage Learning

2 Doel Nadat hierdie hoofstuk bestudeer is sal jy kan: Beskryf die Simple Language programmeertaal en definiëer basiese stellings. Skryf makros in Simple Language deur `n kombinasie van verskillende eenvoudige stellings te gebruik. Beskryf die komponente van `n Turing masjien as `n berekeningsmodel. Wys hoe eenvoudige stellings in Simple Language gesimuleer kan word deur gebruik te maak van `n Turing masjien. Verstaan die Church-Turing proefskrif en sy betekenis. Definiëer die Gödel getal en sy toepassing. Verstaan die konsep van die halt probleem en hoe dit bewys kan word dat hierdie probleem onoplosbaar is. Onderskei tussen oplosbare en onoplosbare probleme. Onderskei tussen polinomiale en nie-polinomiale oplosbare probleme. 17.2

3 17-1 SIMPLE LANGUAGE Ons kan `n rekenaartaal definiëer met slegs drie stellings: die inkrimenteer stelling, die dekrimenteer stelling en die lus stelling (Figuur 17.1) Figure 17.1 Statements in Simple Language

4 Inkrimenteer stelling Die inkrimenteer stelling tel 1 by enige veranderlike. Die formaat is gewys in Algoritme Dekrimenteer stelling Die dekrimenteer stelling trek 1 af van enige veranderlike. Die formaat is gewys in Algoritme

5 Lus stelling Die lus element herhaal `n aksie (of reeks van aksies) terwyl die waarde van die veranderlike nie 0 is nie. Die formaat is gewys in Algoritme

6 Die krag van die Simple Language Dit kan bewys word dat hierdie eenvoudige programmeertaal met slegs drie stellings is net so kragtig alhoewel nie noodwendig so effektief nie as enige gesofistikeerde taal wat ons vandag gebruik, soos C, C++, Java ens. Om dit te bewys, wys ons hoe kan ons veelvuldige stellings simuleer wat in sommige populê tale voorkom. Makros in Simple Language Ons noem elke simulasie `n makro en gebruik dit in ander simulasies sonder die behoefte om kode te herhaal. `n Makro (kort vir makro-instruksie) is `n instruksie in `n hoëvlaktaal wat ekwivalent is aan `n spesifieke versameling van een of meer gewne instruksies in in dieselfde taal. 17.6

7 Eerste makro: X 0 Algoritme 17.4 wys hoe gebruik ons die stellings in Simple Language om 0 toe te ken aan `n veranderlike X. Dit word somtyds genoem: om `n veranderlike skoon te maak (clearing). Praktiese werklike wêreld voorbeelde: terugdraai van die motor se distansie meter; terugdraai van wyser-horlosie se hande; herstel die fiets se kode-slot. Al hierdie is baie maganies, en rekenaars het hulle oorsprong van meganika. 17.7

8 Tweede makro: X n Algoritme 17.5 wys hoe om die stellings in Simple Language te gebruik om `n positiewe heelgetal n toe te ken aan `n veranderlik X. Maak eers X skoon, inkrimenteer X dan n keer. 17.8

9 Derde makro: Y X Algoritme 17.6 simuleer die makro Y X in Simple Language. Let op dat ons `n ekstra lyn kode kan gebruik om die waarde van X te herstel na sy oorsprinklike waarde. 17.9

10 Derde makro: Y X MAAR, Algoritme 17.6 vernietig die waarde van X. Om dit te vermy, kan ons die makro herskryf om die oorspronklike waarde van X te herstel, as volg: Y 0 BACKUP 0 while (X) { decr (X) incr (Y) incr (BACKUP) } while (BACKUP) { decr (BACKUP) incr (X) } 17.10

11 Vierde makro: Y Y + X Algoritme 17.7 simuleer die makro Y Y + X in Simple Language. Weereens, ons kan ekstra lyne kode gebruik om die waarde van X te herstel na sy oorspronklike waarde

12 Vierde makro: Y Y + X Soos voorheen, Algoritme 17.7 vernietig die waarde van X. Om dit te vermy, kan ons die makro herskryf om die oorspronklike waarde van X te herstel, as volg: BACKUP 0 while (X) { decr (X) incr (Y) incr (BACKUP) } while (BACKUP) { decr (BACKUP) incr (X) } 17.12

13 Vyfde makro: Y Y X Algoritme 17.8 simuleer die makro Y Y X in Simple Language. Ons kan die optelling makro gebruik, want heelgetal vermenigvuldiging kan gesimuleer word deur herhaalde optelling. Let op dat ons die waarde van Y moet behou in `n tydelike veranderlike, want tydens elke optelling moet die oorspronklike waarde van Y by Y getel word

14 Vyfde makro: Y Y X Soos voorheen, Algoritme 17.8 vernietig die waarde van X. Om dit te vermy, kan ons die makro herskryf om die oorspronklike waarde van X te herstel, as volg: TEMP Y BACKUP 0 Y 0 while (X) { decr (X) Y Y + TEMP incr (BACKUP) } while (BACKUP) { decr (BACKUP) incr (X) } 17.14

15 Sesde maklro: Y Y X Algoritme 17.9 simuleer die makro Y Y X in Simple Language. Ons kan dit doen deur die vermenigvuldiging makro te gebruik, want heelgetal magsverheffing kan gesimuleer word deur herhaaldelike vermenigvuldiging

16 Sesde maklro: Y Y X Soos voorheen, Algoritme 17.9 vernietig die waarde van X. Om dit te vermy, kan ons die makro herskryf om die oorspronklike waarde van X te herstel, as volg: TEMP Y BACKUP 0 Y 1 while (X) { decr (X) Y Y TEMP incr (BACKUP) } while (BACKUP) { decr (BACKUP) incr (X) } 17.16

17 Sewende makro: as X dan A Algoritme simuleer die sewende makro in Simple Language. Hierdie makro simuleer die besluitneming (if) stelling van moderne programmeertale. In hierdie makro het die verandelike X slegs een van die twee waardes 0 of 1. As die waarde van X nie 0 is nie, word A uitgevoer in die lus

18 Ander makros Dit is voordiehandliggend dat ons meer makros benodig om Simple Language aanpasbaar te maak met moderne tale. Om ander makros te skep is moontlik, maar nie triviaal nie. Invoer en uitvoer In Simple Language kan die stelling X gesimuleer word vir invoer deur (X n) te gebruik. Ons simuleer ook die uitvoer deur aan te neem dat die laaste veranderlike gebruik in `n program hou die waarde wat gedruk moet word. Onthou dat hierdie nie `n praktiese taal is nie, dit is bloot ontwerp om van die stellings in rekenaarwetenskap te bewys

19 17-2 DIE TURING MASJIEN Die Turing Masjien was voorgestel in 1936 deur Alan M. Turing om berekeningsprobleme op te los, en vorm die fondasie vir moderne rekenaars. In hierdie afdeling stel ons `n baie vereenvoudigde weergawe voor van die masjienomtewyshieditwerk

20 Turing masjien komponente `n Turing masjien bestaan uit drie komponente: `n band, `n beheerder en `n lees/skryf kop (Figuur 17.2) Figure 17.2 The Turing machine

21 Band Alhoewel moederne rekenaars willekeurige-toegang stoortoestelle gebruik met uitstekende kapasiteit, neem ons aan dat die Turing masjien se geheue oneindig is. Die band, op enige gegewe oomblik, hou `n reeks van karakters van die versameling karakters wat aanvaar word deur die masjien. Vir ons doel aanvaar ons dat die masjien slegs twee simbole aanvaar: `n blank (b) en syfer Figure 17.3 The tape in the Turing machine

22 Lees/skryf kop Die lees/skryf kop wys, op enige gegewe oomblik, na een simbool op die band. Ons noem hierdie simbool die huidige simbool. Die lees/skryf kop lees/skryf net een simbool op `n slag van/na die band. Nadat dit `n karakter gelees het, skuif dit na links of na regs. Lees, skryf en beweeg word alles gedoen met instruksies van die beheerder. Beheerder (controller) Die beheerder is die teoretiese eweknie van die sentrale verwerkingseenheid (CPU) in moderne rekenaars. Dit is `n eindigende-toestand outomaat, `n masjien wat `n voorafbepaalde eindige aantal toestande het en beweeg van een toestand na `n ander gebaseer op invoer

23 17.23 Figure 17.4 Transition state diagram for the Turing machine

24 17.24

25 Voorbeeld 17.1 `n Turing masjien het slegs twee toestande en die volgende vier instruksies: As die masjien begin met die konfigurasie soos in Figure 17.5, wat is die konfigurasie (toestand) van die masjien nadat een van die bogenoemde instruksies uitgevoer is? Figure 17.5 Example

26 Voorbeeld 17.1 Oplossing Die masjien is in toestand A en die huidige simbool is 1, wat beteken dat slegs die tweede instruksie, (A, 1, 1, R, B), kan uitgevoer word. Die nuwe konfigurasie (toestand) word ook gewys in Figuur Let daarop dat die toestand van die beheerder verander is na B en die lees/skryf kop het beweeg een simbool na regs

27 Simulering van Simple Language Ons kan nou programme skryf wat die stellings van Simple Language implementeer. Let op dat hierdie stellings geskryf kan word op baie verskillende maniere: ons het die eenvoudigste of mees gepaste manier vir opvoedkundige redes gekies, maar hulle is nie noodwendig die beste maniere nie

28 Inkrementeer stelling Figuur 17.6 wys die Turing masjien vir die incr(x) stelling. Die beheerder het vier toestande, S1 tot S4. Toestand S1 is die begintoestand, toestand S2 is the beweeg-regs toestand, toestand S3 is die beweeg-links toestand en toestand 4 is die halt toestand Figure 17.6 The Turing machine for the incr (X) statement

29 Voorbeeld 17.2 Dit wys hoe die Turing masjien kan inkrementeer met X wanneer X= Figure 17.7 Example 17.2

30 Dekrementeer stelling Ons implementeer die decr(x) selling deur gebruik te maak van die minimum aantal stellings. Die rede is omdat ons hierdie stelling moet gebruik in in die volgende stelling, die while lus, wat ook gebruik sal word om alle makros te implementeer Figure 17.8 The Turing machine for the decr (X) statement

31 Voorbeeld 17.3 Dit wys hoe die Turing masjien kan dekrementeer met X wanneer X= Figure 17.9 Example 17.3

32 Lus stelling Om `n lus te simuleer, neem ons aan dat X en die data wat verwerk moet word deur die liggaam van die lus is gestoor op die band geskei deur `n enkele blank simbool. Figuur wys die tabel, die program en die toestandoorgangsdiagram vir `n algemene lus stelling. Die drie toestande S1, S2 en S3 beheer die lusse deur X te bepaal en uit die lus uit te gaan indien X = 0. Vergelyk hierdie drie stellings met die drie stellings wat gebruik is in die dekrementeer stelling in Figuur

33 17.33 Figure The Turing machine for the while loop statement

34 Voorbeeld 17.4 Hier is `n baie eenvoudige voorbeeld. Gestel ons wil die vierde makro simuleer, Y Y + X (bl 444). Soos ons voorheen bespreek het, kan hierdie makro gesimuleer word deur die while stelling te gebruik in Simple Language: Om die prosedure korter te maak, neem ons aan dat X = 2 en Y = 3, so die resultaat is Y = 5. Figuur wys die toestand van die band voor en nadat die makro toegepas is

35 Voorbeeld 17.4 Figure Configuration of the tapes for Example

36 Voorbeeld Figure First iteration in Example 17.4

37 Voorbeeld Figure Second iteration in Example 17.4

38 Die Church-Turing proefskrif Ons het gewys dat `n Turing die drie basiese stellings in Simple Language kan simuleer. Dit beteken die Turing masjien kan ook al die makros wat ons gesimuleer het vir die Simple Language, simuleer. Kan die Turing dus elke probleem oplos wat deur `n rekenaar opgelos word? Die antwoord tot hierdie vraag kan gevind word in die Church Turing proefskrif. i Die Church-Turing proefskrif As `n algoritme bestaan om `n simbool manipulasie taak uit e voer, dan bestaan daar `n Turing masjien om daardie taak uit te voer

39 Die Church-Turing proefskrif Let op hierdie is `n proefskrif, nie `n stelling `n Stelling kan wiskundig bewys word `n Proefskrif kan nie wiskundig bewys word nie Maar daar is sterk argumente vir die Church-Turing proefskrif Geen algoritme kon tot dusver gevind word wat nie deur `n turing masjien gesimuleer kan word nie Dit is al bewys dat alle berekeningsmodelle wat al wiskundig bewys is, kan gesimuleer word deur `n Turing masjien 17.39

40 17-3 GÖDEL GETALLE In teoretiese rekenaarwetenskap, word `n ongetekende getal toegeken aan elke program wat in `n spesifieke taal geskryf kan word. Hierdie word gewoonlik na verwys as die Gödel getal, vernoem na die Austriaanse wiskundige Kurt Gödel. Hierdie toekenning het baie voordele. Eerste, programme kan genruik word as `n enkele data item as inivoer tot ander programme. Tweedens, programme kan na verwys word deur slegs hulle heelgetal voorstellings. Derdens, die numering kan gebruik word om te bewys dat sommige probleme nie opgelos kan word deur `n rekenaar nie

41 Verskeie metodes is ontwikkel vir die numering van programme. Ons gebruik `n baie eenvoudige transformasie om getalle toe te ken aan programme in Simple Language. Simple Language gebruyik slegs vyftien simbole (Tabel 17.2)

42 Voorstelling van `n program Deur hierdie tabel te gebruik kan ons enige program wat geskryf is in Simple Language voorstel deur `n unieke positiewe heelgetal deur die volgende stappe te volg: 1. Vervang elke simbool met die ooreenstemmende heksadesimale kode van die tabel. 2. Interpreteer die resulterende heksadesimale getal as `n ongetekende heelgetal

43 Voorbeeld 17.5 Wat is die Gödel getal vir die program incr (X)? Oplossing Vervang elke simbool met sy heksadesimale simbool So hierdie program kan voorgestel word as program nommer

44 Interpretasie van `n getal Om te wys dat die numeringsisteem uniek is, gebruik die volgende stappe om `n Gödel getal te interpreteer: 1. Skakel die program om in heksadesimaal. 2. Interpreteer elke heksadesimale getal as `n simbool deur van Tabel 17.2 gebruik te maak (ignoreer a 0). Let op dat, alhoewel elke program in Simple Language voorgestel kan word as `n getal, kan nie elke getal geinterpreteeer word as `n geldige program nie. Na omskakeling, indien die simbole nie die sintaks van die taal volg nie, is die getal nie `n geldige program nie, en is dus nie `n Gödel getal nie

45 Voorbeeld 17.6 Interpreteer 3058 as `n program. Oplossing Verander die getal na heksadesimaal en vervang elke syfer met die ooreenstemmende simbool: Dit beteken dat die ekwivalente kode in Simple Language is decr (X2). Let op dat in Simple Language, elke program invoer en uitvoer insluit. Dit beteken dat die kombinasie van `n program en sy invoer die Gödel getal definiëer

46 16-4 THE HALTING PROBLEM Almost every program written in a programming language involves some form of repetition loops or recursive functions. A repetition construct may never terminate (halt): that is, a program can run forever if it has an infinite loop. For example, the following program in Simple Language never terminates: 17.46

47 A classical programming question is: i Can we write a program that tests whether or not any program, represented by its Gödel number, will terminate? The existence of this program would save programmers a lot of time. Running a program without knowing if it halts or not is a tedious job. Unfortunately, it has now been proven that such a program cannot exist much to the disappointment of programmers! 17.47

48 The halting problem is not solvable Instead of saying that the testing program does not exist and can never exist, the computer scientist says The halting problem is not solvable. Proof Let us give an informal proof about the nonexistence of this testing program. Our method, called proof by contradiction, is often used in mathematics: we assume that the program does exist, then show that its existence creates a contradiction therefore, it cannot exist. We use three steps to show the proof in this approach

49 Step 1 In this step, we assume that a program, called Test, exists. It can accept any program such as P, represented by its Gödel number, as input, and outputs either 1 or 0. If P terminates, the output of Test is 1: if P does not terminate, the output of Test is 0 (Figure 17.14) Figure Step 1 in the proof

50 Step 2 In this step, we create another program called Strange that is made of two parts: a copy of Test at the beginning and an empty loop a loop with an empty body at the end. The loop uses X as the testing variable, which is actually the output of the Test program. This program also uses P as the input Figure Step 2 in the proof

51 Step 3 Having written the program Strange, we test it with itself (its Gödel number) as input. This is legitimate because we did not put any restrictions on P. Figure shows the situation Figure Step 3 in the proof

52 Contradiction This proves that the Test program cannot exist and that we should stop looking for it, so i The halting problem is unsolvable. The un-solvability of the halting program has proved that many other programs are also unsolvable, because if they are solvable, then the halting problem is solvable which it is not

53 17-5 THE COMPLEXITY OF PROBLEMS Now that we have shown that at least one problem is unsolvable by a computer, we ll touch on this important issue a bit more. In computer science, we can say that, in general, problems can be divided into two categories: solvable problems and unsolvable problems. The solvable problems can themselves be divided into two categories: polynomial and non-polynomial problems (Figure 17.17)

54 17.54 Figure Taxonomy of problems

55 Solvable problems There are many problems that can be solved by a computer. However, we often want to know how long it takes for the computer to solve that problem. In other words, how complex is the program? The complexity of a program can be measured in several different ways, such as its run time, the memory it needs and so on. One approach is the program s run time how long does the program take to run? 17.55

56 Complexity of solvable problems One way to measure the complexity of a solvable problem is to find the number of operations executed by the computer when it runs the program. Big-O notation With the speed of computers today, we are not as concerned with exact numbers as with general orders of magnitude. This simplification of efficiency is known as big-o notation. We present the idea of this notation without delving into its formal definition and calculation. In big-o notation, the number of operations given as a function of the number of inputs. The notation O(n) means a program does n operations for n inputs, while the notation O(n 2 ) means a program does n 2 operations for n inputs

57 Example 17.7 Imagine we have written three different programs to solve the same problem. The first one has a complexity of O(log 10 n), the second O(n),andthethirdO(n 2 ). Assuming 1 million inputs, how long does it take to execute each of these programs on a computer that executes one instruction in 1 microsecond, that is, 1 million instructions per second? Solution 17.57

58 Polynomial problems If a program has a complexity of O(logn), O(n), O(n 2 ), O(n 3 ), O(n 4 ), or O(n k ), where k is a constant, it is called polynomial. With the speed of computers today, we can get solutions to polynomial problems with a reasonable number of inputs, for example 1000 to 1 million. Non-polynomial problems If a program has a complexity that is greater than a polynomial for example, O(10 n )oro(n!) it can be solved if the number of inputs is very small, for example fewer than 100. If the number of inputs is large, one could sit in front of the computer for months to see the result of a nonpolynomial problem