MuPAD in Schule und Studium

Transkript

1 MuPAD in Schule und Studium Kai Gehrs, Eine spielerische Anwendung für das Lösen linearer Gleichungssysteme über dem Körper mit zwei Elementen

2 Inhalt...: Die Reise nach Trisentis Kategorie.: Lehreinheit Mathematik: Lineare Algebra MuPAD...: 2.5., 2.. Datum...: Autoren...: Kai Gehrs Funktionen: Dom::IntegerMod, Dom::SparseMatrix, plot, plot::rectangle2d, Funktionen: linalg::matdim, abs, print, expr, domtype, linalg::matlinsolve Funktionen: linalg::concatmatrix, table() Die Reise nach Trisentis Diese Lehreinheit basiert auf dem Artikel "Wie kommt man nach Disentis?" von Achim Clausing, erschienen in "Spektrum der Wissenschaft", Januar 23, Serie 25 Jahre Spektrum, Seiten bis 3. Wir wollen MuPAD benutzen, um das dort vorgestellte mathematische Problem zu visualisieren und Lösungen in speziellen Fällen berechnen zu lassen. Die Notebook- Version ist in die Teile Trisentis.mnb, Trisentis2.mnb und Trisentis3.mnb unterteilt und bietet neben den hier vorgestellten Prozeduren noch eine weitere zum tatsächlichen, interaktiven Spielen von Trisentis. In diesem Notebook wollen wir eine Anwendung der Linearen Algebra im Rahmen eines Spieles diskutieren. Das Spiel, mit wir uns beschäftigen wollen, heißt "Reise nach Trisentis". Es wurde ursprünglich zu dem Zweck erfunden, eine längere Wartezeit zu überbrücken. Daher wird im folgenden ganz sicher keine Langeweile aufkommen. Zunächst zu den Spielregeln: - Ausgangssituation: Wir stellen uns vor, wir haben ein quadratisches Bild mit einem beliebigen Motiv (z.b. einem Foto einer schneebedeckten Bergspitze oder ähnlichem). Wir zerschneiden das Bild mit einer Schere in 4 x 4 gleich große Felder. Dann legen wir die verdeckten Felder auf einen Tisch. - Ziel des Spiels: Ziel soll es im folgenden sein, durch geschicktes Aufdecken nach fest vorgegebenen Regeln alle Felder sukzessive Umzudrehen, so dass das Bild wieder zum Vorschein kommt. - Visualisierung mit MuPAD: Da unser Spiel vollkommen unabhängig von der Wahl des Bildes und des Motivs ist, stellen wir das aufgedeckte Bild als grünes Quadrat mit 4 x 4 Teilfeldern dar:

3 (Aufgedecktes Bild mit 4 x 4 Teilfeldern) Insbesondere sind also die im folgenden auftauchenden grünen Felder genau diejenigen, die aufgedeckt sind. Das Bild in (vollkommen) verdeckter Form stellen wir durch ein entsprechendes blaues Quadrat mit 4 x 4 Teilfeldern dar: (Vollkommen verdecktes Bild mit 4 x 4 Teilfeldern) Drehen wir z.b. das linke obere Feld um, so erhalten wir die folgende Situation: (Linke obere Ecke des Bildes aufgedeckt, Rest des Bildes verdeckt) d.h. das linke obere Feld ist aufgedeckt und alle anderen sind weiterhin verdeckt. Als nächstes wollen wir die Regeln festlegen, nach denen Felder aufgedeckt bzw. auch wieder verdeckt werden können.

