Können wir 4 Quadratzahlen finden, so dass die Differenz je zweier solcher wieder ein Quadrat ist?

Neue Frage »

Eldar Auf diesen Beitrag antworten »
Können wir 4 Quadratzahlen finden, so dass die Differenz je zweier solcher wieder ein Quadrat ist?
Können wir vier Quadratzahlen finden, so dass die Differenz je zweier solcher wieder ein Quadrat ist?

Möglicherweise könnte das Gleichungssystem eine Lösung liefern:






Der Weg scheint aber sehr ineffizient.
Steffen Bühler Auf diesen Beitrag antworten »

Wenn Du sowas wie





meinst - das wäre das kleinste Quartett von wahrscheinlich unendlich vielen, was ich mit brute force gefunden habe. Ob hier ein Lösungsansatz über pythagoräische Tripel funktioniert, habe ich noch nicht herausgefunden.

Viele Grüße
Steffen
HAL 9000 Auf diesen Beitrag antworten »

Vielleicht sollte man erstmal kleinere Brötchen backen und nur drei solche Zahlen x,y,z finden, d.h., mit





Die gibt es durchaus, z.B. .
Eldar Auf diesen Beitrag antworten »

Vielen Dank!

Das geht schonmal in die richtige Richtung. Genial wäre es, wenn beispielsweise auch noch eine Quadratzahl wäre (also jede mögliche Differenz der vier Quadrate untereinander).

Möglicherweise geht das ja auch gar nicht?

Wie HAL 9000 schon richtig geschrieben hat, für drei solcher Zahlen gibt's das durchaus und das 3er-Beispiel ist super. Wahrscheinlich werden für den 4er-Fall die Zahlen extrem groß oder es geht überhaupt nicht mehr.
Eldar Auf diesen Beitrag antworten »

Hallo HAL,

absolut korrekt. Bei dem 4er-Fall glaube ich langsam, dass man sich da totsuchen muss.

Viele Grüße
Eldar
HAL 9000 Auf diesen Beitrag antworten »

Ich weiß nicht - wenn man etwas systematisch vorgeht, kommt man vielleicht doch in endlicher Zeit zum Ziel. Ich schildere mal, wie ich bei dem Problem mit nur drei Werten vorgegangen bin:

Pythagoras-Tripel (s,x,y) mit Ansatz
Pythagoras-Tripel (t,x,z) mit Ansatz

Damit die dritte Gleichung gilt, muss



gelten, d.h., das rechts ein Quadrat sein. Jetzt habe ich einfach gesetzt und ein "nicht-triviales" Paar per Brute-force gesucht, so dass ein Quadrat ist. Dabei heißt "nichttrivial" hier, dass sein sollte, und das habe ich mit gefunden.
 
 
Eldar Auf diesen Beitrag antworten »

Genial - besten Dank!

Ich hab's mal implementiert und komme auf Dein Ergebnis und noch auf viel mehr:
Python Notebook

Wie kann ich das jetzt umbasteln für den "spannenderen" 4er-Fall?

[4, 5, 5]
[16, 20, 20]
[36, 45, 45]
[64, 80, 80]
[100, 125, 125]
[144, 180, 180]
[196, 245, 245]
[256, 320, 320]
[324, 405, 405]
[400, 500, 500]
[484, 605, 605]
[576, 720, 720]
[676, 845, 845]
[784, 980, 980]
[900, 1125, 1125]
[1024, 1280, 1280]
[1156, 1445, 1445]
[1296, 1620, 1620]
[1444, 1805, 1805]
[1600, 2000, 2000]
[1764, 2205, 2205]
[1936, 2420, 2420]
[644, 725, 2165]
HAL 9000 Auf diesen Beitrag antworten »

Moment mal: Ich bin davon ausgegangen, dass du nur positive Lösungen suchst, d.h., auch müssen von Null verschieden sein. Dazu muss aber auf jeden Fall sein bzw. bei drei Variablen . Letzteres erfüllt von deinen Tripeln nur das letzte...

