import numpy as np
import matplotlib.pyplot as plt

def simulate_biased_coin_tosses(n, p, num_trials):
    """
    Simulates multiple trials of biased coin tosses and plots the running average.
    
    Args:
        n (int): Number of coin tosses in each trial.
        p (float): Probability of getting heads (biased coin).
        num_trials (int): Number of trials to simulate.
    """
    results = []
    
    for _ in range(num_trials):
        coin_tosses = np.random.choice([0, 1], size=n, p=[1-p, p])
        running_average = np.cumsum(coin_tosses) / np.arange(1, n + 1)
        results.append(running_average)
    
    # Plot the results
    for i, running_average in enumerate(results):
        plt.plot(np.arange(1, n + 1), running_average, alpha=0.5)
    
    # Plot the theoretical expectation (p for a biased coin)
    plt.plot(np.arange(1, n + 1), np.full(n, p), color='red', linestyle='--', label='Theoretical Expectation')
    
    plt.xlabel('Number of Tosses')
    plt.ylabel('Running Average')
    plt.title('Law of Large Numbers Simulation (Balanced Coin)')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
n = 100000  # Number of coin tosses in each trial
p = 0.5  # Probability of getting heads (biased coin)
num_trials = 1  # Number of trials to simulate

# Perform the simulation and visualize the results
simulate_biased_coin_tosses(n, p, num_trials)

import numpy as np
import matplotlib.pyplot as plt

def simulate_binomial_distribution(n, p, num_trials):
    """
    Simulates multiple trials of a binomial distribution and plots the histogram of outcomes.
    
    Args:
        n (int): Number of trials in each binomial experiment.
        p (float): Probability of success in each trial.
        num_trials (int): Number of trials to simulate.
    """
    results = np.random.binomial(n, p, size=num_trials)
    
    # Plot the histogram of outcomes
    plt.hist(results, bins=np.arange(n + 1) - 0.5, density=True, alpha=0.7, edgecolor='black')
    
    # Plot the theoretical probability mass function
    x = np.arange(n + 1)
    y = np.array([np.math.comb(n, k) * p**k * (1 - p)**(n - k) for k in x])
    plt.plot(x, y, color='red', label='Theoretical Probability')
    
    plt.xlabel('Number of Successes')
    plt.ylabel('Probability')
    plt.title(f'Binomial Distribution (n={n}, p={p})')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
n =10  # Number of trials in each binomial experiment
p = 0.5  # Probability of success in each trial
num_trials = 100000  # Number of trials to simulate

# Perform the simulation and visualize the results
simulate_binomial_distribution(n, p, num_trials)

# Importing libraries
import numpy as np
import pandas as pd
import seaborn as sns
from scipy.stats import norm
import matplotlib.pyplot as plt

# Function to simulate coin toss
def coin_toss(n, deviation):
    coin = np.random.choice([0, 1], size=n)  # Simulating coin toss
    proportion = np.mean(coin)  # Calculating proportion of Heads
    concentration = 2 * np.exp(-2 * n * deviation**2)  # Calculating Gaussian concentration
    return proportion, concentration

# Parameters for simulation
n_values = [10, 20, 30, 40, 50, 75, 100, 500, 1000, 10000]
deviation_values = [0.01, 0.03, 0.05, 0.07, 0.1, 0.15, 0.2, 0.25, 0.3, 0.5]

# Simulation and calculation of Gaussian concentration for each combination of parameters
results = []
for n in n_values:
    row = []
    for deviation in deviation_values:
        proportion, concentration = coin_toss(n, deviation)
        row.append(concentration)
    results.append(row)

# Creating DataFrame from results
df = pd.DataFrame(results, columns=deviation_values, index=n_values)

# Displaying results as a table
print("Number of coin tosses\t", end="")
for deviation in deviation_values:
    print(f"Deviation {deviation}\t", end="")
print()
for i, n in enumerate(n_values):
    row_str = f"{n}\t\t"
    for j, deviation in enumerate(deviation_values):
        row_str += f"{results[i][j]:.3e}\t"
    print(row_str)

# Creating heatmap with Seaborn
plt.figure(figsize=(12, 8))
sns.heatmap(data=df, annot=True, cmap="Reds", fmt=".2e", cbar=True, cbar_kws={'label': 'Gaussian concentration'})
plt.xlabel("Deviation")
plt.ylabel("Number of coin tosses")
plt.title("Gaussian concentration as a function of the deviation and the number of coin tosses")
plt.show()

