Kann es echten Zufall geben oder gibt es nur unberechenbares Chaos?

Die Frage danach, ob alles vorherbestimmt ist, ist sicher auch eine spirituelle, aber mich interessiert eher die wissenschaftliche Seite. Den mathematischen Zufall kenne ich, das Modell aus subjektiv kausal nicht zusammenhängenden Ereignissen -- aber auch etwa der zufällig wirkende Münzen- oder Würfelwurf ist ja kein echter, objektiver Zufall, sondern auch "nur" deterministisches Chaos.

Im gleichen Zuge stellt sich dann die Frage, ob es objektiven Zufall überhaupt geben kann -- im Rahmen der Quantenphysik scheint es ein paar Stellen zu geben, an denen echter Zufall eventuell möglich zu sein scheint. Oder gibt es tatsächlich nur zufällig wirkende Ereignisse, die aber auch nur Ergebnis einer (wenn auch unbekannten) Kausalkette sind?

Wenn ja, würde das ja bedeuten, dass im Allgemeinen alles vorbestimmt ist und theoretisch vorausgesagt werden kann. Ist das möglich? Und um den Gedanken dann noch ein bisschen weiterzuspinnen -- wenn wir wirklich dazu in der Lage wären, bestimmte Kausalketten in die Zukunft vorherzusagen, könnten wir dann auch Ergebnisse beliebig weit in die Vergangenheit zurückführen?

Mit anderen Worten, um es auf den Punkt zu bringen: Kann es indeterministisches Chaos überhaupt geben?

(Mir ist klar, dass das darauf nicht die Antwort gibt. Es ist eher eine Meinungs- und Ansichtenfrage.)

Religion, Mathematik, Mathe, Wissenschaft, Psychologie, Chaos, Philosophie, Physik, Quantenphysik, Zufall, Determinismus, Philosophie und Gesellschaft
11 Antworten
Algorithmus zum Durchlaufen aller möglichen Verteilungskombinationen?

Guten Morgen,

ich beschäftige ich momentan etwas mit Lotto 6aus49. Dafür möchte ich den Erwartungswert bei variabler Anzahl von Tipps berechnen - dabei wird es aber zunehmend komplex.

Unter der Voraussetzung, dass nur in einer Gewinnklasse gleichzeitig gewonnen werden kann, komme ich für den Erwartungswert (Preise für die Tippscheine berechne ich separat) auf folgende Formel:



k: Gewinnklasse
n: Anzahl der Lose
m: Anzahl der Gewinne in Gewinnklasse k (der Rest sind Nieten)
p_k: Gewinnwahrscheinlichkeit in Gewinnklasse k
g_k: Anzahl der Gewinner in Gewinnklasse k
G_k: Gesamtgewinn in Gewinnklasse k

Das ist aber natürlich Quatsch. Gebe ich mehr als einen Tipp ab, kann ich theoretisch auch in mehreren Gewinnklassen gleichzeitig (oder auch in einer Gewinnklasse mehrmals) gewinnen. Da es dafür aber so viele Kombinationen gibt, komme ich mit mathematischen Mitteln vermutlich nicht ans Ziel.

Deswegen versuche ich, einen Algorithmus zu entwickeln, der systematisch alle möglichen Kombinationen für alle 10 Gewinnklassen durchgeht (Gewinnklasse 1-9 sind die normalen Gewinnklassen, Gewinnklasse 10 ist die Niete). Daran hänge ich aber momentan.

Kurz: Ich habe n (verschiedene) Tipps und kann diese auf 10 Gewinnklassen verteilen.

Das Problem: In jeder Gewinnklasse gibt es eine andere Anzahl an maximalen Tipps (für GK 1 - 6 Richtige + SZ - gibt es nur eine einzige Möglichkeit, wobei es für GK 2 - 6 Richtige ohne SZ - schon 9 Möglichkeiten gibt und in GK 3 - 5 Richtige + SZ - 6 Möglichkeiten (6 nCr 5)).
Einfach gesagt: Bei den Gewinnzahlen 1, 2, 3, 4, 5 und 6 sind sowohl die Zahlen 4, 3, 5, als auch die Zahlen 2, 5, 1 drei Richtige. Da alle Tipps verschieden sind, kann es also maximal einen richtigen Tipp in GK 1 geben, in GK 7 (3 Richtige + SZ) aber bspw. schon 20 (6 nCr 3).

Wie kann ich programmatisch also alle Möglichkeiten durchgehen bzw. anders gefragt: Wie kann ich aus diesem Problem ein bisschen die Komplexität rausnehmen?

Vielen Dank schon mal im Voraus fürs Lesen und Verstehen.

LG

PC, Computer, Mathematik, Mathe, Programmieren, Programmierung, Informatik, Lotto, Algorithmus
4 Antworten
Wie kann man diesen Code sauberer und effizienter schreiben?