4 - Spielregeln: Das Spiel ist ganz einfach. Wir starten mit der vollkommen verdeckten Version des Bildes: (Vollkommen verdecktes Bild mit 4 x 4 Teilfeldern) Der erste Zug besteht nun darin, sich ein beliebiges Feld auszuwählen und dann alle direkt benachbarten Felder umzudrehen. Wählen wir das Feld 2,2), d.h. das zweite Feld von links in der zweiten Zeile, so erhalten wir das folgende Bild: (Spielfeld nach dem ersten Zug, bei dem das Feld (2,2) gewählt wurde) Das blaue Feld in der zweiten Zeile und der zweiten Spalte ist also weiterhin verdeckt (die ausgewählten Felder bleiben immer unberührt) und die um dieses Feld herumliegenden Felder sind nun aufgedeckt. In allen nun folgenden Zügen kann man sich wieder ein beliebiges Feld aussuchen (egal, ob verdeckt oder bereits aufgedeckt). Alle benachbarten Felder werden dann entsprechend umgedreht, d.h. verdeckte Felder werden aufgedeckt und aufgedeckte Felder wieder verdeckt. Wählen wir also als nächstes das Feld (,) ganz oben links in der Ecke, so ergibt sich folgende Situation:

5 (Spielfeld nach einem weiteren Zug, bei dem das Feld (,) gewählt wurde) - Ende des Spiels: Das Spiel ist beendet, wenn nur noch offene Felder zu sehen (d.h. wenn in unserer Darstellung alle Felder grün gefärbt) sind. Im folgenden wollen wir diejenigen MuPAD Prozeduren vorstellen, die zur Durchführung und Visualisierung des Spiels genutzt werden können. Die Grundidee besteht darin, das quadratische Bild als Matrix zu interpretieren. Da nur die beiden Fälle "Feld ist aufgedeckt" oder "Feld ist zugedeckt" auftreten können, macht es Sinn, für die Komponenten der Matrizen ebenfalls nur zwei mögliche Einträge zuzulassen: für ein verdecktes Feld und für ein aufgedecktes Feld. Wenn wir nur Matrizen betrachten, deren Einträge nur aus Nullen und Einsen bestehen, sind diese in natürlicher Weise dünnbesetzt. Es bietet sich daher aus Effizienzgründen und Gründen der Speicherersparnis an, unsere Matrizen über dem Domain Dom::SparseMatrix zu definieren (dies ist genau die Struktur für dünnbesetzte Matrizen in MuPAD). Der richtige Koeffizientenbereich für die Einträge der Matrix ist in unserer Situation der Domain Dom::IntegerMod(2) d.h. der Körper, der nur aus zwei Elementen - nämlich und - besteht und der im wesentlichen durch die Rechenregeln + = + = + = + = (Rechenregeln im Körper mit * = * = 2 Elementen) * = * = beschrieben ist. Statt einfach nur und zu schreiben, schreibt man in der Regel mod 2 und mod 2, um anzudeuten, dass wir nicht mit "normalen Zahlen", sondern mit Elementen des Körpers mit zwei Elementen nach den entsprechenden Rechenregeln von oben rechnen.

6 Ein Beispiel für eine 4 x 4 Matrix über dem Körper mit zwei Elementen, die eine Spielsituation in unserem Spiel kodieren könnte, ist die folgende: F2:= Dom::IntegerMod(2): Mat:= Dom::SparseMatrix(F2): Spielstand:= Mat([[,,,],[,,,],[,,,],[,,,]]) mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 Stellen wir uns jetzt vor, dass jede mod 2 ein offenes und jede mod 2 ein verdecktes Feld darstellt, so kodiert die Matrix Spielstand genau den Spielstand von oben, den wir durch zweimaliges Ziehen erreicht hatten: (Spielfeld nach dem zweiten Zug, bei dem das Feld (,) gewählt wurde) Nun benötigen wir eine Prozedur plotmatrix, die eine Matrix über dem Körper mit zwei Elementen so darstellt, dass wir Sie als Spielsituation interpretieren können. Eine mögliche Version dieser Prozedur ist die folgende, die als Argumente neben der Matrix auch noch zwei Farben erhält, so dass man auch andersfarbige Quadrate als die von uns bisher gezeichneten mit MuPAD darstellen kann: plotmatrix:= proc(m, c, c) local i, j, c, L, dim; begin dim:= linalg::matdim(m)[]; L:= table(); for i from to dim do for j from to dim do if iszero(m[i,j]) then c:= c else c:= c end_if; L[i,j]:= plot::rectangle2d([j-, i-],,, Color = c, Filled = TRUE), plot::rectangle2d([j-, i-],,,

7 Color = RGB::Black); end_for; end_for; plot(l[i,j] $ i =..dim $ j =..dim, Axes = None, Scaling = Constrained); end_proc: plotmatrix(spielstand, RGB::Blue, RGB::Green): Nun zu den Zügen, die man im Spiel machen kann: Oben hatten wir für den ersten Zug das Feld in der zweiten Zeile von oben und in der zweiten Spalte ausgewählt und damit das verdeckte Feld (repräsentiert durch die Nullmatrix) überführt in den Zustand (Vollkommen verdecktes Bild mit 4 x 4 Teilfeldern) (Spielfeld nach dem ersten Zug, bei dem das Feld (2,2) gewählt wurde)