# Importing libraries
import numpy as np
import pandas as pd
import seaborn as sns
from scipy.stats import norm
import matplotlib.pyplot as plt

# Function to simulate coin toss
def coin_toss(n, deviation):
    coin = np.random.choice([0, 1], size=n)  # Simulating coin toss
    proportion = np.mean(coin)  # Calculating proportion of Heads
    concentration = 2 * np.exp(-2 * n * deviation**2)  # Calculating Gaussian concentration
    return proportion, concentration

# Parameters for simulation
n_values = [10, 20, 30, 40, 100, 500, 1000]
deviation_values = [0.01, 0.03, 0.05, 0.1, 0.2]

# Simulation and calculation of Gaussian concentration for each combination of parameters
results = []
for n in n_values:
    row = []
    for deviation in deviation_values:
        proportion, concentration = coin_toss(n, deviation)
        row.append(concentration)
    results.append(row)

# Creating DataFrame from results
df = pd.DataFrame(results, columns=deviation_values, index=n_values)

# Displaying results as a table
print("Number of coin tosses\tDeviation 0.01\tDeviation 0.03\tDeviation 0.05\tDeviation 0.1\tDeviation 0.2")
for i, n in enumerate(n_values):
    row_str = f"{n}\t\t"
    for j, deviation in enumerate(deviation_values):
        row_str += f"{results[i][j]:.3e}\t"
    print(row_str)

# Creating the graph with Seaborn
sns.set(style="whitegrid")
plt.figure(figsize=(10, 6))
sns.lineplot(data=df, markers=True, dashes=False)
plt.xlabel("Number of coin tosses")
plt.ylabel("Gaussian concentration")
plt.title("Gaussian concentration as a function of the number of coin tosses and the deviation")
plt.legend(title="Deviation")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def simulate_ruin(player_a_amount, player_b_amount, win_probability):
    """
    Simulates the ruin of two players in a gambling game and returns the number of rounds played.
    
    Args:
        player_a_amount (int): Initial amount of money for player A.
        player_b_amount (int): Initial amount of money for player B.
        win_probability (float): Probability of winning a bet.
        
    Returns:
        int: Number of rounds played until one of the players goes broke.
    """
    rounds = 0
    
    while player_a_amount > 0 and player_b_amount > 0:
        # Simulate a round of the game
        if np.random.rand() < win_probability:
            player_a_amount += 1  # Player A wins
            player_b_amount -= 1  # Player B loses
        else:
            player_a_amount -= 1  # Player A loses
            player_b_amount += 1  # Player B wins
        
        rounds += 1
    
    return rounds

def simulate_ruin_visual(player_a_amount, player_b_amount, win_probability):
    """
    Simulates the ruin of two players in a gambling game with a biased coin and visualizes the results.
    
    Args:
        player_a_amount (int): Initial amount of money for player A.
        player_b_amount (int): Initial amount of money for player B.
        win_probability (float): Probability of winning a bet.
    """
    player_a_history = [player_a_amount]
    player_b_history = [player_b_amount]
    rounds = 0
    
    while player_a_amount > 0 and player_b_amount > 0:
        # Simulate a round of the game with a biased coin
        if np.random.rand() < win_probability:
            player_a_amount += 1  # Player A wins
            player_b_amount -= 1  # Player B loses
        else:
            player_a_amount -= 1  # Player A loses
            player_b_amount += 1  # Player B wins
        
        rounds += 1
        player_a_history.append(player_a_amount)
        player_b_history.append(player_b_amount)
    
    # Plot the results
    plt.plot(player_a_history, label='Geralt fortune')
    plt.plot(player_b_history, label='Casino fortune')
    plt.xlabel('Rounds')
    plt.ylabel('Amount')
    plt.title('Players Ruin Simulation (Balanced Coin)')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
player_a_amount = 1000  # Initial amount of money for player A
player_b_amount = 1000  # Initial amount of money for player B
win_probability = 0.5  # Probability of winning a bet (balanced coin)

# Perform the simulation and get the number of rounds played
rounds_played = simulate_ruin(player_a_amount, player_b_amount, win_probability)
print("Number of rounds played:", rounds_played)

# Perform the simulation and visualize the results
simulate_ruin_visual(player_a_amount, player_b_amount, win_probability)