\mnb150<nb wrap="0" txtwidth="80" autowidth="0" pprint="1" typeset="1" xface="Times New Roman" xsize="240" xbold="0" xitalic="0" xcolor="#0000FF" slidents="1" sizemult="71" minsize="160" ifont="0 220 255 0 49 Courier New" ofont="0 220 16711680 0 49 Courier New" tfont="0 220 0 1 0 Times New Roman"></nb>ÿ{\rtf1\ansi\deff0\deftab720{\fonttbl{\f0\fswiss MS Sans Serif;}{\f1\froman\fcharset2 Symbol;}{\f2\fswiss\fprq2 System;}{\f3\fmodern\fprq1 Courier New;}{\f4\fmodern\fprq1\fcharset1 Courier New;}{\f5\fswiss\fprq2 Arial;}{\f6\fswiss\fprq2\fcharset1 Arial;}{\f7\froman\fprq2 Times New Roman;}{\f8\froman\fcharset1 Times New Roman;}}
{\colortbl\red0\green0\blue0;\red255\green0\blue0;\red0\green128\blue0;\red0\green0\blue255;}
\deflang1031\pard\ri4\plain\f3\fs20\cf0 ________________________________________________________________________________
\par 
\par Inhalt....: Konstruktion von Primzahlen
\par Kategorie.: Unterrichtsmaterial
\par Mathematik: Zahlentheorie
\par MuPAD.....: 3.1.0
\par Datum.....: 2006-10-24
\par Autoren...: August Barkhausen <abarkhausen@gmx.de>
\par Funktionen: for, if, print, Typeset, min, numlib::primedivisors, testeq, matrix
\par Funktionen: map, testeq
\par ________________________________________________________________________________
\par 
\par \plain\f6\fs36\cf0 Konstruktion von Primzahlen nach einem
\par Beweis des Satzes von Euklid \'fcber die 
\par Anzahl von Primzahlen
\par \plain\f5\fs24\cf2\b 
\par Im folgenden wird ein Algorithmus zur Berechnung von Primzahlen durchgef\'fchrt, der 
\par auf die in dem Buch "Elementare Zahlentheorie" von Remmert und Ulrich, 2. Auflage 
\par Birkh\'e4user1995 dargestellte Version des Satzes von Euklid zur\'fcckgeht. Der Algorith-
\par mus wird zun\'e4chst heuristisch und dann mit einer Programmierl\'f6sung durchgef\'fchrt. 
\par In diesem Zusammenhang wird dar\'fcber hinaus nachgewiesen, dass die gefundenen 
\par Zahlen tats\'e4chlich Primzahlen sind. 
\par Im Rahmen der heuristischen Vorarbeit wird dar\'fcber hinaus mit gezeigt, dass die 
\par gefundenen Primzahlen paarweise voneinander verschieden sind. 
\par 
\par Am Ende des Notebooks finden sich Anregungen f\'fcr Folgeaufgaben. 
\par 
\par Als mathematischer Hintergrund werden ausreichende Kenntnisse \'fcber Primzahlen 
\par und Primfaktorzerlegungen sowie Grundkenntnisse der Logik vorausgesetzt. Aus 
\par dem Bereich der EDV werden Programmierkenntnisse ben\'f6tigt. Schlie\'dflich werden 
\par zur Simulation von Tabellen Matrizen benutzt. Wenn keine mathematischen Kennt-
\par nisse \'fcber Matrizen bzw. Vektoren vorhanden sind, sollte zumindest erkl\'e4rt werden, 
\par wie man Matrizen in MuPAD erstellen und zur Datenein- und ausgabe nutzen kann.  
\par \plain\f5\fs22\cf2\b  \plain\f8\fs22\cf0 
\par \plain\f8\fs28\cf0 Aus der Zahlentheorie (siehe zum Beispiel Remmert, Ulrich: "Elementare Zahlentheorie", 
\par 2. Auflage Birkh\'e4user 1995 S. 25 ff) ist bekannt, dass es unendlich viele Primzahlen gibt. 
\par Genauer gilt: Sind die Primzahlen q1, q2, ... ,qn  bekannt, so ist der kleinste 
\par Teiler t > 1 der nat\'fcrlichen Zahl \plain\f8\fs28\cf0\b a = (q1*q2*...*qn + 1)\plain\f8\fs28\cf0  eine Primzahl, die von den 
\par bisherigen Primzahlen q1, q2, ....., qn verschieden ist. 
\par 
\par Es soll (sollen) in diesem Notebook 
\par 1) schrittweise beginnend mit 2 einzelne Primzahlen mit dem angegebenen Algorithmus 
\par     konstruiert werden. 
\par 2) nachgewiesen werden, dass die so konstruierten Zahlen tats\'e4chlich Primzahlen sind. 
\par 3) die Aussage, dass die so konstruierte Primzahl von den Primzahlen q1, q2, ..... qn 
\par     paarweise verschieden ist, au\'dferhalb der Programmierl\'f6sung nachgewiesen werden.
\par 4) in einer Programmierl\'f6sung Primzahlen nach dem angegebenen Algorithmus konstruiert 
\par     werden. 
\par 5) nachgewiesen werden, dass die in der Programmierl\'f6sung ermittelten Zahlen tats\'e4chlich 
\par     Primzahlen sind.
\par 6) \'fcberpr\'fcft werden, ob mit dem Algorithmus alle Primzahlen ermittelt werden. 
\par \plain\f8\fs22\cf0 
\par \plain\f8\fs32\cf0\b Heuristische L\'f6sung 
\par \plain\f8\fs22\cf0 
\par \plain\f8\fs28\cf0 Zun\'e4chst werden iterativ ausgehend von der Primzahl 2 zwei Primzahlen in Einzelschritten
\par bestimmt, um den Algorithmus zu \'fcberpr\'fcfen. An dieser Stelle erscheint eine Pr\'fcfung durch 
\par MuPAD, ob die gefundenen Zahlen Primzahlen sind, noch \'fcberfl\'fcssig, da diese Eigenschaft 
\par bei den gefundenen Zahlen offensichtlich ist. Andererseits ist die Eigenschaft "Primzahl" 
\par bei gro\'dfen Zahlen nicht mehr offensichtlich. Insofern wird hier die Pr\'fcfung zur Erkl\'e4rung 
\par und Kontrolle des Algorithmus doch durchgef\'fchrt.  
\par 
\par Um zu erkennen, ob eine Zahl Primzahl ist, l\'e4sst man zweckm\'e4\'dfigerweise durch MuPAD 
\par die Primfaktorzerlegung durchf\'fchren. Eine Probe, ob eine nat\'fcrliche Zahl a Primzahl ist, ist  
\par mit MuPAD ist wie folgt m\'f6glich: 
\par Zun\'e4chst wird die Primfaktorzerlegung der Zahl a mit dem Befehl primedivisors durchgef\'fchrt. 
\par Dann pr\'fcft man, ob das erste Element der Primfaktorzerlegung von a  identisch mit der der 
\par Zahl a ist. 
\par Sind beide Zahlen identisch, kann es keine weiteren Elemente der Primfaktorzerlegung geben 
\par und die gefundenen Zahl ist tats\'e4chlich eine Primzahl. Anderenfalls ist a keine Primzahl.  
\par \plain\f8\fs22\cf0 
\par \plain\f8\fs28\cf0 
\par Der Algorithmus zur Bestimmung von Primzahlen weicht in einem Punkt von der oben
\par angegebenen Theorie ab. Entsprechend der Theorie ist der kleinste von 1 verschiedene
\par Teiler der Zahl a die neue Primzahl. In MuPAD entspricht dies dem Befehl
\par "numlib::divisors[2]", da MuPAD die Teiler von links nach rechts in wachsender Gr\'f6\'dfe
\par anordnet. 
\par In diesem Notebook wird abweichend davon der kleinste Primteiler benutzt. Da der kleinste
\par Primteiler allerdings mit dem kleinsten von 1 verschiedenem Teiler entspricht, ist es m\'f6glich, 
\par auch mit diesem Wert zu rechnen. In MuPAD spricht man den kleinsten Primteiler mit
\par dem Befehl "numlib::primdivisors[1]" an. 
\par 
\par Wir beginnen mit der ersten Primzahl 2. (Die Zahl 1 ist keine Primzahl)
\par \plain\f8\fs22\cf0 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}primzahl1:=2
\par \pard\ri4\plain\f8\fs28\cf0 Die zweite potenzielle Primzahl wird konstruiert.\plain\f8\fs22\cf0  
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}primzahl2:=min(numlib::primedivisors(primzahl1+1))
\par \pard\ri4\plain\f8\fs28\cf0 Es wird \'fcberpr\'fcft, ob die gefundene Zahl tats\'e4chlich Primzahl ist. Bei der Antwort 
\par True handelt es sich um eine Primzahl, bei der Antwort false liegt keine Primzahl vor.\plain\f8\fs22\cf0   
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}testeq(numlib::primedivisors(primzahl1+1)[1]=primzahl2)
\par \pard\ri4\plain\f8\fs28\cf0 Es wird nun \'fcberpr\'fcft, ob die gefundene neue Primzahl von den bisher bekannten 
\par Primzahlen verschieden ist. Bei der Antwort false sind die Zahlen des \'fcberpr\'fcften 
\par Zahlenpaares voneinander verschieden.\plain\f8\fs22\cf0  
\par  
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}testeq(primzahl1=primzahl2)
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1 
\par \pard\ri4\plain\f8\fs28\cf0 Die ersten beiden Primzahlen sind somit voneinander verschieden. 
\par 
\par Die dritte potenzielle Primzahl wird konstruiert.\plain\f8\fs22\cf0  
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}primzahl3:=
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1   min(numlib::primedivisors(primzahl1*primzahl2+1))
\par \pard\ri4\plain\f8\fs28\cf0 Es wird nachgewiesen, dass die gefundene Zahl eine Primzahl ist. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}testeq
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1   (numlib::primedivisors(primzahl1*primzahl2+1)[1]=primzahl3)
\par 
\par \pard\ri4\plain\f8\fs28\cf0 Es wird nachgewiesen, dass die gefundene Primzahl von den beiden bisher bekannten 
\par Primzahlen verschieden ist. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}testeq(primzahl1=primzahl3)
\par {\pntext\f1\'b7\tab}testeq(primzahl2=primzahl3)
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1 
\par \pard\ri4\plain\f8\fs28\cf0 Bereits mit diesem Iterationsschritt wird klar, dass der benutzte Algorithmus nicht alle 
\par Primzahlen liefert, da die Primzahl 5 fehlt. 
\par 
\par Im folgenden soll eine Programmierl\'f6sung f\'fcr eine gr\'f6\'dfere Anzahl von Primzahlen 
\par erfolgen. Zun\'e4chst soll nur der konstruktive Aspekt ber\'fccksichtigt werden\plain\f8\fs22\cf0 . \plain\f3\fs22\cf1 
\par \plain\f8\fs22\cf0 
\par \plain\f8\fs28\cf0 Erster Schritt: Die Anzahl der Iterationsschritte und der Startwert f\'fcr die Laufvariable 
\par werden festgelegt.\plain\f8\fs22\cf0  
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Ende:=10:
\par {\pntext\f1\'b7\tab}n:=1:
\par \pard\ri4\plain\f8\fs28\cf0 
\par Zweiter Schritt: Die Daten sollen in einen Vektor der Dimension Ende geschrieben
\par werden. 
\par Die erste Komponente wird mit 2 als erster Primzahl vorinitialisiert. 
\par M\'f6chte man den Algorithmus mit einer anderen Zahl beginnen, ist die zwei 
\par entsprechend zu ersetzen. 
\par Die anderen Elemente der Matrix werden automatisch mit 0 initialisiert und sp\'e4ter 
\par \'fcberschrieben.     
\par Durch den Doppelpunkt wird die Ausgabe unterdr\'fcckt.\plain\f8\fs22\cf0  
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlmatrix:=matrix(Ende,1,[2]):
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1 
\par \pard\ri4\plain\f8\fs28\cf0 Die Variable Primzahlprodukt ist eine Hilfsvariable, da die Produkte im Algorithmus 
\par ben\'f6tigt werden. Diese Variable wird mit dem Startprimzahl f\'fcr den Algorithmus 
\par vorinitialisiert. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlprodukt:=Primzahlmatrix[1]:
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1 
\par \pard\ri4\plain\f8\fs28\cf0 Nun werden die Primzahlen berechnet und in die Primzahlmatrix geschrieben.\plain\f8\fs22\cf0  
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}while n < Ende do
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1    Primzahlmatrix[n+1]
\par       :=min(numlib::primedivisors(Primzahlprodukt+1));
\par    Primzahlprodukt
\par       :=Primzahlprodukt*Primzahlmatrix[n+1];
\par    n:=n+1;
\par end_while:
\par 
\par \pard\ri4\plain\f8\fs28\cf0 Die Primzahlmatrix wird ausgegeben. 
\par \plain\f8\fs22\cf0 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlmatrix
\par \pard\ri4\plain\f8\fs22\cf0 
\par \plain\f8\fs28\cf0 Offensichtlich stimmen die ersten drei ausgegebenen Elemente der Matrix mit den oben 
\par bestimmten Primzahlen \'fcberein. Die weiteren Elemente lassen sich sowohl durch 
\par manuelle Berechnungen, als auch wie oben beschrieben mit MuPAD berechnen.  
\par  
\par Man stellt durch Ablesen fest: 
\par 1) Die Zahlen sind  paarweise voneinander verschieden.
\par 2) Es werden nicht alle Primzahlen erfasst. Hier fehlt beispielsweise die Primzahl 11.
\par 3) Wider Erwarten ist die Folge der Primzahlen nicht monoton steigend. 
\par Die ersten sieben Ergebnisse der Iteration sind offensichtlich Primzahlen. Bei gr\'f6\'dferen 
\par Zahlen ist jedoch nicht ohne weiteres erkennbar, dass es sich eine um eine Primzahl 
\par ergeben hat.
\par 
\par F\'fcr den Nachweis, dass die berechneten Zahlen tats\'e4chlich Primzahlen sind, werden 
\par die Elemente der Primzahlmatrix ausgelesen und einzeln entsprechend dem weiter oben 
\par angegebenem Algorithmus mit dem ersten Element der Primzahlzerlegung verglichen. 
\par Die Ergebnisse der jeweiligen Proben werden in eine als Testmatrix bezeichnete Matrix 
\par eingelesen. Die Elemente der Matrix sind mit 0 vorinitialisiert und werden dann bei 
\par jedem Iterationsschritt \'fcberschrieben. 
\par 
\par Die hier durchgef\'fchrte Entkopplung der Iterationen hat den Vorteil, dass die Algorithmen 
\par unabh\'e4ngig voneinander entwickelt und getestet werden k\'f6nnen. Gemeinsame Daten 
\par aller Iterationen sind die Variable Ende, die die Anzahl der Iterationen bestimmt, 
\par die Primzahlmatrix und die Testmatrix. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Testmatrix:=matrix(Ende,1): 
\par {\pntext\f1\'b7\tab}delete(m):
\par \pard\ri4\plain\f8\fs28\cf0 
\par An dieser Stelle sollte zun\'e4chst die Iteration bei 1 begonnen werden. Fehlermeldungen 
\par von MuPAD erzwangen die Besetzung der ersten Komponente der Testmatrix au\'dferhalb 
\par der Schleife und die Benutzung der Variablen Zwischenspeicher.
\par  \plain\f8\fs22\cf0 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Zwischenspeicher:=
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1     testeq(numlib::primedivisors(Primzahlmatrix[1])[1]
\par                                  =Primzahlmatrix[1]):
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Testmatrix[1]:=Zwischenspeicher:
\par {\pntext\f1\'b7\tab}for m from 2 to Ende  do
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1    Testmatrix[m]:=testeq(numlib::primedivisors
\par                 (Primzahlmatrix[m])[1]=Primzahlmatrix[m]);
\par       
\par end_for:
\par 
\par \pard\ri4\plain\f8\fs22\cf0 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Testmatrix
\par \pard\ri4\plain\f8\fs28\cf0 An dieser Stelle sind bis auf die angegebene L\'fccke bei der \'dcberpr\'fcfung auf Ungleichheit 
\par der Primzahlen die mathematischen Inhalte im Rahmen des Algorithmus abgearbeitet. 
\par  
\par Allerdings ist die Ausgabe der Testmatrix ohne gemeinsame Darstellung mit der zuge-
\par h\'f6rigen Primzahl nicht optimal. Angebrachter erscheint es, die Primzahlen mit den 
\par Ergebnissen der \'dcberpr\'fcfung, ob es sich um Primzahlen handelt, gemeinsam darzustellen. 
\par Um Doppelausgaben der Ergebnisse zu vermeiden, kann es sinnvoll sein, die uner-
\par w\'fcnschten Ausgaben durch einen Doppelpunkt hinter dem jeweiligen Befehl zu 
\par unterdr\'fccken.
\par 
\par Die gemeinsame Darstellung in einer einheitlichen Matrix mit geeigneter Dokumentation wird 
\par im folgenden durchgef\'fchrt. Dabei wird in einem ersten Schritt das Ergebnis der Testmatrix 
\par in eine besser lesbare Aussage "ist Primzahl" beim Ergebnis TRUE bzw. "ist keine Primzahl" 
\par beim Ergebnis FALSE \'fcbersetzt. 
\par 
\par Der folgende Teil der Notebooks benutzt anspruchsvollere Funktionen von MuPAD als in 
\par den vorherigen Teilen, dient aber andererseits zur Verbesserung der Dokumentation und kann 
\par bei einer ersten Durchsicht \'fcbersprungen werden.  \plain\f8\fs22\cf0   
\par \plain\f3\fs22\cf1 
\par \plain\f8\fs28\cf0 Zun\'e4chst wird der Startwert der Laufvariablen zur\'fcckgesetzt. Dann wird die Ausgabematrix 
\par definiert. Alle Elemente dieser Matrix sind mit 0 vorinitialisiert und werden dann in der  
\par Durchf\'fchrung der Iteration mit den Werten aus den oben angegebenen Matrizen \'fcber
\par schrieben.Es werden zwei Ausgabevarianten dargestellt: Erst wird die Funktion print benutzt 
\par und anschlie\'dfend wird die Ausgabematrix ausgegeben. Auch hier lassen sich unerw\'fcnschte 
\par Ausgaben durch Doppelpunkte hinter den Befehlen unterdr\'fccken. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}delete k:
\par {\pntext\f1\'b7\tab}Ausgabe:= matrix(Ende, 2):
\par {\pntext\f1\'b7\tab}for k from 1 to Ende do
\par \pard\li600\ri1\fi-300\plain\f3\fs28\cf1   if Testmatrix[k] = TRUE
\par     then
\par       print(Typeset, 
\par        "Primzahl Nr. ".expr2text(k).": ".Primzahlmatrix[k]);
\par       Ausgabe[k,1]:= "Primzahl Nr. ".expr2text(k);
\par       Ausgabe[k,2]:= Primzahlmatrix[k];
\par     else
\par       print(Typeset, 
\par        "keine Primzahl: ".expr2text(Primzahlmatrix[k]));
\par       Ausgabe[k,1]:= "keine Primzahl: ";
\par       Ausgabe[k,2]:= Primzahlmatrix[k];
\par   end_if;
\par end_for:
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f3\fs28\cf1 {\pntext\f1\'b7\tab}Ausgabe
\par \pard\ri4\plain\f8\fs28\cf0 Eine Auswahl m\'f6glicher Anschlussaufgaben: 
\par 
\par 1)   Ein noch offener Punkt in der Programmierl\'f6sung ist der Nachweis, dass die gefundenen 
\par       Primzahlen paarweise voneinander verschieden sind. Die Programmierl\'f6sung kann um 
\par       diesen Nachweis erg\'e4nzt werden. 
\par 
\par 2)   Es ist unter Umst\'e4nden l\'e4stig, dass der Nachweis, dass die gefundenen Zahlen Primzahlen 
\par       sind, f\'fcr jede Zahl einzeln ausgegeben wird. Es ist m\'f6glich, die Ergebnisse der Nachweise 
\par       zu einer einzigen Aussage zusammenzufassen. 
\par 
\par 3)   Bei der Benutzung des Algorithmus wurden die beginnend mit 2 die gefundenen Primzahlen 
\par       im jeweils n\'e4chsten Iterationsschritt benutzt.  Es ist m\'f6glich, mit anderen Startwerten als 2 
\par       zu beginnen und den Algorithmus in der beschriebenen Form durchf\'fchren. 
\par       Es ist aber auch m\'f6glich, sich von der beschriebenen Iteration zu l\'f6sen und 
\par       mit willk\'fcrlich gew\'e4hlten Produkten von Primzahlen zu experimentieren. 
\par 
\par 4)   Eine interessante Aufgabe ist es, gro\'dfe Primzahlen bzw. Primzahlen mit bestimmten 
\par       Eigenschaften zu finden. 
\par       Man kann daher die Programmierl\'f6sung so erg\'e4nzen, dass der Algorithmus Primzahlen 
\par       findet, deren Ziffernzahl eine vorgegebene Anzahl von Ziffern \'fcberschreitet bzw. mit 
\par       dieser Ziffernzahl \'fcbereinstimmt. Alternativ ist es auch m\'f6glich, sich nur die Anzahl der 
\par       Ziffern mit der gew\'fcnschten Eigenschaft ausgeben zu lassen.   
\par 
\par 5)   Es kann \'fcberpr\'fcft werden, welche Auswirkungen auftreten, wenn man im Algorithmus 
\par       Zahlen benutzt, die keine Primzahlen sind. Diese \'dcberpr\'fcfung ist problemlos au\'dferhalb 
\par       der Programmierl\'f6sung m\'f6glich. Andererseits kann man auch den Startwert der 
\par       Programmierl\'f6sung so w\'e4hlen, dass er keine Primzahl ist. In diesem Fall sollte erkl\'e4rt, 
\par       werden, warum alle weiteren Zahlen doch Primzahlen sind. 
\par 
\par 6)   Es kann einen Check eingebaut werden, der bewirkt, dass der Algorithmus nur mit 
\par       Primzahlen als Startwert durchlaufen wird. 
\par 
\par 7)   Man kann die Programmierl\'f6sung in Form einer Prozedur realisieren.
\par 
\par 8)   In der vorliegenden L\'f6sung wird die Primzahlnummer fehlerhaft ausgegeben, wenn man 
\par       den Algorithmus mit einer Zahl beginnt, die keine Primzahl ist. Der Fehler tritt nicht auf, 
\par       wenn der Startwert eine Primzahl ist. Dies teilkorrekte Verhalten sollte verifiziert, 
\par       begr\'fcndet und korrigiert werden. 
\par 
\par 9)   Es ist m\'f6glich, die vorliegende L\'f6sung zu verk\'fcrzen und optimieren, indem man die aus 
\par      didaktischen Gr\'fcnden getrennt dargestellten Programmierl\'f6sungen zu einer 
\par       kompakten L\'f6sung zusammenfasst. 
\par 
\par 10) Schlie\'dflich kann man den Algorithmus auf den Befehl "numlib::divisors[2] umstellen. 
\par 
\par \plain\f3\fs20\cf0\b ______________________________________________________________________________
\par \plain\f5\fs22\cf0 
\par \plain\f5\fs22\cf2\b Anmerkung:\plain\f5\fs22\cf2 
\par \plain\f5\fs20\cf2\b 
\par 1.\plain\f5\fs20\cf2  Darstellungen des gew\'e4hlten Algorithmus finden sich in vielen B\'fcchern zur Zahlentheorie. Das vorliegende 
\par     Notebook bezieht sich auf die Darstellung in Remmert, Ulrich: "Elementare Zahlentheorie", 2. Auflage 
\par     Birkh\'e4user 1995.  
\par 
\par \plain\f5\fs20\cf2\b 2.\plain\f5\fs20\cf2  L\'f6sungen von Programmierproblemen im Rahmen der linearen Algebra und Analysis finden sich in weiteren 
\par     Notebooks des gleichen Autors. 
\par 
\par \plain\f5\fs20\cf2\b 3.\plain\f5\fs20\cf2  Weitere Aspekte der Anwendung von MuPAD auf die Zahlentheorie finden sich in zwei Notebooks des 
\par     gleichen Autors, die sich mit vollkommenen Zahlen besch\'e4ftigen. 
\par 
\par \plain\f5\fs20\cf2\b 4.\plain\f5\fs20\cf2  Weitere Anregungen finden Sie in der Unterrichsmaterialsammlung unter \plain\f5\fs20\cf3 schule.mupad.de\plain\f5\fs20\cf2 . In diesen 
\par     Notebooks werden eine Vielzahl unterschiedlichster mathematischer Probleme mit MuPAD Pro gel\'f6st. 
\par \plain\f3\fs20\cf0\b ______________________________________________________________________________
\par 
\par \plain\f8\fs22\cf0 
\par }