8 der durch die Matrix mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 (Matrix über dem Körper mit zwei Elementen kodiert die Spielsituation) kodiert werden soll. Wir sehen also, dass das Ziehen nach den Spielregeln nichts anderes ist, als die Addition einer geeigneten "Zugmatrix" zu derjenigen Matrix, die den aktuellen Spielstand darstellt. Die folgende Prozedur zugdelta hilft, die Spielzüge direkt in Matrixform zu kodieren. Sie erhält stets zwei Argumente, von denen das erste die Zeile und das zweite die Spalte bezeichnet, in der das Feld liegt, dass wir bei unserem nächsten Zug auswählen möchten (d.h. dasjenige Feld, dessen Nachbarfelder wir alle umzudrehen haben). zugdelta:= proc(a,b) local i,j, M; begin M:= Mat(x,y); for i from to x do for j from to y do if abs(i-a)<= and abs(j-b)<= and (i<>a or j<>b) then M[i,j]:= ; else M[i,j]:= ; end_if; end_for; end_for; return(m); end_proc: Eine wichtige Besonderheit ist an dieser Stelle zu nennen: Die Prozedur zugdelta arbeitet mit Hilfe der globalen Variablen x und y. Dies bedeutet, dass wir an x und y irgendwo in unserem Notebook Werte zuweisen können, die dann in der Prozedur automatisch bekannt sind. Dabei ist mit x die Anzahl der Zeilen einer Matrix und mit y die Anzahl der Spalten einer Matrix gemeint. Diese Vorgehensweise hat den Vorteil, dass wir das Format des Spielfeldes an einer Stelle im Notebook global ändern können und alle Prozeduren dann automatisch auf diesen Werten für das Format operieren. Wir betrachten hier zunächst 4 x 4 Felder, also x:= 4: y:= 4:

9 Wir hatten im ersten Zug das Feld in der zweiten Zeile und zweiten Spalte von oben ausgewählt. Dies entspricht jetzt genau der Matrix zugdelta(2,2) mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 mod2 die wir natürlich auch wieder entsprechend visualisieren können: plotmatrix(zugdelta(2,2), RGB::Blue, RGB::Green): Jetzt kann das Spiel beginnen. Im folgenden versuchen wir unser Glück bei einem 4 x 4 Bild. Zunächst wollen wir aber die Ausgabeform der Matrizen etwas kompakter gestalten. Da wir ja immer nur mit Matrizen über dem Körper mit zwei Elementen betrachten, sollte nicht hinter jedem Eintrag der Matrix mod 2 stehen. Es genügt uns, wenn nur die Zahlen und ausgegeben werden. Jeder MuPAD Domain besitzt eine print-methode, die zur Ausgabe der entsprechenden mathematischen Objekte auf dem Bildschirm zuständig ist. Auf die print-methode des von uns benutzten Domains F2 für den Körper mit zwei Elementen (in der Variablen F2 hatten wir den Domain Dom::IntegerMod(2) gespeichert) greifen wir wie folgt zu: F2::print x -> hold(_mod)(extop(x, ), Mod) Wenn wir auf die Methode zugreifen können, so können wir Sie auch entsprechend unseren Vorstellungen umgestalten: F2::print:= F2::expr: Mit Hilfe dieses Befehls erreichen wir es, dass statt mod 2 und mod 2 im folgenden

10 immer nur bzw. ausgegeben wird (die Elemente aber immer vom Typ Dom::IntegerMod(2) sind): zugdelta(2,2) Fragen wir zur Sicherheit noch einmal den Typ der Matrix ab: domtype(zugdelta(2,2)) Dom::SparseMatrix(Dom::IntegerMod(2)) In der Tat hat unsere Vorgehensweise zum Ziel geführt. Nun zu dem Spiel. Die Startmatrix ist die Nullmatrix und alle Felder sind verdeckt: Start:= Mat(x,y); plotmatrix(start, RGB::Blue, RGB::Green): Wähle zuerst das Feld (, ) und drehe alle umliegenden Felder um: Zustandsmatrix:= Start + zugdelta(,); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green):

11 Jetzt wähle das Feld (, 3) aus: Wir erhalten somit Zustandsmatrix:= Zustandsmatrix + zugdelta(,3); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green): Als nächstes drehe alle Felder um das Feld (2, 2) herum um: Zustandsmatrix:= Zustandsmatrix + zugdelta(2,2); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green):

12 Jetzt wähle das Feld (3, 2). Damit ergibt sich die Spielsituation: Zustandsmatrix:= Zustandsmatrix + zugdelta(3,2); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green): Fast haben wir es geschafft. Wir wählen noch das Feld (4, ) Zustandsmatrix:= Zustandsmatrix + zugdelta(4,); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green):

13 und schließlich das Feld mit der Position (4, 3): Zustandsmatrix:= Zustandsmatrix + zugdelta(4,3); plotmatrix(zustandsmatrix, RGB::Blue, RGB::Green): Geschafft!!! Die Fragen, die man sich als mathematisch Interessierter jetzt stellt, sind natürlich: Gibt es eine systematische Vorgehensweise, die zur Lösung führt? Gibt es überhaupt immer eine Lösung? Wenn ja, wie findet man eine Lösung? Wir wollen uns von jetzt an ein wenig mit der Theorie beschäftigen, die nötig ist, um die gestellten Fragen zu beantworten. Um eine Lösung des Trisentis-Problems zu finden, müssen wir stets eine Anzahl geschickt gewählter Züge miteinander kombinieren. Solche Kombinationen von Zügen lassen sich - wie oben in unserem konkreten Beispiel bereits durchgeführt - durch sukzessive Addition von Zugmatrizen realisieren. Die Lösung des obigen Problems können wir also auch in einem Zug wie folgt darstellen: Start:= Mat(x,y); plotmatrix(start, RGB::Blue, RGB::Green):

14 Ergebnis:= Start + zugdelta(,) + zugdelta(,3) + zugdelta(2,2) + zugdelta(3,2) + zugdelta(4,) + zugdelta(4,3); plotmatrix(ergebnis, RGB::Blue, RGB::Green): Die Lösung erhalten wir also als eine "Linearkombination" der Startmatrix mit den entsprechenden Zugmatrizen. Wir können diese Linearkombination auch als eine Linearkombination der Startmatrix und aller möglichen Zugmatrizen auffassen, wobei diejenigen Zugmatrizen, die Züge darstellen, die wir gar nicht durchführen, als Koeffizienten erhalten. Zum Auffinden einer Lösung könnten wir also den Ansatz

15 Start + a[,] * zugdelta(,) + a[,2] * zugdelta(,2) + a[,3] * zugdelta(,3) + a[,4] * zugdelta(,4) + a[2,] * zugdelta(2,) + a[2,2] * zugdelta(2,2) + a[2,3] * zugdelta(2,3) + a[2,4] * zugdelta(2,4) + a[3,] * zugdelta(3,) + a[3,2] * zugdelta(3,2) + a[3,3] * zugdelta(3,3) + a[3,4] * zugdelta(3,4) + a[4,] * zugdelta(4,) + a[4,2] * zugdelta(4,2) + a[4,3] * zugdelta(4,3) + a[4,4] * zugdelta(4,4) wobei die Matrix Ergebnis nur aus Einsen besteht und die Werte a[,],..., a[,4],a[2,],...,a[4,4] entweder oder sind (je nach dem, ob wir die entsprechende Zugmatrix zur Lösung benötigen oder nicht. Im Prinzip führt uns also dieser Ansatz auf eine Art Gleichungssystem. Das Problem, das sich nun stellt, ist, dass die Zugmatrizen zugdelta(i,j) eben keinen Vektoren sind, und wir das System daher nicht einfach mit Hilfe der Funktion linalg::matlinsolve lösen können. Wir müssen daher aus dem obigen System ein Gleichungssytem in der üblichen Form bilden, d.h. (Koeff.-Matrix) * (Vektor mit Unbekannten) = (Rechte Seite). Diese Konvertierung können wir wie folgt vornehmen: Wir schreiben jede der vorkommenden Zugmatrizen in einen Vektor um, d.h. wir stellen einfach die Spalten der Matrix übereinander. Damit wird z.b. die Zugmatrix in der Form

16 in einen Vektor konvertiert. Die Konvertierung lässt sich leicht mit Hilfe des Befehls op erreichen, der einfach eine Sequenz der Einträge einer Matrix liefert: v:= Mat([op(zugdelta(2,2))]): zugdelta(2,2), v, Die Rückkonvertierung geben wir in Form der Funktion Vector2Matrix an: Sie überführt den Vektor, der ursprünglich aus einer Matrix hervorging, wieder in eine Matrix. MuPAD selbst bietet von sich aus keine Funktion, mit der sich die Konvertierung direkt realisieren lässt (was aber aufgrund der Tatsache, dass es sich um eine sehr speziell und eng an unser Problem gebundene Routine handelt, durchaus verständlich ist). Wir schreiben die Funktion schnell selbst: Vector2Matrix:= proc(v) local M, i,j; begin M:= type(v)(x,y): for j from to y do for i from to x do M[i,j]:= v[i + (j-) * x]; end_for; end_for; return(m); end_proc: Auch diese Routine testen wir an dem obigen Beispiel: v, Vector2Matrix(v)

17 , Damit haben wir alles Handwerkzeug beisammen, um eine Lösung des Trisentis- Problems berechnen zu können. Wir erinnern uns, dass wir ein linearen Gleichungssystem zu lösen haben. Die Koeffizientenmatrix des Gleichungssystems setzt sich nun aus den in Spaltenvektoren konvertierten Zugmatrizen zusammen: A:= linalg::concatmatrix( Mat([op(zugdelta(i,j))]) $ i =..x $ j =..y): Die Spalten der Matrix A bestehen nun also aus den zu Spaltenvektoren konvertierten Zugmatrizen: A Ziel des Spiels ist es, alle Felder aufzudecken. Daraus ergibt sich für unser lineares Gleichungssystem als rechte Seite der Vektor, der nur aus Einsen besteht (alle Felder aufgedeckt = Ergebnismatrix besteht nur aus Einsen, die für unsere Zwecke dann ebenfalls wieder in einen Vektor konvertiert wird). Die Lösung erhalten wir also über:

18 b:= Mat([ $ x*y]): L:= linalg::matlinsolve(a, b),,,, Wir sind eigentlich nur an einer Lösung interessiert, aber schon an diesem Beispiel sehen wir, dass das Gleichungssystem nicht nur genau eine, sondern eine Vielzahl von Lösungen besitzt. Der erste Vektor in der obigen Liste ist eine spezielle Lösung des Gleichungssystems: Alle weiteren Lösungen erhalten wir, indem wir zu diesem Vektor beliebige Linearkombinationen der Vektoren addieren, die in der zweiten (inneren) Liste zusammengefasst sind (diese bilden die Kernvektoren der Matrix, d.h. sie spannen den Lösungsraum des zugehörigen homogenen linearen Gleichungssystems A * x = auf). Damit ist die Frage nach der Eindeutigkeit von Lösungen beantwortet: Es kann mehr als nur eine Lösung des Trisentis-Problems geben. Die genau ist nun die (spezielle) Lösung in Form des Vektors L[]

19 zu interpretieren? Nun: Am einfachsten lässt sich die Lösung deuten, wenn wir den Vektor wieder in eine Matrix zurückkonvertieren und diese grafisch als 4 x 4 Quadrat darstellen lassen: Zuege:= Vector2Matrix(L[]): plotmatrix(zuege, RGB::Blue, RGB::Green): Wenn wir jetzt einmal einen Blick auf die grünen Felder werfen, so stellen wir fest, dass Sie genau die Felder markieren, die wir, als wir das Trisentis-Problem oben per Hand gelöst hatten, benutzt haben. Die Lösung war gegeben durch Ergebnis:= Start + zugdelta(,) + zugdelta(,3) + zugdelta(2,2) + zugdelta(3,2) + zugdelta(4,) + zugdelta(4,3); Die unterstrichenen Wertepaare markieren genau die Positionen der grünen Felder. Die "mathematische Lösung" in Form einer Matrix erhalten wir dann, indem wir die Koeffizienten Zuege[i,j] mit den entsprechenden Zugmatrizen zugdelta(i,j) multiplizieren und anschließend alle so erhalten Matrizen zu der Startmatrix hinzu addieren. Ergebnis:= Start + _plus( Zuege[i,j] * zugdelta(i, j) $ i =..x $ j =..y ) Die Ergebnismatrix besteht also tatsächlich nur aus Einsen und kodiert damit das Spielfeld in der Form, in der alle Quadrate korrekt aufgedeckt sind:

20 plotmatrix(ergebnis, RGB::Blue, RGB::Green): Wir fassen zusammen: Wir haben einen systematischen Weg gefunden, wie man eine Lösung des Trisentis-Problems berechnen kann (falls eine Lösung existiert). Es kann, wie wir im obigen Beispiel gesehen haben, durchaus mehrere Lösungen geben. Die Reihenfolge, in der die durch die Lösung bestimmten Züge ausgeführt werden, ist egal: Die Lösung ergibt sich als Summe der Startmatrix und der Linearkombinationen der Zugmatrizen. Da die Matrixaddition kommutativ ist, können Summanden in der Linearkombination beliebig vertauscht werden. Es gibt aber auch Werte für n, so dass das Trisentis-Problem nicht lösbar ist. Für den Fall eines 5 x 5 Feldes ist das Problem z.b. nicht lösbar: x:= 5: y:= 5: A:= linalg::concatmatrix(mat([op(zugdelta(i,j))]) $ i =..x $ j =..y ): b:= Dom::SparseMatrix(Dom::IntegerMod(2))([ $ x*y]): L:= linalg::matlinsolve(a, b) [] Das zugeordnete Gleichungssystem besitzt keine Lösung, denn wir erhalten als Ergebnis die leere Liste. Einige Anmerkungen zur Komplexität: Stellen wir uns vor, wir betrachten ein n x n Feld für eine beliebige natürliche Zahl n. Dann handelt es bei der Startmatrix und den jeweiligen Zugmatrizen um n x n Matrizen. Unser Ansatz führt wegen der Konvertierungder Matrizen in Vektoren zu Spaltenvektoren mit n² vielen Zeilen. Die Koeffizientenmatrix des Gleichungssystems ist also eine n² x n² Matrix. Geht man davon aus, dass die Lösung des Gleichungssystems nach einer Standard-Gauß Elimination (ohne Optimierung in Hinsicht auf die dünne Struktur der jeweiligen Matrizen) berechnet wird, so hat der Algorithmus zur Berechnung einer Lösung unseres Problems bei Eingabe einer m x m Koeffizientenmatrix für das lineare Gleichungssystem etwa Laufzeit O(m³). In unserem Fall ist m = n², also m³ = (n²)³ = n 6, d.h. der Algorithmus zur

21 Berechnung der Lösung benötigt einen Aufwand von etwa O(n 6 ). Jetzt berechnen wir noch eine Lösung des Trisentis-Problems für n = 2 (man bedenke dabei: wir haben es beim Lösen des Gleichungssystems mit 2² x 2² = 4 x 4 Matrizen zu tun, weshalb man schon ein bisschen mehr Geduld benötigt, als in den kleinen obigen Beispielen für n = 4 bzw. n = 5): x:= 2: y:= 2: A:= linalg::concatmatrix(mat([op(zugdelta(i,j))]) $ i =..x $ j =..y): b:= Dom::SparseMatrix(Dom::IntegerMod(2))([ $ x*y]): L:= linalg::matlinsolve(a, b): Wir lassen die Lösungen hier nicht ausgeben - die Vektoren sind einfach zu groß. In diesem Fall hat MuPAD genau eine Lösung berechnet, weshalb L keine Liste von Vektoren ist, sondern ein einzelner Vektor. Wir konvertieren ihn wie üblich in eine Matrix und stellen sie anschließend grafisch dar: Zuege:= Vector2Matrix(L): plotmatrix(zuege, RGB::Blue, RGB::Green): Als letztes wollen wir das Spiel ein wenig realistischer gestalten. Bisher waren die blauen Felder immer die zugedeckten, die grünen die offenen Felder. Im folgenden werden wir ein "wirkliches Bild" von einem mathematischen Objekt als Grundlage für unser Spiel verwenden, d.h. wir ersetzen die grünen Felder durch solche, in denen ein tatsächliches Motiv zum Vorschein kommt. Im folgenden werden wir ein wenig exzessiver Gebrauch von den Programmiermöglichkeiten in MuPAD machen. Unser Motiv für den Hintergrund soll im folgenden ein "Spinnennetz" sein, das über eine kleine Prozedur definiert ist: SpiderNet:= proc(move, r, rc, gc, bc) local lines, theta, i, newline, x, y, x, y, pi; begin lines:=[]; pi:= float(pi);

22 for i from to 8 do theta:= float(i*pi/8); x:= r*cos(theta)+r; y:= r*sin(theta)+r; x:= r*cos(move*theta)+r; y:= r*sin(move*theta)+r; newline:= plot::line( [x, y], [x, y], Color = [abs(rc*sin(2*theta)), abs(gc*sin(2*theta+pi/4)), abs(bc*sin(2*theta+pi/2))] ); lines:=lines.[newline]; end_for: lines:=plot::group(op(lines)): end_proc: Mit dem Aufruf plot(spidernet(, x/2,.9,.2,.4)) stellen ein Spinnennetz dar. Die fünf Argumente, die die Funktion SpiderNet beim Aufruf erhält, wollen wir hier nicht im Detail diskutieren. Für uns ist nur der zweite Parameter x/2 interessant. Er bestimmt den "Radius" des Spinnennetzes: plot(spidernet(, x/2,.9,.2,.4), Scaling = Constrained): y x Kehren wir wieder zu unserem ersten Beispiel zurück: Wir haben oben das Trisentis- Problem für x:= 4: y:= 4: gelöst. Um das Spinnennetz (oder ganz allgemein ein grafisches Objekt) in unserem Spiel korrekt mit Quadraten zu überdecken, müssen sowohl die Quadrate als auch das Spinnennetz im gleichen Bereich des Koordinatensystems liegen. Unsere Quadrate werden immer beginnend im Koordinatenursprung (mit Seitenlänge ) in den ersten Quadranten des Koordinatensystems gezeichnet und füllen somit ein Quadrat mit den Seitenlängen x = y aus. Im Fall x = y = 4 haben wir also (wenn wir zusätzlich ein Koordinatensystem zeichnen lassen, dass aber normalerweise immer ausgeblendet

23 wird) die folgende Situation: y Die Quadrate füllen genau den Bereich [, 4] x [, 4] des Koordinatensystems aus. Man kann also ein Bild nur dann sinnvoll in den Hintergrund legen, wenn es im gleichen Bereich des Koordinatensystems liegt, wie die Quadrate. Zur Darstellung benötigen wir eine erweiterte Version der Prozedur plotmatrix von oben. Als drittes Argument kann dieser neuen Version von plotmatrix entweder eine Farbe (z.b. die Farbe RGB::Green) oder auch ein grafisches Objekt (z.b. unser Spinnennetz) übergeben werden. Das grafische Objekt muß die in Relation zu x,y die richtige Größe haben und sich im ersten Quadranten im Bereich [,x] x [,y] befinden. plotmatrix:= proc(m, c, c) local i, j, c, dim, c2; local bg; begin dim:= linalg::matdim(m)[]; c:= Color=c, Filled=TRUE; c2:= Color=c, Filled=TRUE; if testtype(c, Type::ListOf(Type::Numeric,3)) then bg:= null(); else c2:= null(); bg:= c; end_if: plot( bg, (plot::rectangle2d([j-, i-],,, _if( iszero(m[i,j]), c, c2 )), plot::rectangle2d([j-, i-],,, Color = RGB::Black) ) $ i =..dim $ j =..dim, Axes = None, Scaling = Constrained, _if(args() = 5, args(4..args()), null()) ); end_proc: Wir erproben die neue Funktion an einem Beispiel der Zugmatrix zugdelta(,2). x

24 plotmatrix(zugdelta(,2), RGB::Blue, SpiderNet(, x/2,.9,.2,.4)): Geben wir statt des grafischen Objekts als drittes Argument die Farbe RGB::Green an, so erhalten wir ein Bild der Gestalt, wie wir es von vorher kennen, d.h. die aufgedeckten Felder werden wieder als grüne Felder dargestellt: plotmatrix(zugdelta(,2), RGB::Blue, RGB::Green): Als letzte MuPAD Prozedur geben wir noch die Prozedur Loesung an, die alle Schritte bei der Lösung des Trisentis-Problems visualisiert und anschließend diejenige Matrix ausgibt, an der man ablesen kann, welche Züge unternommen wurden. Sie erhält als Argumente die Dimensionen x und y des Spielfeldes sowie als drittes Argument ein entsprechend formatiertes und positioniertes Bild für den Hintergrund: Loesung:= proc(x, y, BG) local start, A, b, i, j, Zuege, L, Heading; begin start:= Mat(x,y); Heading:= Title = "Das zugedeckte Startfeld", TitlePosition = Above;

25 plotmatrix(start, RGB::Blue, RGB::Green, Heading); A:= linalg::concatmatrix( Mat([op(zugdelta(i,j))]) $ i =..x $ j =..y ); b:= Dom::SparseMatrix(Dom::IntegerMod(2))([ $ x*y]); L:= linalg::matlinsolve(a, b); if L = [] then print(unquoted, "Für x = ".x." und y = ".y." gibt es keine Lösung"); return(); elif domtype(l) = Mat then Zuege:= Vector2Matrix(L); else Zuege:= Vector2Matrix(L[]); end_if; for i from to x do for j from to y do if not iszero(zuege[x-i+,j]) then start:= start + zugdelta(x-i+,j); Heading:= Title = "Gewählt wurde das Feld (".i.",".j. ")", TitlePosition = Above; plotmatrix(start, RGB::Blue, BG, Heading); end_if; end_for; end_for; Heading:= Title = "Die Lösungsmatrix", TitlePosition = Above; plotmatrix(zuege, RGB::Blue, RGB::Green, Heading); end_proc: Damit können wir die oben per Hand durchgeführte Lösung des Trisentis-Problems für x = y = 4 nun automatisch ausgeben lassen: Loesung(x, y, SpiderNet(, x/2,.9,.2,.4)): Das zugedeckte Startfeld

26 Gewählt wurde das Feld (,) Gewählt wurde das Feld (,3) Gewählt wurde das Feld (2,2)

27 Gewählt wurde das Feld (3,2) Gewählt wurde das Feld (4,) Gewählt wurde das Feld (4,3)

28 Die Lösungsmatrix Die Sequenz der Bilder stellt nun den Verlauf des Spiels bis zu seiner Lösung dar. Die letzte Matrix codiert die durchgeführten Spielzüge (wie wir es schon oben gesehen hatten). Die Positionen der grünen Felder markieren genau diejenigen Felder, die bei den Zügen bis zur Lösung gewählt wurden.