Das Lösen  von Gleichungen, Teil 1

Bem.: 
Da Gleichungen (und Ungleichungen sowie Gleichungssysteme)
sehr häufig auftreten, ist dieses notebook von zentraler Bedeutung.
  
Hinweis:
Ab Version 8 hat der output von Solve eine andere Struktur.
Eine mehrfache Nullstelle wird nur noch einmal aufgelistet.
Bei mehreren Nullstellen hat sich u.U. die Reihenfolge geändert
(dies ist zu beachten, wenn man beider Diskussion der Lösung 
 sich auf die 1., 2., 3. etc Nullstelle beziehen möchte).

Zusammenfassung: Gleichungen

Linke und rechte Seite der Gleichung werden durch den Vergleichsoperator   ==  verknüpft. 
Zur Lösung stellt Mathematica die Befehle    Solve  ,  NSolve   und  FindRoot   zur Verfügung.

Solve       löst die Gleichung exakt (sofern möglich).

NSolve    löst die Gleichung mit numerischen Methoden und liefert numerische Werte. 

N [ Solve [...]  ] liefert numerische Werte der exakten Lösung.   
Alternative:  auf das Ergebnis von Solve     //N   anwenden.
Die Anzahl der Stellen kann angegeben werden, z.B.  30 :   NSolve[....., 30]

Reduce bringt die Lösungsmenge (also alle Lösungen) in den Fällen, in denen Solve 
nur eine (typische) Lösung (von unendlich vielen) bringt (“warning: some solutions may not be found”).
Allerdings wurde das Spektrum der Gleichungen, die Solve lösen kann, erweitert: die Lösungsmenge
wird dann mit  ConditionalExpression  ausgedrückt.

Reduce bringt auch bei Ungleichungen die Lösungsmenge.

Solve löst auch einige Ungleichungen, aber Reduce bleibt Methode der Wahl.

Viele Gleichungen können nicht exakt gelöst werden. Dann sind numerische Näherungsverfahren erforderlich. Eines dieser Verfahren ist das Neweton-Verfahren. Mathematica stellt dieses Verfahren im Befehl  

FindRoot    zur Verfügung. Wie bei jedem numerischen Verfahren wird ein Startwert  x0  benötigt.
Die Genauigkeit lässt sich einstellen:  FindRoot[ gleichung, { x , x0 } ,  WorkingPrecision -> 30] 

Beachten Sie die Hinweise, welche das System ausgibt ! 

Bspl.:  Nullstellen einer Funktion

           f[x_]  :=   x^4 + 2x -5
                gl   =   f[x] = = 0 
                ls   =   Solve[gl, x]
                ls // N

Bspl. 1:

Remove["Global`*"]

(* Aufstellen der Gl.:*)    x^2 + x == 0

(* Beachten Sie das doppelte Gleichheitszeichen,
  das für den Vergleichsoperator steht - so wie in der Programmiersprache  C  !! 
 Es wird die linke Seite der Gleichung mit der rechten verglichen. *)

(* Es ist sinnvoll, diese Gl. auf einer Variablen zu speichern, 
   mit anderen Worten: diese Gl. wird einer Variablen zugewiesen: *)

gl = x^2 + x == 0

(* beachten Sie den Unterschied  zwischen ZUWEISUNG  und  VERGLEICH  !! *)

(* Die Variable  x  darf noch keinen Wert haben, sonst  : *)

x=5

gl= x^2 + x == 0

Clear[x]

(* nochmal die Gl. definieren: *)

gl= x^2 + x == 0

(* Lösen, mit Angabe der gesuchten Variablen*)   

Solve[gl,x]

Das Ergebnis liegt in der für Mathematica typischen Listen-Notation vor;
wir werden die Weiterverarbeitung dieser Liste in einem weiteren  
Notebook noch genauer untersuchen;

Das Ergebnis kann gar nicht in Form einer Zuweisung geschehen: die zweite Zuweisung 
würde die erste überschreiben;  
Mathematica müßte die Lösungen also durchnummerieren -  
und dann ist obige Schreibweise eleganter und einfacher zu erweitern, 
z.B. bei komplizierteren Lösungsmengen.

(* sehr sinnvoll ist das Speichern des Ergebnisses:*)  

 ls =Solve[gl,x]

(* Kontrolle durch eine Grafik: *)

linkeS=gl[[1]]  (* die linke Seite der Gleichung; Erläuterung zu  [[1]]  später in einf08a *)

Plot[linkeS, {x,-2,2}]

Plot[Evaluate[gl[[1]]], {x,-2,2}]     (* ohne die Hilfsvariable muss gl[[1]] im Plot erst ausgewertet werden *)

(* Hinweis: 
   Mathematica V10 akzeptiert NICHT MEHR die GLEICHUNG als Argument für den Befehl Plot. Das ist auch GUT so! *)

Plot[gl, {x,-2,2}]

Zum Lösungsverfahren für eine Gleichung gehört auch geeignete nicht-graphische Proben.
Dies wird in einem späteren notebook untersucht.

Weitere Beispiele

(* 2. ein lineares Gleichungssystem: *)

gl1= x + y == 1;
gl2 = x - y == 2;

(* die beiden Gl. werden in einer Liste zusammengefasst: *)

ls=Solve[{ gl1,gl2 },{x,y}]

(* 3. ein weiteres lineares System *)

gl1= x + y == u
gl2 = x - y == v

(* die beiden Gl. werden vorher in einer Liste zusammengefasst: *)

gls = {gl1,gl2}

Solve[gls,{x,y}]

(* 4. ein NICHTlineares Gleichungssystem: *)

Clear[x,y]    (* nur zur Vorsicht, hier nicht erforderlich *)

gl1= x^2 + y == 1
gl2 = x - y == 2

ls=Solve[{gl1,gl2},{x,y}]

(* Vergleichen Sie die Struktur der Lösungsmenge mit der aus Bspl. 2 !! *)

(* 5. eine algebraische Gleichung höherer
     Ordnung *)

gl = x^4 + x^3 + x^2 + x + 1==0

ls=Solve[gl,x]

(* Mathematica verwendet eine unglückliche Notation: 
 komplexe Wurzeln sind eigentlich mehrdeutig !! 
Die interne Verarbeitung ist aber in sich konsistent.

Numerische Werte: 
*)

ls//N

(* die Werte sind beliebig genau vorhanden: *)

N[ls,20]

(* Man kann, wenn man nur an den Zahlenwerten interesiert ist,  
   auch direkt den Befehl  NSolve  verwenden  
*)

ls=NSolve[gl,x]

(* geht es genauer ? *)

N[ls,20]

(* wenn man es genauer will, 
   muß man diese Anforderung bereits dem Befehl mitgeben: 
*)

ls=NSolve[gl,x,20]

(* 6. die folgende algebraische Gleichung
     kann Solve nicht mehr symbolisch 
     lösen: *)

gl =x^5+ x^4 + x^3 + x^2 + x + 3==0

ls=Solve[gl,x]

(* es wurde aber ein NUMERISCHES Ergebnis ermittelt *)

ls//N

(*  NSolve liefert direkt ein numerisches Ergebnis*)

ls=NSolve[gl,x]

(* 7. eine nicht-
     algebraische (sog. transzendente) Gleichung 
*)

gl = x/2 - Sin[x] ==0

ls=Solve[gl,x]

(* Mathematica findet keine Lösung; eine exakte Lösung ist 0, 
   die aber auch nicht angezeigt wird; auch NSolve geht nicht: 
*)

ls=NSolve[gl,x]

(* die Grafik zeigt drei Lösungen, 
   nämlich die Nullstellen der Differenz-Funktion y = x/2 - sin(x)  
*)

Plot[x/2-Sin[x],{x,-Pi,Pi}]

(* die Lösungen sind natürlich zugleich die Schnittpunkte 
 der beiden Funktionen y = x/2  und y = sin(x) ; 
   wir lassen beide Funktionen plotten:  
*)

Plot[ {  x/2 , Sin[x]} ,{x,-Pi,Pi}]

(* jetzt kann man den Befehl FindRoot versuchen; 
   hier führt Mathematica ein numerisches Verfahren durch, nämlich das sog. Newton-Verfahren, 
   um eine Lösung zu finden; allerdings muß man einen Startwert vorgeben; 
   ob eine Lösung gefunden werden kann und wie gut diese Lösung ist, 
   hängt auch ganz wesentlich von diesem Startwert ab; 
   wir lassen uns von der Grafik leiten: *)

ls = FindRoot[gl,{x,0}]

ls = FindRoot[gl,{x,1}]

ls = FindRoot[gl,{x,2}]

ls = FindRoot[gl,{x,-2}]

N[ls,20]

(* wenn man es genauer will, muß man diese Anforderung dem Befehl mitgeben: *)

ls = FindRoot[gl,{x,-2}, WorkingPrecision->24]

(* wenn man die Anzahl der Iterationen zu stark begrenzt: *)

ls = FindRoot[gl,{x,2},MaxIterations->3]

ls = FindRoot[gl,{x,2},MaxIterations->4]

(* ein schlechter Startpunkt: *)

ls = FindRoot[gl,{x,10}]

(* 8. einige andere nicht-algebraische Gl. *)

(* a *)

Solve[Sin[x]==1/2,x]

(* Mathematica V10 beschreibt die Lösungsmenge über ConditionalExpression;     
 Alternative: *)

Reduce[Sin[x]==1/2,x]

(* So muss man dieses Ergebnis lesen: 
 ∈  ist das Element-Symbol;  
   C[1] ist also ein Element der Menge der ganzen Zahlen.
 && ist der logische Operator  UND .
  || ist der logische Operator  ODER. 
*)

(* b *)

Solve[Exp[x]==0.5,x]

(* Mathematica versucht eine exakte Lösung mit Hilfe der Umkehrfunktion; 
   wenn die Funktion nur abschnittsweise umkehrbar ist, können Lösungen verloren gehen; im obigen Beispiel ist die Umkehrung der Funktion im KOMPLEXEN mehrdeutig.
   die volle Information, also die Lösungsmenge: 
*)

Reduce[Exp[x]==0.5,x]

(* c *)

gl = Exp[x]==2+x

ls=Solve[gl]

(* das Ergebnis enthält hier eine der zahlreichen eingebauten speziellen Funktionen,
   nämlich ProductLog; wir lassen uns ganz pragmatisch die numerischen Werte anzeigen: 
*)

%//N

(* Kontrolle durch eine Grafik: *)

Plot[ { Exp[x],2+ x}, {x,-4,2}]

(* es soll auch noch der empfohlene Befehl Reduce benutzt werden: *)

Reduce[gl]

(* demnach gäbe es noch weitere Lösungen; 
   diese können aber nach den vorstehenden Überlegungen nicht reell sein
*)

-2-ProductLog[2,-(1/(E^2))]//N

-2-ProductLog[-2,-(1/(E^2))]//N

Dieses notebook hat Ihnen gezeigt, wie man in Mathematica Gleichungen löst. Man muß die Ergebnisse kritisch würdigen, insbesondere wenn die Lösung auf rein numerischem Weg über FindRoot ermittelt wurde.

Aufgaben

1)
Lösen Sie die folgenden Gleichungen. Führen Sie eine Probe durch eine geeignete Grafik durch.

a)  (x^3) + x + 1 = 0   
b) (x^5) - 10(x^2) + 1 = 0
c) (e^(-(x^2))) - x = 0 
d) cos(3x) + ln(x) = 0 
e) x - 2y = 2  ;   2x + y = 3

2)
Gleichungen treten oft im Zusammenhang mit Funktionen auf, z.B.: "ermitteln Sie für f(x) = (x^3) - x   die Nullstellen". Definieren Sie zunächst eine Funktion und machen Sie dann von dieser Definition Gebrauch. Führen Sie eine Probe durch eine geeignete Grafik durch.

Lösungen

1)

(* a *)

gl = x^3 + x + 1 ==0

ls=Solve[gl,x]

ls//N

Plot[x^3 + x + 1,{x,-2,2}]

(* man sieht im (reellen) Plot auch nur die reelle Lösung *)

(* b *)

gl = x^5 - 10x^2 + 1 ==0

ls=Solve[gl,x]

ls//N

Plot[x^5 -10 x^2 + 1,{x,-3,3}]

(* genauer um Null: *)

Plot[x^5 -10 x^2 + 1,{x,-1,1}]

(* c *)

gl = Exp[-x^2] - x ==0

ls=Solve[gl,x]

ls//N

Plot[Exp[-x^2] - x,{x,-3,3}]

(* der obige Plot der Differenzfkt zeigt gut die Lage der Nullstelle; 
   der folgende Plot der Einzelfunktionen zeigt besser,  
   dass es nur eine Nullstelle gibt *)

Plot[{Exp[-x^2], x},{x,-3,3}]

(* d *)

gl =Cos[ 3x] +Log[x] ==0

ls=Solve[gl,x]

(* aus der Zeichnung entnehmen wir, wo die Nullstelle(n) in etwa liegen : *)

Plot[Cos[3x] +Log[x],{x,0,4}]

xstart = 1.4

ls=FindRoot[gl,{x,xstart}]

ls = FindRoot[gl,{x,xstart}, WorkingPrecision->24]

(* Achtung: das Ergebnis hängt hier sehr stark von der Wahl des Startwertes ab *)

(* e *)

gl1= x-2y==2

gl2=2x+y==3

gls= {gl1,gl2}

ls=Solve[gls,{x,y}]

(* Probe: die Lösung kann als Schnittpunkt der durch die beiden Gleichungen
 definierten Geraden interpretiert werden; 
   Ermitteln der Geradengl. in der Form  y = ..., 
   also EXPLIZITE Darstellung der Funktion :  
*)

Solve[gl1,y]

Solve[gl2,y]

(* Übernahme der Geradendef. einfach durch durch Copy & Paste - 
  ohne können wir es noch nicht !
*)

Plot[{(1/2) (-2+x),3-2 x},{x,0,2}]

(* ohne die Gleichungen vorher aufzulösen, 
   also unter Verwendung der IMPLIZITEN Funktionsdefinition:
*)

ContourPlot[{x-2y==2,2x+y==3},{x, 0,2},{y,-1,2},Axes->True,Frame->False]

(* Bem.:
   Der Befehl  Plot  kann man mit ZWEI Variablen nicht funktionieren.
 Man könnte jetzt den analogen Befehl  Plot3D  nehmen. Die Bilder sind aber 
  nicht so anschaulich.
*)

2)

f[x_]:= x^3 - x

ls=Solve[f[x]==0,x]

Plot[f[x],{x,-2,2}]