Home

📚 Spieltheorie – Ein mehrteiliges Tutorial

Was ist Spieltheorie? Historie, Anwendungen, Übungen & Python-Simulationen

🎮 Teil 1: Was ist Spieltheorie?

Spieltheorie ist ein mathematischer und wissenschaftlicher Ansatz, der darauf abzielt, Entscheidungen von Agenten (wie Menschen, Unternehmen, Staaten) in Situationen zu analysieren, in denen die Entscheidung eines Agenten die Auswirkungen auf andere Agenten hat.

Kernidee: „Was ich tue, hängt von dem, was andere tun – und was sie glauben, dass ich tue.“

Beispiel: Zwei Unternehmen entscheiden, ob sie einen Preisanstieg machen oder nicht. Wenn beide Preise senken, gewinnen sie mehr Kunden – aber wenn einer preiswert bleibt, gewinnt er Kunden.

📚 Teil 2: Historie der Spieltheorie

Wichtige Persönlichkeiten:

🚀 Teil 3: Anwendungen der Spieltheorie

  1. Ökonomie & Wirtschaft: Preisgestaltung, Auktionen, Marktstruktur (z. B. Oligopol).
  2. Politik & Internationale Beziehungen: Kriegsentscheidungen, Verhandlungen (z. B. Frieden vs. Krieg).
  3. Biologie: Evolutionäre Strategien – warum Tiere kooperieren oder nicht.
  4. Informatik & KI: Strategien in Spielen (z. B. Schach, AlphaGo), Verhalten von Robotern.
  5. Sozialwissenschaften & Psychologie: Verhalten in Gruppen, Glaube an Gerechtigkeit (z. B. „Trust Game“).
  6. Kultur & Gesellschaft: Sozialverhalten, Informationsverbreitung in Netzwerken.

🧠 Teil 4: Was ist noch interessant?

Nash-Gleichgewicht: Kein Spieler kann durch eine Änderung seiner Strategie besser werden – aber es ist nicht immer das beste Ergebnis.
Spieltheorie mit Unsicherheit: Harsanyi – Bayes’sche Spieltheorie (Jeder schätzt, was der andere tut).
Dynamische Spiele: Entscheidungen erfolgen nacheinander (z. B. Verhandlungen, Wachstum).
Spieltheorie & Ethik: Gibt es moralisch bessere Entscheidungen als rationale? (z. B. nicht verraten, wenn man weiß, dass der andere nicht handelt).

🎯 Teil 5: Gefangenen-Dilemma – Schritt für Schritt

1. Entscheidungstabelle

Spiele A \\ Spieler B Verraten Schweigen
Verraten (2, 2) (0, 3)
Schweigen (3, 0) (1, 1)

2. Nash-Gleichgewicht

Beide Spieler wählen „Verraten“ → Ergebnis: (2, 2)
Warum? Für jeden Spieler ist „Verraten“ immer die beste Antwort – egal was der andere wählt.

3. Warum ist es „paradox“?

Die rationale Entscheidung für jeden ist: Verraten.

Wenn beide schweigen → (1,1): besseres Ergebnis für beide.

Aber: Wenn beide verraten → (2,2): schlechtes Ergebnis.

Paradox: Individuelle Rationalität führt zu gemeinsam schlechtem Ergebnis.

💻 Teil 6: Python-Code – Grafische Simulation

Ein Python-Code mit matplotlib zeigt die Entscheidungstabelle grafisch.

import matplotlib.pyplot as plt
import numpy as np

# Spieltheorie: Gefangenen-Dilemma
OUTCOMES = [
    [(2, 2), (0, 3)],  # A: Verraten
    [(3, 0), (1, 1)]    # A: Schweigen
]

labels_A = ["Verraten", "Schweigen"]
labels_B = ["Verraten", "Schweigen"]

fig, ax = plt.subplots(figsize=(10, 8))
ax.set_xticks([0.5, 1.5], labels=labels_A)
ax.set_yticks([0.5, 1.5], labels=labels_B)

for i in range(2):
    for j in range(2):
        val = OUTCOMES[i][j]
        ax.text(j + 0.5, i + 0.5, f"({val[0]}, {val[1]})", 
                ha='center', va='center', fontsize=14, 
                bbox=dict(boxstyle="round,pad=0.3", facecolor="lightyellow", alpha=0.8))