Ansonsten könnte man ja auch gleich wählen... Augenzwinkern
Eldar Auf diesen Beitrag antworten »

Korrekt - hab das Problem behoben und bekomme jetzt richtige Tripel:

[644, 725, 2165]
[2576, 2900, 8660]
[5796, 6525, 19485]
[10304, 11600, 34640]
[16100, 18125, 54125]
[23184, 26100, 77940]
[31556, 35525, 106085]
[41216, 46400, 138560]
[52164, 58725, 175365]
[64400, 72500, 216500]
[77924, 87725, 261965]
[92736, 104400, 311760]

Hier ist das korrigierte Notebook
Wie kann ich es für den 4er-Fall anpassen, so dass es genauso effizient läuft? Wäre absolute klasse. So langsam habe ich Hoffnung, dass es doch klappen könnte.
HAL 9000 Auf diesen Beitrag antworten »

Ich muss nochmal meckern: Offenbar ist mit auch jedes Tripel Lösung, wobei eine beliebige ganze Zahl ist. Daher sollte man sich erstmal auf Lösungen mit teilerfremden x,y,z konzentrieren. D.h., berechne mal VOR dem Print

g = math.gcd(x,y)
g = math.gcd(g,z)
x = x//g
y = y//g
z = z//g

Dann wirst du bei deinen Tripeln eine unangenehme Überraschung erleben...

Zitat:
Original von Eldar
Wie kann ich es für den 4er-Fall anpassen, so dass es genauso effizient läuft? Wäre absolute klasse. So langsam habe ich Hoffnung, dass es doch klappen könnte.

Darüber habe ich mir noch keine Gedanken gemacht - ich wollte nur erstmal eine Anregung geben, wie man den Bruteforce-Raum etwas einschränken könnte.
Eldar Auf diesen Beitrag antworten »

Tatsächlich - es wird dünner, aber immerhin 2 Tripel:

[644, 725, 2165]
[1873432, 2288168, 2399057]

und er sucht noch. Und was ich noch optimieren muss, ist die unglückliche Tatsache, dass er mir diese zwei Tripel doppelt und dreifach ausgibt. Das liegt daran dass ich über und iteriere und erst dann berechne. Ich muss mit dem Ausschlusskriterium früher ansetzen.
HAL 9000 Auf diesen Beitrag antworten »

Z.B. nur über teilerfremde b,c iterieren. Also sowieso nur die c untersuchen mit math.gcd(b,c)=1.
Eldar Auf diesen Beitrag antworten »

Es geht voran (die Doubletten sind weg) und für a=2 haben wir:
[644, 725, 2165]
[1873432, 2288168, 2399057]

Für a=3 haben wir:
[12, 13, 37]
[483, 485, 2405]
[2810148, 4539373, 4835077]
Komischerweise ist 37*37-13*13 keine Quadratzahl.

Für a=4 haben wir:
[16, 20, 65]
[1288, 1313, 8513]
[3746864, 7691060, 8245505]

Das Spiel könnte man fortsetzen - er findet immer was.

Kleine ergänzende Nachfrage:
Ich gebe ja immer [x,y,z] aus. Die Variablen s, t nutze ich momentan gar nicht.
Ist das ein Problem?
HAL 9000 Auf diesen Beitrag antworten »

Zitat:
Original von Eldar
Komischerweise ist 37*37-13*13 keine Quadratzahl.

Ist mir auch gerade aufgefallen. Irgendetwas scheint mit deinem Skript nicht in Ordnung. verwirrt
Eldar Auf diesen Beitrag antworten »

Hab ihn parallel gefixt (und das auch schon mitbekommen):

hier der saubere Fall für a=3:
[4557, 5525, 11285]

und für a=4:
[512008, 878033, 1367633]