Guten Abend,

ich arbeite gerade an einem Projekt, bei dem ich unter anderem schnell, effizient und sicher (also nicht nur probabilistisch) prüfen muss, ob eine Zahl prim ist oder nicht. Dafür verwende ich den Fermat'schen Primzahltest - der wirkt mir für das Projekt am schlauesten (oder?), weil er einfach ist und mir Listen mit Pseudoprimzahlen bis zu ausreichender Größe vorliegen, sodass der Primzahltest sicher ist.

Je nachdem, bis wohin ich Primzahlen prüfen will, enthält die Liste pseudoprimes alle Pseudoprimzahlen bis zu einer gewissen Größe.

def exponentiateModular(a: int, b: int, n: int) -> int: # calculates a^b mod n
    powersModN = [a] # a^k for each k <= b
    while 2 ** len(powersModN) <= b:
        powersModN.append(powersModN[-1] ** 2 % n)
    binaryString = bin(b)[2:] # binary string without 0b
    res = 1
    for index, digit in enumerate(reversed(binaryString)):
        if digit == '1':
            res *= powersModN[index] # powersModN[x] = 3^(2^x) mod n
    return res % n

def isPrime(p: int) -> bool: # Fermat
    return exponentiateModular(2, p - 1, p) == 1 and p not in pseudoprimes

Kann ich diesen Code noch optimieren? (Python) Wie kann die exponentiateModular-Methode mit der momentan logarithmischen Laufzeit noch schneller laufen?

Vielen Dank schon mal im Voraus.

LG

PC, Computer, Technik, Programmieren, Programmierung, Primzahlen, Python, Technologie
4 Antworten
Java Ellipse aus Linien zeichnen - Fehler wegen nur ganzzahlig möglichen Winkeln?

Hallo,

ich möchte in Java einen Farbkreis in Form eines Ellipse zeichnen; dafür zeichne ich Linien verschiedener Farben vom Mittelpunkt aus in einem bestimmten Winkel zum Endpunkt, der auf der imaginären Form einer Ellipse liegt. So weit so gut, das funktioniert auch.

Mein Problem allerdings ist, dass die Farbkreis-Ellipse nach dem Zeichnen ganz und gar nicht so aussieht, wie sie aussehen sollte:

Ich vermute, dass es daran liegt, dass die Berechnungen Gleitkommazahlen ergeben, die ich aber ganzzahlig runden muss, damit ich damit das Ende einer Linie als Punkt kennzeichnen kann. Dadurch liegen die Linien womöglich an manchen Stellen aufeinander und an anderen Stellen existieren keine Linien (ist das so?).

Hier der Code zum Definieren der Linien mit Farbe und Index:

Line[] lines = new Line[3*255]; 
int[] color = {255,0,0}; 
for(int i=0; i<3; i++) 
   for(int j=0; j<255; j++){ 
      color[i]--; color[(i+1)%3]++; 
      lines[i*255 + j] = new Line(i*255 + j + 1, new Color(color[0], color[1], color[2])); 
} 

Zeichne ich die Linien mit aufsteigender Länge nebeneinander, funktioniert der Farbübergang so wie geplant - nur die Farbellipse macht Probleme.

Hier der Konstruktor der Line-Klasse (mehr enthält sie mom. noch nicht):

Line(int index, Color color){
	this.index = index;
	this.color = color;
	this.angle = this.index*360./765; //3*255 Farben
    int a = Ellipse.a, b = Ellipse.b;
    double x = (a*b/Math.sqrt(b*b+Math.pow(a*Math.tan(angle), 2))),
           y = x*Math.tan(angle);
    if(angle > 90 && angle < 270) x = -x;
    this.end = new Point((int) x, (int) y);
    this.length = Point.distance(0, 0, end.x, end.y);
}

Die paint-Methode der Frame Klasse (ja, ich programmiere in Swing, die Ellipse ist eher ein quick&dirty-Projekt):

@Override public void paint(Graphics g){
	for(int i=0; i<3*255; i++){ 
       g.setColor(lines[i].color); 
       g.drawLine(m.x, m.y, lines[i].end.x+m.x, lines[i].end.y+m.y); 
    } 
} 

Warum sieht die gezeichnete Ellipse so grausam im Gegensatz zum Dreieck aus und separiert optisch so stark zwischen rot und blau? Woran liegt das bzw. wie kann ich es beheben?

Vielen Dank schon mal im Voraus.

LG

Java Ellipse aus Linien zeichnen - Fehler wegen nur ganzzahlig möglichen Winkeln?
Computer, Mathematik, zeichnen, Mathe, Programmieren, Java, Programmierung, Swing, Ellipse
5 Antworten