ax.set_title("Gefangenen-Dilemma – Entscheidungstabelle", fontsize=16, fontweight='bold')
ax.set_xlabel("Strategie von Spieler A", fontsize=12)
ax.set_ylabel("Strategie von Spieler B", fontsize=12)

ax.text(1.5, 1.5, "Nash-Gleichgewicht\n(Verraten, Verraten)", 
        ha='center', va='center', fontsize=14, 
        bbox=dict(boxstyle="round,pad=0.3", facecolor="red", alpha=0.7))

ax.grid(True, linestyle='--', alpha=0.5)
plt.tight_layout()
plt.show()

🎮 Teil 7: Gefangenen-Dilemma als Spiel (mit GUI – Tkinter)

Ein interaktives Spiel, in dem Benutzer „Verraten“ oder „Schweigen“ wählen können.

import tkinter as tk
from tkinter import messagebox, Label, Button, Frame, StringVar

OUTCOMES = [
    [(2, 2), (0, 3)],
    [(3, 0), (1, 1)]
]

def get_result_text(a_choice, b_choice):
    outcome = OUTCOMES[a_choice][b_choice]
    return f"Ergebnis: Spieler A → {outcome[0]} Jahre, Spieler B → {outcome[1]} Jahre"

class PrisonerDilemmaGame:
    def __init__(self, root):
        self.root = root
        self.root.title("Gefangenen-Dilemma – Spiel")
        self.root.geometry("600x500")

        title_label = Label(root, text="Gefangenen-Dilemma – Spiel", 
                            font=("Arial", 18, "bold"), bg="#f0f0f0", fg="#2c3e50")
        title_label.pack(pady=20)

        table_text = """
        | Spieler A \\ Spieler B | Verraten     | Schweigen    |
        |------------------------|-------------|-------------|
        | Verraten               | (2,2)       | (0,3)       |
        | Schweigen              | (3,0)       | (1,1)       |
        """
        table_label = Label(root, text=table_text, font=("Arial", 12), bg="#f0f0f0", fg="#2c3e50")
        table_label.pack(anchor="w", padx=20)

        # Auswahl-Boxen
        selection_frame = Frame(root, bg="#f0f0f0", padx=20, pady=10)
        selection_frame.pack(pady=20)

        # Spieler A
        a_label = Label(selection_frame, text="Spieler A wählen:", font=("Arial", 14"))
        a_label.pack(anchor="w", padx=10, pady=5)

        a_button_v = Button(selection_frame, text="Verraten", width=15, height=2, bg="#e74c3c", fg="white")
        a_button_v.pack(pady=5)

        a_button_s = Button(selection_frame, text="Schweigen", width=15, height=2, bg="#2ecc71", fg="white")
        a_button_s.pack(pady=5)

        # Spieler B
        b_label = Label(selection_frame, text="Spieler B wählen:", font=("Arial", 0, 14"))
        b_label.pack(anchor="w", padx=10, pady=10)

        b_button_v = Button(selection_frame, text="Verraten", width=15, height=2, bg="#e74c3c", fg="white")
        b_button_v.pack(pady=5)

        b_button_s = Button(selection_frame, text="Schweigen", width=15, height=2, bg="#2ecc71", fg="white")
        b_button_s.pack(pady=5)

        # Ergebnis
        self.result_label = Label(root, text="Ergebnis: ", font=("Arial", 16, "bold"), fg="#e74c3c", pady=20)
        self.result_label.pack(pady=20)

        info_label = Label(root, text="Warum ist das paradox?\n→ Individuelle Rationalität führt zu schlechtem Ergebnis.", 
                           font=("Arial", 10), fg="#7f8c8d", wraplength=500)
        info_label.pack(pady=10)

        nash_label = Label(root, text="Nash-Gleichgewicht: (Verraten, Verraten)", 
                           font=("Arial", 12, "bold"), fg="#e74c3c")
        nash_label.pack()

    def update_choice(self, player, choice):
        # ... (wie oben)
        pass

if __name__ == "__main__":
    root = tk.Tk()
    game = PrisonerDilemmaGame(root)
    root.mainloop()

🤝 Teil 8: Gefangenen-Dilemma mit Vertrauen – ein kooperatives Spiel

Ein erweitertes Spiel, bei dem Spieler „Vertrauen“ wählen können – und somit kooperatives Verhalten fördern.

import tkinter as tk
from tkinter import messagebox, Label, Button, Frame, StringVar

OUTCOMES = [
    [(2, 2), (0, 3), (3, 0)],  # A: Verraten
    [(1, 1), (1, 1), (1, 1)]    # A: Vertrauen
]

def get_result_text(a_choice, b_choice):
    outcome = OUTCOMES[a_choice][b_choice]
    return f"Ergebnis: Spieler A → {outcome[0]} Jahre, Spieler B → {outcome[1]} Jahre"

class TrustPrisonerDilemma:
    def __init__(self, root):
        self.root = root
        self.root.title("Gefangenen-Dilemma mit Vertrauen")
        self.root.geometry("650x600")

        title_label = Label(root, text="Gefangenen-Dilemma mit Vertrauen", 
                            font=("Arial", 18, "bold"), bg="#f0f0f0", fg="#2c3e50")
        title_label.pack(pady=20)

        table_text = """
        | Spieler A \\ Spieler B | Verraten     | Schweigen    | Vertrauen     |
        |------------------------|-------------|-------------|--------------|
        | Verraten               | (2,2)       | (0,3)       | (3,0)        |
        | Vertrauen              | (1,1)       | (1,1)       | (1,1)        |
        """
        table_label = Label(root, text=table_text, font=("Arial", 12), bg="#f0f0f0", fg="#2c3e50")
        table_label.pack(anchor="w", padx=20)

        # Auswahl-Boxen
        selection_frame = Frame(root, bg="#f0f0f0", padx=20, pady=10)
        selection_frame.pack(pady=20)

        # Spieler A
        a_label = Label(selection_frame, text="Spieler A wählen:", font=("Arial", 14"))
        a_label.pack(anchor="w", padx=10, pady=5)

        a_button_v = Button(selection_frame, text="Verraten", width=15, height=2, bg="#e74c3c", fg="white")
        a_button_v.pack(pady=5)

        a_button_t = Button(selection_frame, text="Vertrauen", width=15, height=2, bg="#3498db", fg="white")
        a_button_t.pack(pady=5)

        # Spieler B
        b_label = Label(selection_frame, text="Spieler B wählen:", font=("Arial", 14"))
        b_label.pack(anchor="w", padx=10, pady=10)

        b_button_v = Button(selection_frame, text="Verraten", width=15, height=2, bg="#e74c3c", fg="white")
        b_button_v.pack(pady=5)

        b_button_s = Button(selection_frame, text="Schweigen", width=15, height=2, bg="#2ecc71", fg="white")
        b_button_s.pack(pady=5)

        b_button_t = Button(selection_frame, text="Vertrauen", width=15, height=2, bg="#3498db", fg="white")
        b_button_t.pack(pady=5)

        # Ergebnis
        self.result_label = Label(root, text="Ergebnis: ", font=("Arial", 16, "bold"), fg="#e74c3c", pady=20)
        self.result_label.pack(pady=20)

        info_label = Label(root, text="Warum ist Vertrauen wichtig?\n-> Beide vertrauen -> (1,1): nur 1 Jahr!\n-> Wenn ein Spieler vertraut, aber der andere verrät -> 3 Jahre für den Vertrauenden!\n-> Vertrauen ist entscheidend in Wirtschaft, Politik und Beziehungen!", 
                           font=("Arial", 10), fg="#7f8c8d", wraplength=550)
        info_label.pack(pady=15)

        best_label = Label(root, text="Beste Ergebnisse: Beide vertrauen -> (1,1)", 
                           font=("Arial", 12, "bold"), fg="#27ae60")
        best_label.pack()

    def update_choice(self, player, choice):
        # ... (wie oben)
        pass

if __name__ == "__main__":
    root = tk.Tk()
    game = TrustPrisonerDilemma(root)
    root.mainloop()

✅ Fazit & Tipp

Das Gefangenen-Dilemma ist nicht nur ein mathematisches Spiel – es ist eine lebensnahe Erklärung für viele realweltliche Entscheidungen.