Hatte peinlicherweise die Zahl 15 hardgecoded drin stehen anstelle von a*a*a*a-1.

Das korrigierte Skript ist hier :

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
a=4
for c in range(10000):
    for b in range(1000):
        if gcd(c,b)==1:
            D=(a*a*a*a-1)*(c*c*c*c-b*b*b*b)
            if is_square(D):
                s=a*a*b*b-c*c
                t=a*a*c*c-b*b
                x=2*a*b*c
                y=a*a*b*b+c*c
                z=a*a*c*c+b*b
                g = sympy.igcd(x,y,z)
                x = x//g
                y = y//g
                z = z//g
                if x < y and y < z:
                    print([x,y,z])
Eldar Auf diesen Beitrag antworten »

Ich hab mal weiter recherchiert. Der 3er Fall scheint eng mit dem Mengoli Six-Square Problem verwandt zu sein. Hab das Programm mal weiter laufen lassen und er findet nun folgende Quadrupel (a,x,y,z):

[2, 644, 725, 2165]
[2, 1873432, 2288168, 2399057]
[3, 4557, 5525, 11285]
[3, 76059351, 117591849, 137110601]
[4, 512008, 878033, 1367633]
[5, 483595, 1086397, 1460797]
[6, 20062092, 55714933, 68768533]
[7, 10063193, 33237625, 38882425]
[8, 268042256, 1025007425, 1157095745]

Die scheinen zu passen.

Allerdings, wie konnte uns die Lösung (153,185,697) durch die Lappen gehen?


Wäre spannend zu wissen, ob die 4er-Variante auch Lösungen bietet.
HAL 9000 Auf diesen Beitrag antworten »

Zitat:
Original von Eldar
Allerdings, wie konnte uns die Lösung (153,185,697) durch die Lappen gehen?

Weil sie nicht zum Schema des Ansatzes

Zitat:
Original von HAL 9000
Pythagoras-Tripel (s,x,y) mit Ansatz
Pythagoras-Tripel (t,x,z) mit Ansatz

passt, denn bei dem ist stets gerade. Ich hatte ja auch nie behauptet, dass man mit diesem Ansatz alle Tripel erwischt, sondern das Ansinnen war lediglich einige zu finden! Augenzwinkern
Eldar Auf diesen Beitrag antworten »

Ahh ok - dann bin ich beruhigt (dass nicht noch irgendwo ein Bug im Script ist).

Hab übrigens gute Neuigkeiten. Hab eine "fast"-Lösung für den 4er Case (per Bruteforce):

Nehmen wir mal das Quadrupel (w=448, x=952, y=1073, z=1105) und multiplizieren jedes Element mit dem Faktor 2554, dann sind alle Differenzen Quadrate, bis auf die Ausnahme: Wurzel aus (z*z-w*w)*f*f ist 2579819,40764

Es geht glaube ganz gut voran.
Eldar Auf diesen Beitrag antworten »

So ich habe mal eine CSV-Datei generiert mit 2254 solcher Tripel : CSV

Dann hatte ich für jedes Tripel ein gesucht (per Bruteforce) und geschaut, ob jeweils zu eine Differenz erzeugt, die dann auch wieder ein Quadrat ist. Ergebnis: Nope.

Das Ganze lief Stunden. Nun habe ich das Script für CUDA/JIT/GPU optimiert und lasse es in einem GPU Cluster laufen - mit einer Suche bis zu 2000000. Also wenn er dann nix findet, können wir uns ja überlegen, ob ein Beweis machbar ist, dass es gar keine solche Quadrupel gibt.

Oder ich hab noch einen krassen Denkfehler in meiner Suche.
Eldar Auf diesen Beitrag antworten »

Liege ich richtig, wenn ich sage: Eine Primitive Lösung kann es nicht geben, sprich eine Lösung, deren vier Quadrupel-Elemente nicht mehr durch eine Zahl weiter "kürzbar sind".

