<jupyter_start><jupyter_text>Einblick in die Arbeit mit zufall von <NAME> - <EMAIL>Diese Arbeit steht unter der freien Lizenz [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.de)  1. Urne - Zufallsexperiment2. Binomialverteilung3. Bedingte Wahrscheinlichkeiten4. Statistische Berechnungen5. Ein Spiel6. Klassen  in zufall7. Hilfe-InformationenDas Paket zufall ist in der Programmiersprache Python geschrieben und basiertauf dem ebenfalls in Python geschriebenen und quelloffen frei verfügbaren CAS SymPy Für die Objekte der Stochastik wurden Python-Klassen im Sinne der Objekt-Orientierten-Programmierung implementiert (siehe die Liste unter 6.). Damit können entsprechende Python-Objekte erzeugt werden, mit denen unter Verwendung ihrer Eigenschaften und Methoden am Computer gearbeitet wird Die Berechnungen werden in einem Jupyter-Notebook (mit englischer Bedienoberfläche)durchgeführt, die vorliegende Datei wurde durch den HTML-Export eines solchen Notebooks erzeugtDie Kommentare (nach ) sind lediglich Erläuterungen und für die Berechnungen nicht relevant<jupyter_code>%run zufall/start   # Aktivierung des Paketes<jupyter_output><empty_output><jupyter_text>1. Urne - Zufallsexperiment Aus einer Urne mit 5 grünen, 3 roten und 2 weißen Kugeln wird 2-mal mit Zurücklegen / Wiederholung gezogen<jupyter_code>u = Urne({g:5, r:3, w:2}, 2)
u<jupyter_output><empty_output><jupyter_text>Ergebnismenge und Wahrscheinlichkeitsverteilung<jupyter_code>u.omega
u.vert
u.Vert(d=4)   # Dezimaldarstellung<jupyter_output><empty_output><jupyter_text>Das Baumdiagramm kann gezeichnet werden, falls es nicht zu groß wird<jupyter_code>u.baum<jupyter_output><empty_output><jupyter_text>Die Wahrscheinlichkeiten von Ereignissen sind leicht zu berechnen<jupyter_code>u.P('rg')
u.P(['rg', 'rr', 'rw'])<jupyter_output><empty_output><jupyter_text>Es sind Stichproben mit beliebiger Länge moglich<jupyter_code>u.stich_probe(5)<jupyter_output><empty_output><jupyter_text>Mit Hilfe der Listendarstellung der Versuchsausgänge in einer Stichprobe<jupyter_code>u.stich_probe(5, l=ja)<jupyter_output><empty_output><jupyter_text>können Zähl-Statistiken erhalten werden:<jupyter_code>n = 100000
sp = u.stich_probe(n, l=ja)
anzahl(sp, [r, g]) / n    # rel. Häufigkeit; anzahl - zufall-Funktion
 u.P('rg', d=4)           # theoretische Wahrscheinlichkeit<jupyter_output><empty_output><jupyter_text>Es sind auch eigene Python-Funktionen zu benutzen, z.B berechnet die folgendeFunktion die relative Häufigkeit aller Versuchsausgänge, die mindestens ein w enthalten<jupyter_code>def eig_fkt(liste):    # die Funktion erwartet eine Liste als Argument
    anz = 0
    for el in liste:
        if w in el:
            anz += 1
    return anz / len(liste)    # len gibt die Länge der Liste zurück          
eig_fkt(sp)<jupyter_output><empty_output><jupyter_text>Die theoretische Wahrscheinlichkeit ist in diesem Fall<jupyter_code>u.P(['ww', 'wr', 'wg', 'rw', 'gw'], d=4)<jupyter_output><empty_output><jupyter_text>Die vorige Aufgabe läßt sich aus Python-Sicht eleganter und effektiver mit Hilfeeiner list comprehension lösen<jupyter_code>li = [ x for x in sp if w in x ]

len(li) / len(sp)<jupyter_output><empty_output><jupyter_text>2. Binomialverteilung<jupyter_code>bv = BV(12, 0.4)   # BV - BinomialVerteilung
bv<jupyter_output><empty_output><jupyter_text>Erwartungswert, Varianz und Standardabweichung<jupyter_code>bv.erw, bv.var, bv.sigma
bv.Erw(d=2), bv.Var(d=2), bv.Sigma(d=2)<jupyter_output><empty_output><jupyter_text>Die Wahrscheinlichkeitsverteilung<jupyter_code>bv.vert 
bv.Vert(d=4)   # Dezimaldarstellung
bv.Vert(p=ja)   # Prozentwerte<jupyter_output><empty_output><jupyter_text>Das Histogramm und das Histogramm der kumulierten Wahrscheinlichkeiten<jupyter_code>bv.hist
bv.hist_kum<jupyter_output><jupyter_text>Wahrscheinlichkeiten können so<jupyter_code>bv.P(5)  # Auftreten einer 5   
bv.P([2, 4, 6], d=4)   # Auftreten einer 2, 4 oder 6<jupyter_output><empty_output><jupyter_text>oder auch mit einer Notation, die der üblichen sehr nahe kommt, berechnet werden<jupyter_code>bv.P(X=5)
bv.P(X <= 8) 
P = bv.P   # das ist lediglich eine temporäre Umbenennung der Methode
P(X <= 8)
P(X <= 8, d=4)
P('3 < X <= 6'), P('3 < X <= 6', d=4)
P('3 < X <= 6', g=ja)<jupyter_output><jupyter_text>Es sind Versuche und Stichproben beliebigen Umfangs möglich<jupyter_code>bv.versuch
sp = bv.stich_probe(50000)   # eine liste mit 50000 Elementen
sp[:10]                      # die ersten 10 Elemente<jupyter_output><empty_output><jupyter_text>Durch die Rückgabe einer DatenReihe mit den Werten der Stichprobe<jupyter_code>dr = bv.stich_probe(50000, d=1)<jupyter_output>Rückgabe einer DatenReihe<jupyter_text>kann ein Vergleich der Wahrscheinlichkeiten der Binomialverteilung und der relativen  Häufigkeiten in der Stichprobe erhalten werden; das kann beliebig oft wiederholt werden, indem die Stichprobe neu gezogen wird (durch erneutes Ausführen der obigen Zelle, eventuell auch mit anderem Umfang) und die nachfolgenden Zellen erneutberechnet werdenHier der Vergleich zwischen der theoretischen Verteilung und der Stichprobe:<jupyter_code>bv.Erw(d=4), dr.Mittel(d=4)
bv.Sigma(d=4), dr.S(d=4)   # für den zweiten Wert braucht der Computer 
                           # etwas länger
bv.Hist(dr)<jupyter_output><jupyter_text>Für ein Ereignis kann veranschaulicht werden, wie sich die relativen  Häufigkeiten stabilisieren<jupyter_code>e = [5, 6, 7]   # Ereignis "5 oder 6 oder 7"

bv.P(e, d=4)

bv.relh2p(e, 30000)   # mehrfach ausführen, auch mit anderem e  
                      # und/oder anderem Stichprobenumfang<jupyter_output>Stabilisierung der relativen Häufigkeiten eines Ereignisses

Es werden die relativen Häufigkeiten eines Ereignisses bei wachsender Ver-
suchsanzahl dargestellt

grüne Linie: theoretische Wahrscheinlichkeit des Ereignisses<jupyter_text>3. Bedingte Wahrscheinlichkeiten In einer Lostrommel sind 80% der Lose Nieten, 40% der Lose sind rot gefärbt und5% sind rot gefärbt und keine NietenDie zugehörige Vier-Felder-Tafel ist<jupyter_code>vt = VT([35, 45, 5, 15], ['Rot', 'nichtRot', 'Niete', 'keineNiete'])
vt.ausg<jupyter_output><empty_output><jupyter_text>Sie kann auch nur mit den gegebenen Werten erzeugt werden<jupyter_code>vt = VT([x, x, 80, 5, x, x, 40, x, 100], ['Rot', 'nichtRot', 'Niete', 'keineNiete'])
vt.ausg<jupyter_output>Die Tafel wird automatisch vervollständigt<jupyter_text>Die Wahrscheinlichkeiten (einschließlich der bedingten), die sich anhand der Tafelberechnen lassen, sind folgende<jupyter_code>vt.wahrsch<jupyter_output><jupyter_text><NAME> kommt in seinerm Buch Einmaleins der Skepsis zu dem Schluss, dass für den Umgang mit bedingten Wahrscheinlichkeiten von den relativen Zahlen in einer Vier-Felder-Tafel zu den natürlichen (absoluten) Häufigkeiten in einem entsprechenden Baum der natürlichen Häufigkeiten übergegangen werden sollte<jupyter_code>hb = vt.hb_(1000)    # Häufigkeitsbaum, welcher der Vierfeldertafel 
                     # entspricht; auf 1000 umgerechnet
hb.ausg   
hb.wahrsch<jupyter_output><jupyter_text>4. Statistische BerechnungenEine weitere Datenreihe auf der Grundlage einer Binomialverteilung<jupyter_code>bv = BV(15, 0.2)   # andere Binomialverteilung
dr1 = bv.stich_probe(30000, d=1)
dr1.n, dr1.daten[:10]   # Umfang und die ersten 10 Werte
dr1.hh(5, d=3)   # relative Häufigkeit für k=5
dr1.Mittel(d=3)   # Mittelwert
dr1.spann_weite   # Spannweite
dr1.modal   # Modalwert und absolute Häufigkeit
dr1.Modal(rd=ja)   # ebenso, relative Häufigkeit
dr1.poly_zug
dr1.hist<jupyter_output><jupyter_text>Die Verteilung der relativen Häufigkeiten, in Prozent<jupyter_code>dr1.Vert(p=ja)<jupyter_output><empty_output><jupyter_text>Eine Datenreihe auf der Grundlage einer Normalverteilung<jupyter_code>nv = NormalVerteilung(3, 1)   
dr2 = nv.stich_probe(50000, d=1)
dr2.box_plot
dr2.violin_plot
dr3 = dr2.klassen(12)   # Klasseneinteilung
dr3.daten[:20], dr3.daten[-20:]   # die ersten 20 und letzten 20 Werte
                                  # Klassennummern 0, 1, ..., 11
dr3.vert_abs_h   # Verteilung der absoluten Häufigkeiten
dr3.hist_abs_h   # entsprechendes Histogramm<jupyter_output><jupyter_text>5. Ein Spiel In zufall sind einige einfache Spiele implementiert, die verwendet werden könnenHier wird demonstriert, wie das Ziegenproblem mit Hilfe eines Python-Programms simuliert werden kannDas Programm ist auch in einem der Aufgaben-Notebooks in den Materialien enthalten, die von zufall bereitgestellt werden, gemeinsam mit einem Programm zur statistischen Auswertung des Spiels bei vielfacher WiederholungDer Algorithmus geht auf *<NAME>* zurück<jupyter_code># Definition einer Funktion für das Spiel

def ziegen_problem():
    
    auto = zuf_zahl((1, 3))         # die Tür mit dem Auto    ( Zufallszahl 1, 2 oder 3 )
    spieler = zuf_zahl((1, 3))      # die vom Spieler gewählte Tür    
    frei = {1, 2, 3}.difference({auto, spieler})
                                    # eine oder zwei Türen für den Spielleiter
                                    # (er darf weder die Auto- noch die gewählte Tür öffnen)    
    if spieler != auto:
        gewinnA = 'verloren'        # Strategie A: verloren
        leiter = frei.pop()         # die Tür für den Spielleiter (frei hat ein Element)
    else:                           
        gewinnA = 'gewonnen'        # Strategie A: gewonnen
        nr = zuf_zahl((0, 1))       # zufällige Wahl eines Index  (frei hat zwei Elemente)    
        leiter = list(frei)[nr]  
        
    wechsel = 6 - spieler - leiter  # zu dieser Tür kann gewechselt werden 
                                    # (es gilt immer spieler + leiter + wechsel = 6)    
    if wechsel == auto: 
        gewinnB = 'gewonnen'        # Strategie B: gewonnen
    else:
        gewinnB = 'verloren'        # Strategie B: verloren
        
    print("\n                     Strategie A        Strategie B");
    print("Auto    " + str(auto) + ".Tür")
    print("Spieler " + str(spieler) + ".Tür")
    print("Leiter  " + str(leiter) + ".Tür")
    print("                     kein Wechsel", "      Wechsel zur " + str(wechsel) + ".Tür")
    print("                    ", gewinnA, "         ", gewinnB, "\n")   
# Durchführung eines Spiels; das kann beliebig oft wiederholt werden

ziegen_problem()<jupyter_output>Strategie A        Strategie B
Auto    2.Tuer
Spieler 1.Tuer
Leiter  3.Tuer
                     kein Wechsel       Wechsel zur 2.Tuer
                     verloren           gewonnen<jupyter_text>6. Klassen in zufall<jupyter_code>Hilfe(h=6)<jupyter_output>Klassen in zufall
	
Kurz-     Langname

ZE        ZufallsExperiment
             = ZV  ZufallsVersuch
ZG        ZufallsGröße
BK        BernoulliKette

BV        BinomialVerteilung		
HGV       HyperGeometrischeVerteilung		
GLV       GleichVerteilung
GV        GeometrischeVerteilung
PV        PoissonVerteilung
		
NV        NormalVerteilung
EV        ExponentialVerteilung

DR        DatenReihe

EA        EreignisAlgebra		
VT        VierFelderTafel
HB        HäufigkeitsBaum

KI        KonfidenzIntervall		
AT        AlternativTest		
STP       SignifikanzTestP
		
Urne		
Münze		
Würfel		
Rad       GlücksRad
		
MK        MarkoffKette
		
Roulette		
Chuck     ChuckALuck		
Craps		
Toto      FussballToto		
Lotto		
Skat      SkatBlatt
		
Vektor    analog zu agla		
Matrix    analog zu agla<jupyter_text>7. Hilfe-Informationenzufall verfügt über ein eingebautes HilfesystemHilfethemen können mit Hilfe() abgefragt werden Hilfe zur Erzeugung von Objekten kann jederzeit erhalten werden, indem in der Erzeugerfunktion des Objektes als letztes Argument h = 1 angegeben wird, etwa$\qquad$Urne(..., h=1)Das gilt auch für alle Funktions- und MethodenaufrufeZu einem existierenden Objekt ist die Liste der Namen seiner Eigenschaften und Methoden über die h-Eigenschaft erhältlich, etwa<jupyter_code>bv.h<jupyter_output>Eigenschaften und Methoden (M) für BinomialVerteilung
 
bv.hilfe               Bezeichner der Eigenschaften und Methoden
bv.e_sigma_umg         Sigma-Umgebungen des Erwartungswertes		
bv.erw                 Erwartungswert	
bv.erw_(...)        M  ebenso, zugehörige Methode	
bv.F(...)           M  Verteilungsfunktion
bv.faust_regel         Faustregeln
bv.formeln             Formeln
bv.graf_F              Graf der Verteilungsfunktion
bv.hist                Histogramm
bv.hist_(...)       M  ebenso, zugehörige Methode
bv.hist_kum            ebenso, kumulierte Wahrscheinlichkeiten
bv.n                   Anzahl Versuche
bv.n_omega             Größe der Ergebnismenge 
bv.nv_approx           Approximation durch Normalverteilung 
bv.omega               Ergebnismenge 
bv.p                   Trefferwahrscheinlichkeit
bv.P(...)           M  Wahrscheinlichkeit eines Ereignisses
bv.p_sigma_umg         Sigma-Umgebungen der Wahrscheinlichkeit
bv.poly_zug            Polygonzug-Diagramm der Wahrschei[...]
{'fraction_non_alphanumeric': 0.07823314410140758, 'fraction_numerical': 0.016719807138968815, 'mean_word_length': 3.762962962962963, 'pattern_counts': {'":': 0, '<': 125, '<?xml version=': 0, '>': 116, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '31', 'dir': 'jupyter-structured-clean-dedup', 'id': '535918', 'license': 'Apache-2.0', 'n_tokens_mistral': 4919, 'n_tokens_neox': 4812, 'n_words': 1169, 'path': 'zufall/demo/ipynb/a_hier_beginnen.ipynb', 'repo_name': 'HBOMAT/AglaUndZufall', 'size': '12896'}