NDSolve gibt eine falsche Lösung

Question

Betrachten Sie die ODE $$\frac{y'y}{1+\frac{1}{2} \sqrt{1+ y'^2}}=-x.$$

Verwenden von

NDSolve[{-x==y'[x] y[x]/(1+Sqrt[1+(y'[x])^2]/2), y[0] ==3}, y, {x,-7,7}]

und das Zeichnen führt zu den beiden Lösungen (einige Warnungen in der Nähe der Grenzen)

$$y(x) = \sqrt{6^2 - x^2} - 3$$ und $$y(x) = \sqrt{2^2 - x^2} + 1.$$

Aber nur letzteres ist eine gültige Lösung! Egal welche 'Methode' ich ausprobiert habe, ich habe immer eine völlig falsche Lösung gefunden. Außer mit

Method -> {"EquationSimplification" -> "Residual"}

Warum das?

Hinweis: Wie in der folgenden Antwort ausgeführt, ist das Festlegen des Werts in x=0seitdem von entscheidender Bedeutung$y'$verschwindet hier. Die Verwendung anderer Startwerte wie y[Sqrt[3]]=2des Problems wird jedoch noch schlimmer, da ein Zweig jetzt überall völlig falsch ist und der andere Zweig nur in einem kleinen Bereich korrekt ist.

Answer 1

Der Grund für dieses Verhalten scheint ein großer logischer Fehler zu sein NDSolve. Während der Berechnung scheint es Ausdrücke wie: y==Sqrt[x]und y^2==xals gleich zu behandeln . Aber wie jeder Benutzer hier weiß, sind sie es nicht!

Nehmen Sie zur Bestätigung Ihr spezielles Beispiel: Multiplizieren mit dem Nenner ergibt $$-x\left(1-\frac{1}{2} \sqrt{1+(y'(x))^2}\right)=y'(x) y(x).$$ Beide Seiten dumm quadrieren und nach lösen $y'(x)$ erstellt zwei Zweige

NDSolve[{y'[x]==(4 x y[x]+Sqrt[3 x^4 + 4 x^2 y[x]^2])/(x^2 - 4 y[x]^2) , y[0]==3}, y, {x,-6,6}]

und

NDSolve[{y'[x]==(4 x y[x]-Sqrt[3 x^4 + 4 x^2 y[x]^2])/(x^2 - 4 y[x]^2) , y[0]==3}, y, {x,-6,6}]

Dies sind in der Tat genau die Zweige, NDSolvedie zur Verfügung gestellt werden, obwohl keine gültig ist.

Schlimmer noch, obwohl es grundlegend ist, werden die Lösungen nicht überprüft. Dies würde nur eine zusätzliche Codezeile im Algorithmus erfordern, da er bereits die Tupel verwendet$(x_i,y(x_i),y'(x_i)$. Stecken Sie sie einfach in die Gleichung und prüfen Sie, ob sie wahr oder falsch ist (bis zu einem numerischen Fehler).

Bearbeiten: NDSolve muss die Gleichung in eine Standardform umwandeln, die von gesteuert wird EquationSimplification. Für diese Methode gibt es drei mögliche Optionen : MassMatrix, Residualund Solvedies ist die Standardeinstellung. Letzteres wandelt die Gleichung in eine Form ohne Ableitungen auf einer Seite um. Das System wird dann mit einem gewöhnlichen Differentialgleichungslöser gelöst . Wenn diese ResidualOption ausgewählt ist, werden alle Nicht-Null-Terme in der Gleichung einfach zur Seite verschoben und dann mit einem Differentialalgebraischen Gleichungslöser gelöst . Dies ist der Grund, warum das Ergebnis in diesem Fall korrekt ist, da es nicht verwendet wird, Solvewas hier fehlerhaft ist.

Answer 2

Das allgemeine Problem

Bei NDSolveder Lösung von IVPs erster Ordnung gibt es grundsätzlich zwei Möglichkeiten, die ODE einzurichten:

y'[x] == f[x, y[x]]     (* explicit form *)
F[x, y[x], y'[x]] == 0  (* implicit form *)

Bei den meisten numerischen Lösern muss das Problem explizit angegeben werden. In Mathematica gibt es nur einen Löser, der mit der impliziten Form IDA arbeitet , und er ist auf die Maschinengenauigkeit beschränkt. Da es einfach ist, die implizite Form durch Differenzieren in eine explizite ODE zweiter Ordnung umzuwandeln x, bestand möglicherweise nicht viel Druck, Löser impliziter Form zu entwickeln.

In Mathematica können Sie anfordern, dass eine Lösung in beiden Formen mit der folgenden MethodOption versucht wird :

Method -> {"EquationSimplification" -> "Solve"}    (* explicit *)
Method -> {"EquationSimplification" -> "Residual"} (* implicit *)

Mit dem "Solve"Verfahren, das der Standard ist, NDSolveruft Solveeine ODE in der expliziten Form zu konvertieren. Eine in impliziter Form angegebene Gleichung kann mehrere Lösungen haben und NDSolvewird in jedem Fall separat integriert. Das passiert im Beispiel des OP. Darüber hinaus NDSolveist es so eingerichtet, dass die separaten ODEs in expliziter Form unabhängig voneinander integriert werden und nicht kombiniert werden können, was im Fall des OP erforderlich ist (siehe Antwort von @ BobHanlon ).

Jetzt Solveist Frage des Genericity spielt hier eine wichtige Rolle. Im Fall des OP werden Lösungen zurückgegeben, die jeweils für bestimmte Domänen gültig und in anderen nicht leeren Regionen ungültig sind, einschließlich solcher, über die wir integrieren möchten. Reduceist viel vorsichtiger und analysiert das OP-System korrekt. Man kann macht den SolveEinsatz Reducemit der Option Method -> Reduce, aber es gibt immer noch zwei getrennte Lösungen, die jeweils gültige eine Seite x == 0. Weiterhin kehrt es zurück ConditionalExpression, was NDSolveerstickt (und NDSolve::ndnumim Anfangszustand während der ProcessEquationsPhase einen "nicht numerischen" Fehler ergibt ). ConditionalExpressionwurde ziemlich spät in V8 eingeführt, und möglicherweise wurden nicht genügend Anfragen an die NDSolveWRI gestellt, um damit richtig umgehen zu können.

OTOH, die "Residual"Methode löst die ODE implizit bei jedem Schritt. Da beide Lösungen nur bei gleichzeitig gültig sind x == 0, NDSolvefindet sie in einem Schritt den richtigen Zweig . Dies berechnet die richtige Lösung, die das OP erwähnt. Der einzige Nachteil ist, dass nur eine Integrationsmethode verfügbar ist und nur in Maschinengenauigkeit.

Es scheint in der NDSolve`ProcessEquationsPhase leicht zu sein, zu überprüfen, ob die ursprüngliche implizite ODE durch die expliziten Formulare in der Anfangsbedingung erfüllt ist. Das würde das Problem im Beispiel bei nicht abfangen. y[0] == 3An diesem Punkt erfüllen beide expliziten Formen die ODE für implizite Form, aber es würde das Problem bei abfangen y[1] == 2. Ein weiteres Problem bei den von zurückgegebenen Lösungen Solvebesteht darin, dass die explizite Formel für die y'[x]Notwendigkeit besteht, Zweige auf die andere Lösung umzuschalten, die Solvebei der Integration zurückgegeben wird x == 0. Das Wechseln von Zweigen ist weder NDSolveeine Aufgabe, noch scheint es mir eine einfache Programmierkorrektur zu sein, da jede Lösung unabhängig integriert ist. Einige Möglichkeiten, dies zu tun, sind unten angegeben, aber alle erfordern, dass der Benutzer den NDSolveAnruf vorbereitet . Keine werden automatisch von durchgeführt NDSolve, was wünschenswert wäre.

Was sollte der Benutzer schließlich erwarten? In der wissenschaftlichen Berechnung wird seit langem erwartet, dass der Benutzer die numerische Integration von Differentialgleichungen einrichtet. Dies scheint bei MATLAB und NumPy immer noch der Fall zu sein. Ich kenne Maple nicht gut genug, um einen Kommentar abzugeben. Die allgemeine Philosophie von Mathematica war es, alles so automatisch wie möglich zu machen. Mathematica tendierte auch dazu, generisch wahre Lösungen anstelle einer strengeren Einschränkung zu verwenden. Diese stehen hier in einem gewissen Konflikt, da die generischen Methoden Solveeine Ursache für das Problem mit den NDSolveLösungen sind. Auf der anderen Seite ist es weniger ein Wolfram-Ziel als vielmehr ein Leitprinzip, alles automatisch sein zu lassen. Die Fragen und Antworten auf dieser Website zeigen, dass Automaticdie Arbeit nicht immer erledigt wird. Der Benutzer muss häufig das Problem verstehen, wissen, welche Löser verfügbar sind, die Eingabe entsprechend vorbereiten und den Löser mit den richtigen Optionen aufrufen. Bei einem IVP mit impliziter Form sollte der Benutzer wissen, dass bei der Lösung ein Problem auftreten kann y'[x]. Sie sollten sich auch darüber im Klaren sein, dass es Standardmethoden für den Umgang mit ODEs impliziter Form gibt:

• Verwenden eines impliziten Lösers wie IDA, der beim "Residual"Aufrufen aufgerufen wird;
• Differenzieren, um die Ordnung zu erhöhen;
• y'[x]explizit nach der Standardmethode lösen "Solve".

Ich werde wiederholen, dass ich denke, dass es vernünftig ist zu erwarten NDSolve, dass überprüft wird, ob eine explizite Form die ursprüngliche ODE der impliziten Form unter der Anfangsbedingung erfüllt. Während der Benutzer die Ergebnisse NDSolvenachträglich überprüfen kann , würde dies in Fällen wie dem IVP y[1] == 2eine fremde Integration verhindern.

Die Beispiele des OP

Die expliziten Lösungen, die y'[x]wir für die ODE des OP erhalten, haben zwei Zweige für x < 0und zwei für x > 0. Die beiden Lösungen ergeben sich aus der (algebraischen) Rationalisierung der ODE, die die Möglichkeit von Fremdlösungen einführt. Tatsächlich besteht der Lösungssatz aus vier verbundenen Komponenten, zwei für das Intervall x < 0und zwei für x > 0. Jede von zurückgegebene Lösung Solveist über ein Intervall gültig, jedoch nicht über beide. Wir können sie jedoch durch in eine richtige und eine falsche Lösung umwandeln Simplify[..., x > 0], aber das ist meiner Meinung nach kaum eine allgemeine Technik.

Problemumgehung Nr. 1

Die Entdeckung des OP:

ode = -x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2);

ListLinePlot[
 NDSolveValue[{ode, y[0] == 3}, y, {x, -7, 7}, 
  Method -> {"EquationSimplification" -> "Residual"}],
 PlotRange -> All
 ]

Problemumgehung Nr. 2

Die Differenzierung der ODE erhöht die Reihenfolge, führt jedoch zu einer, für die es eine eindeutige explizite Form gibt. Sie müssen die ODE verwenden, um die Anfangsbedingung für zu lösen y'[0].

sol = NDSolve[{D[ode, x], y[0] == 3, y'[0] == 0}, y, {x, -7, 7}]

Problemumgehung Nr. 3

Verwenden Sie die richtige explizite Form , die aus den richtigen Zweigen aufgebaut ist für x <> 0:

ode2 = y'[x] == 
   Piecewise[{
    {(4 x y[x] - Sqrt[3 x^4 + 4 x^2 y[x]^2])/(x^2 - 4 y[x]^2), x < 0}}, 
    (4 x y[x] + Sqrt[3 x^4 + 4 x^2 y[x]^2])/(x^2 - 4 y[x]^2)];

sol = NDSolve[{ode2, y[0] == 3}, y, {x, -7, 7}]

Problemumgehung Nr. 4

Es gibt Probleme mit unserer algebraischen Notation und ihrer Beziehung zu algebraischen Funktionen. Durch Anwenden der Annahme wird x > 0 die Auswahl der Verzweigungsschnitte geändert, wenn die zurückgegebenen Lösungen Solveso vereinfacht werden , dass eine davon korrekt ist. Mit anderen Worten, dies ergibt eine einfachere Formel y'[x], die der Problemumgehung Nr. 3 entspricht.

sol = NDSolve[{#, y[0] == 3} /. Rule -> Equal, y, {x, -7, 7}] & /@
  Assuming[x > 0,
   Select[Simplify@Solve[ode, y'[x]], 
    ode /. # /. {y[x] -> 1, x -> 1.`20} &]
   ] // Apply[Join]

Problemumgehung Nr. 5

Die SolveOption Method -> Reduceerzeugt korrekte Lösungen in Form von a ConditionalExpression. Um eine Methode zu erhalten, die den richtigen Zweig einer ODE überprüft und auswählt, der implizit definiert y'[x], müsste der Benutzer seine eigene Vorverarbeitung durchführen. Im Folgenden wird rhs[]der Zweig ausgewählt, der die ursprüngliche ODE erfüllt, indem die bedingten Ausdrücke in eine einzelne PiecewiseFunktion konvertiert werden. Die Bedingungen werden von Gleichungen a == bin einen Vergleich umgewandelt Abs[a-b] < 10^-8. Ich musste den Wert am Verzweigungspunkt x == 0manuell hinzufügen .

Mit anderen Worten, dies prüft y'[x]bei jedem Schritt und wählt den richtigen Zweig für den Schritt aus. Es wechselt daher automatisch die Zweige, wenn dies x == 0im OP-Problem erforderlich ist . Es ist darauf hinzuweisen, dass dies ein Problem behebt, das sich aus der Rationalisierung der ODE ergibt, die fremde Zweige einführt. Es ist möglich, dass eine ODE mit impliziter Form mehrere gültige Zweige hat. Die folgende Methode kombiniert sie alle (wenn die Lösungen die ConditionalExpressionForm haben), was als Fehler angesehen werden sollte, obwohl möglicherweise immer noch versehentlich eine korrekte Lösung erstellt wird. Für die ODE des OP macht es das Richtige.

ClearAll[rhs];
rhs[x_?NumericQ, y_?NumericQ] = Piecewise[
   yp /. Solve[ode /. {y[x] -> y, y'[x] -> yp}, yp, 
       Method -> Reduce] /. ConditionalExpression -> List /. 
    Equal -> (Abs[#1 - #2] < 10^-8 &),
   0 (* y'[0] == 0 *)];

sol = NDSolve[{y'[x] == rhs[x, y[x]], y[0] == 3}, y, {x, -7, 7}]

Hier ist eine sehr hackige Methode, um das Ergebnis des internen SolveErgebnisses zu korrigieren . Es wird durch eine Sequenz von viralen erreicht UpValuesfür , $tagdass eine neu schreibt ConditionalExpressionLösung in eine PiecewiseLösung wie die oben.

opts = Options@Solve;
SetOptions[Solve, Method -> Reduce];
Block[{ConditionalExpression = $tag, $tag},
 $tag /: Rule[v_, $tag[a_, b_]] := $tag[v, a, b];
 $tag /: {$tag[v_, a_, b_]} := $tag[List, v, a, b];
 $tag /: call : {$tag[List, v_, __] ..} := {{v -> 
     Piecewise[
      Unevaluated[call][[All, -2 ;;]] /. $tag -> List /. 
       Equal -> (Abs[#1 - #2] < 1*^-8 &)]}};
 sol = NDSolve[{ode, y[0] == 3}, y, {x, -7, 7}]
 ]
SetOptions[Solve, opts];

Wie man sieht, was Solvedrinnen passiertNDSolve

Wenn Sie sehen möchten, was intern passiert, können Sie verwenden Trace. NDSolveverwendet Solve, um die ODE für die Ableitung höchster Ordnung zu lösen, wenn dies möglich ist, und verwendet die Lösung (en), um das Integral (die Integrale) zu konstruieren. Dies zeigt den SolveAufruf und seinen Rückgabewert:

Trace[
 NDSolve[
  {ode, y[0] == 3},
  y, {x, -7, 7}],
 _Solve,
 TraceForward -> True,
 TraceInternal -> True
 ]

Answer 3

Clear["Global`*"]

sol = DSolve[{-x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2), y[0] == 3}, y, 
   x] // Quiet

(* {{y -> Function[{x}, Sqrt[5 - x^2 + 2 Sqrt[4 - x^2]]]}, 
    {y -> Function[{x}, Sqrt[45 - x^2 - 6 Sqrt[36 - x^2]]]}} *)

FunctionDomain[y[x] /. sol[[1]], x]

(* -2 <= x <= 2 *)

Die erste Lösung gilt für -2 <= x <= 2

{-x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2), y[0] == 3} /. sol[[1]] // 
 Simplify[#, -2 <= x <= 2] &

(* {True, True} *)

FunctionDomain[y[x] /. sol[[2]], x]

(* -6 <= x <= 6 *)

Die zweite Lösung gilt für x == 0

{-x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2), y[0] == 3} /. sol[[2]] // 
 FullSimplify[#, -6 <= x <= 6] &

(* {x == 0, True} *)

Plot[Evaluate[y[x] /. sol], {x, -6, 6},
 PlotLegends -> Placed[Automatic, {.75, .2}]]

Beschränken Sie für die numerische Lösung die Domäne auf {- 2, 2}

soln = NDSolve[{-x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2), y[0] == 3}, 
    y, {x, -2, 2}] // Quiet;

Die numerischen Lösungen sind in verschiedenen Bereichen der Domäne gültig

Plot[Evaluate[y[x] /. soln], {x, -2, 2},
 PlotRange -> {0, 3.1},
 PlotLegends -> Placed[Automatic, {.7, .5}]]

Answer 4

Anfangen bei

Plot[Evaluate[y[x] /. sol], {x, -2, 2}, 
 PlotLegends -> Placed[Automatic, {.75, .2}], PlotPoints -> 1600, 
 ImageSize -> Large, PlotRange -> Full]

Was ist in der Differentialgleichung?

$$\frac{𝑦′𝑦}{1+\sqrt{1+𝑦′^2}}=−𝑥$$

1. Dies ist eine Differentialgleichung vom impliziten Typ.

2. Es ist eine Differentialgleichung erster Ordnung ${y,y'}$.

3. Es ist eine nichtlineare Differentialgleichung.

4. Es wird in Form eines Quotienten angegeben, daher muss nach Singularitäten des Nenners gesucht werden.

5. Es gibt eine Auswahl des Vorzeichens der Wurzel zweiten Grades im Nenner, die behandelt werden muss. Der Nenner kann nicht real Null sein$x$ und $y'$ solange die gegebene Auswahl des Vorzeichens der Wurzel getroffen wird.

6. Es gibt eine Form der gegebenen Differentialgleichung, wobei $f(x,y,y')==0$::

   y '[x] == Stückweise [{{(4 xy [x] - Sqrt [3 x ^ 4 + 4 x ^ 2 y [x] ^ 2]) / (x ^ 2 - 4 y [x] ^ 2 ), x <0}}, (4 xy [x] + Sqrt [3 x ^ 4 + 4 x ^ 2 y [x] ^ 2]) / (x ^ 2 - 4 y [x] ^ 2)]

Damit wissen wir verschiedene Fakten darüber, was Mathematica für uns tun kann!

A. Lösung ist möglich mit DSolve! DSolve löst eine Differentialgleichung für die Funktion u mit unabhängiger Variable $x$ zum $x$zwischen Subscript[x, min]und Subscript[x, max]. B. Wir brauchen NDSolve überhaupt nicht. Da die funktionale Abhängigkeit in dem gegebenen Intervall konstant und differenzierbar ist, hat die Lösung diese Eigenschaften auch im Intervall.

Aus der Frage ergibt sich ein Problem für die richtige Lösung. Was sind$x_min$ und $x_max$?

Aus der Lösung von DSolve:

sol = DSolve[{-x == y'[x] y[x]/(1 + Sqrt[1 + (y'[x])^2]/2), 
   y[0] == 3}, y, x]

( {{y -> Funktion [{x}, Sqrt [5 - x ^ 2 + 2 Sqrt [4 - x ^ 2]]]}, {y -> Funktion [{x}, Sqrt [45 - x ^ 2 - 6 Sqrt [36 - x ^ 2]]]}} )

Wir erhalten die Information, dass die Lösungen nicht auf eine Lösungsdomäne beschränkt sind. Mit der ursprünglichen Differentialgleichung als Eingabe erhalten wir die Informationen, DSolvedie die in Mathematica integrierte Methodik zur Berechnung einer Umkehrfunktion der Differentialgleichung aufrufen. Deshalb ruft es auf Reduce. Die Ausgabe enthält keine der Ergebnisse von Reduce.

Hierbei handelt es sich um eine Nachricht, die generiert wird, um weitere Nachrichten wie zuvor im Zwischennachrichtenausgabe-Cue zu stoppen. Endlich findet es die "Problemumgehung" # 3 von @ michael-e2, aber das ist ein eingebauter Prozess und keine "Problemumgehung", sonst wäre der Lösungssatz leer.

Was die Lösung für eine Domain einschränkt, ist die Auswahl, die @ bob-hanlon mithilfe von anzeigtFunctionDomain . FunctionDomainbeschränkt sich auf Reals. Das ist in der Frage nicht gegeben. Und NDSolve würde die Lösungsmethoden nicht auf beschränken Reals. Wie mein Einführungsbild zeigt, gibt es kein Problem mit der ersten Lösung.

Wir brauchen einige geometrische Überlegungen. Die gegebene Differentialgleichung, eine nichtlineare, beschreibt Verschiebungsellipsen und nur deren Grenze. Die von @ bob-hanlon außerhalb der Beschränkung auf das RealsErscheinen angezeigten Zweige sind also nicht mehr korrekt. Ellipsen sind nicht unendlich lang.

Die Lösung muss weiter behandelt werden, bis eine Bewertung sinnvoll ist. Die Anforderung der Mathematik besteht darin, die Wurzeln der Beschreibung zu entfernen. Wir wollen keine Inversion für$x(y)$. In der Mathematik gibt es viele Beschreibungen für Ellipsen.

Die Lösungen:

GraphicsGrid[{{Graphics[Circle[{0, 0}, {2, 3}], Axes -> True, 
    PlotRange -> {{-6, 6}, {-3.1, 3.1}}], 
   Graphics[Circle[{0, 0}, {5.2, 3}], Axes -> True, 
    PlotRange -> {{-6, 6}, {-3.1, 3.1}}]}}]

Warum haben wir das? OK. Dies liegt an der Nichtlinearität der Differentialgleichung und der Differentialgleichung selbst Reals.$x(0)==3$behebt die Auslassungspunkte vollständig. Es ist nur ein Parameter frei zu lösen. Mathematica berechnet es mit Reduce. Wir können dies von Hand tun, wie eine andere Antwort zeigt. Das ist notwendig.

Dieser Schritt ist so kompliziert, dass man akzeptiert, dass Mathematica klassifiziert, wie ich die Differentialgleichung in explizit intern ausgeführt habe NDSolve. Die Lösungsmethode übergibt den Differentialgleichungslösungsprozess an DSolvedie aus diesem Prozess entnommene Lösung und interpoliert diese und gibt diese aus. Dies ist ein Sonderfall der Faulbewertung. Meine Antwort lautet also nicht, dies mit, DSolvesondern mit zu lösen , NDSolvesondern den kopfgeführten Pfad zu verwenden.

Die Schwierigkeiten werden auf diese Weise nicht gelöst. Die Bedeutung der "Problemumgehung" # 3 von @ michael-e2 gegenüber all seinen anderen Problemumgehungen kann neu erfunden werden, indem der Weg zur vollständigen Lösung der Ellipsen beendet und als vollständige Lösung und die mathematische auf wahre Lösung und die Hälfte akzeptiert wird -way Lösung, die alle anderen hier anbieten. Dies von Hand zu tun ist harte Arbeit und viel Schreiben. Wenn Sie dies tun, beendet der Mathematica-Prozess die mathematische Aufgabe nicht vollständig und korrekt. Es nimmt einfach nicht den Überblick über die Arbeit Reduce.

Behalten Sie jedoch bei, da die Quintessenz der Antwort Wurzeln in den Ergebnissen von Mathematica in den meisten Fällen so vermeidet, dass sie nicht in Ihrer Antwort erscheinen sollten. Dies kommt einer korrekten Lösung nahe. Daher kann es sinnvoll sein, in zu behandelnReduce $y$ und $y'$als unabhängig und geben Sie sie angemessen ein. Es gibt keine integrierte Funktion zum Übertragen der Reducefür Sie erledigten Arbeit an der Lösung aus der Mathematica-Ausgabe. Dies ist eine Frage der Erfahrung, die jeder Mathematiker erreichen kann. Wie die Antwort von @ michael-e2 zeigt, kann dies zu neuen Zweigen von Lösungen führen, die alle Anzeichen von Wurzeln vermischen. Daher ist die endgültige Lösung nur dann einzigartig, wenn vor den Wurzeln kein ambivalentes Zeichen ausgelassen wird.