Bei unseren Quadrupeln bestehend aus Quadratzahlen (deren Differenzen untereinander wieder Quadrate sind) müssen zwei von ihnen ungerade und zwei gerade sein.

Nehmen wir mal das Tupel bestehend aus nur Quadraten und setzen:








Sei , wobei und relativ prim sind und verschiedene Parität haben. Mit und hätten wir bzw.

Jetzt setzen wir noch , wobei und ebenfalls relativ prim sind und verschiedene Parität haben. Dann hätten wir mit und analog zu oben die Gleichheit . Und wegen und gilt .

Wie bereits erwähnt haben und verschiedene Parität ebenso wie und . Lass uns dann einfach und ungerade wählen. Umgekehrt sind dann und gerade. Das Quadrat einer ungeraden ganzen Zahl hat (bekanntlich) die Form . Entsprechend haben und die Form , so dass die Form hat. Die geraden Quadrate und haben die Form , weswegen es keine Lösung gibt.

Haben wir damit zumindest primitive Quadrupel-Lösungen ausgeschlossen?

Und nun kommt eine vage Vermutung meinerseits: Wenn es keine primitive Lösung gibt, dann lassen sich auch keine nicht-primitiven generieren:

Nehmen wir mal die "Fast-Lösung", die knapp daneben liegt: . Sie schlägt lediglich fehl bei . Um diese "zu heilen", müssten wir ja Quadrupel-Elemente mit der Zahl multiplizieren. Allgemein müssten wir für jede "Fast-Lösung" die Wurzel als Faktor ansetzen.

Angehängt ist übrigens eine ganze Liste solcher Tupel .
HAL 9000 Auf diesen Beitrag antworten »

Zitat:
Original von Eldar
Liege ich richtig, wenn ich sage: Eine Primitive Lösung kann es nicht geben, sprich eine Lösung, deren vier Quadrupel-Elemente nicht mehr durch eine Zahl weiter "kürzbar sind".

Der letzte Teilsatz ist mir etwas zu vage formuliert. Ich würde ein Lösungstupel als "primitiv" bezeichnen, wenn die Elemente teilerfremd sind. Wobei ich mit teilerfremd eben auch wirklich "teilerfremd" meine, und nicht etwa die viel stärkere Forderung "paarweise teilerfremd".

Den Rest deines Beitrages habe ich noch nicht durchgelesen - vielleicht später.
Eldar Auf diesen Beitrag antworten »

Vielen Dank für den Hinweis. Das passe ich entsprechend an.

Habe übrigens mit Mathematica in der Tupeln folgendermaßen nach Lösungen gesucht - ohne Erfolg:
code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
arr = Import[
   "C:/Users/esultano/git/pythagorean/pythagorean_stu_tmp.txt", "CSV",
    "HeaderLines" -> 0];
f[i_] := Part[arr[[i]], 1 ;; 3];
len = Length[arr];
For[i = 1, i < len, i++, {
  triplet = f[i];
  s = triplet[[1]];
  t = triplet[[2]];
  u = triplet[[3]];
  (*Print[FactorInteger[s]];*)
  Print[FindInstance[
    x*x - w*w == s*s && y*y - w*w == t*t && w != 0, {w, x, y}, 
    Integers]];
  Print[FindInstance[
    y*y - w*w == t*t && z*z - y*y == u*u && w != 0, {w, y, z}, 
    Integers]];
  }
 ]

Python braucht ewig länger, findet aber auch nix:
code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
from z3 import Ints, solve
df = pd.read_csv('pythagorean_stu.txt', header=None)
tuples = df.to_numpy()
x, y, z, w = Ints('x y z w')
for row in tuples:
    s=int(row[3])
    t=int(row[4])
    u=int(row[5])
    solve(x*x-w*w==s, y*y-w*w==t, z*z-y*y==u, w!=0)

Es ist schon "zum Mäusemelken".
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »