Theoretical Probability: Burst Breaks Independence

from fractions import Fraction
from typing import List, Any, Callable
from io.thecodeforge.probability.models import ProbabilitySpace

class TheoreticalProbability:
    """
    Production-grade theoretical probability calculator
    with exact fractional arithmetic for precision.
    """
    
    def __init__(self, sample_space: List[Any]):
        self.sample_space = sample_space
        self.total_outcomes = len(sample_space)
    
    def probability_of(self, event_condition: Callable[[Any], bool]) -> Fraction:
        """
        Calculate theoretical probability using exact fractions
        to avoid floating-point precision errors.
        """
        favorable = sum(1 for outcome in self.sample_space 
                       if event_condition(outcome))
        
        if favorable == 0:
            return Fraction(0)
        if favorable == self.total_outcomes:
            return Fraction(1)
        
        return Fraction(favorable, self.total_outcomes)
    
    def probability_of_complement(self, event_condition: Callable[[Any], bool]) -> Fraction:
        """
        P(not A) = 1 - P(A)
        """
        return Fraction(1) - self.probability_of(event_condition)
    
    def conditional_probability(
        self,
        event_a: Callable[[Any], bool],
        event_b: Callable[[Any], bool]
    ) -> Fraction:
        """
        P(A|B) = P(A and B) / P(B)
        Returns zero if P(B) = 0 to handle edge cases safely.
        """
        p_b = self.probability_of(event_b)
        if p_b == 0:
            return Fraction(0)
        
        both = sum(1 for outcome in self.sample_space
                  if event_a(outcome) and event_b(outcome))
        
        return Fraction(both, self.total_outcomes) / p_b


# Example: Fair six-sided die
die_faces = [1, 2, 3, 4, 5, 6]
prob = TheoreticalProbability(die_faces)

# P(rolling even) = 3/6 = 1/2
p_even = prob.probability_of(lambda x: x % 2 == 0)
print(f"P(even) = {p_even} = {float(p_even):.4f}")

# P(rolling > 4) = 2/6 = 1/3
p_greater_than_4 = prob.probability_of(lambda x: x > 4)
print(f"P(> 4) = {p_greater_than_4} = {float(p_greater_than_4):.4f}")

import numpy as np
from typing import Tuple
from io.thecodeforge.statistics import ConfidenceInterval

def compare_theoretical_experimental(
    theoretical_prob: float,
    observed_successes: int,
    total_trials: int,
    confidence_level: float = 0.95
) -> dict:
    """
    Compare theoretical probability against experimental results
    and determine if the difference is statistically significant.
    """
    experimental_prob = observed_successes / total_trials
    
    # Calculate standard error for binomial proportion
    se = np.sqrt(experimental_prob * (1 - experimental_prob) / total_trials)
    
    # Z-score for confidence level
    z_score = ConfidenceInterval.z_for_confidence(confidence_level)
    
    ci_lower = experimental_prob - z_score * se
    ci_upper = experimental_prob + z_score * se
    
    # Check if theoretical value falls within confidence interval
    is_consistent = ci_lower <= theoretical_prob <= ci_upper
    
    # Calculate effect size (Cohen's h for proportions)
    cohens_h = 2 * np.arcsin(np.sqrt(experimental_prob)) - \
               2 * np.arcsin(np.sqrt(theoretical_prob))
    
    return {
        "theoretical_probability": theoretical_prob,
        "experimental_probability": experimental_prob,
        "confidence_interval": (ci_lower, ci_upper),
        "is_consistent_with_theory": is_consistent,
        "effect_size": cohens_h,
        "trials_needed_for_convergence": max(10000, int(1 / (se ** 2)))
    }


# Example: Testing coin fairness
result = compare_theoretical_experimental(
    theoretical_prob=0.5,
    observed_successes=503,
    total_trials=1000
)
print(f"Theoretical: {result['theoretical_probability']}")
print(f"Experimental: {result['experimental_probability']:.4f}")
print(f"Consistent: {result['is_consistent_with_theory']}")

from fractions import Fraction
from itertools import product
from io.thecodeforge.probability.models import ProbabilityCalculator

class ProbabilityRules:
    """
    Implementation of fundamental probability rules
    using exact arithmetic for production accuracy.
    """
    
    @staticmethod
    def addition_rule(
        p_a: Fraction,
        p_b: Fraction,
        p_both: Fraction = None
    ) -> Fraction:
        """
        General Addition Rule:
        P(A or B) = P(A) + P(B) - P(A and B)
        
        For mutually exclusive events, P(A and B) = 0.
        """
        if p_both is None:
            # Assume mutually exclusive
            p_both = Fraction(0)
        return p_a + p_b - p_both
    
    @staticmethod
    def multiplication_rule(
        p_a: Fraction,
        p_b_given_a: Fraction
    ) -> Fraction:
        """
        General Multiplication Rule:
        P(A and B) = P(A) × P(B|A)
        
        For independent events, P(B|A) = P(B).
        """
        return p_a * p_b_given_a
    
    @staticmethod
    def bayes_theorem(
        p_a_given_b: Fraction,
        p_b: Fraction,
        p_a: Fraction
    ) -> Fraction:
        """
        Bayes' Theorem:
        P(B|A) = P(A|B) × P(B) / P(A)
        
        Critical for updating probabilities based on new evidence.
        """
        if p_a == 0:
            return Fraction(0)
        return (p_a_given_b * p_b) / p_a
    
    @staticmethod
    def complement(p_a: Fraction) -> Fraction:
        """
        Complement Rule:
        P(not A) = 1 - P(A)
        """
        return Fraction(1) - p_a
    
    @staticmethod
    def independent_events_chain(probabilities: list) -> Fraction:
        """
        For n independent events:
        P(A1 and A2 and ... and An) = P(A1) × P(A2) × ... × P(An)
        
        Used in reliability engineering for series systems.
        """
        result = Fraction(1)
        for p in probabilities:
            result *= p
        return result


# Example: System reliability calculation
# Three independent components with 99.9% uptime each
component_reliability = Fraction(999, 1000)
system_reliability = ProbabilityRules.independent_events_chain(
    [component_reliability] * 3
)
print(f"System reliability: {system_reliability} = {float(system_reliability):.6f}")
# Output: 0.997003 — three nines become less with three components

from fractions import Fraction
from itertools import product, combinations
from io.thecodeforge.probability.enumeration import SampleSpaceGenerator

class ProbabilityExamples:
    """
    Common theoretical probability examples with
    exhaustive enumeration for verification.
    """
    
    @staticmethod
    def coin_flips(n_coins: int, target_heads: int) -> dict:
        """
        Calculate probability of exactly k heads in n coin flips.
        Uses binomial coefficient for efficiency.
        """
        from math import comb
        
        total_outcomes = 2 ** n_coins
        favorable_outcomes = comb(n_coins, target_heads)
        
        return {
            "probability": Fraction(favorable_outcomes, total_outcomes),
            "favorable": favorable_outcomes,
            "total": total_outcomes,
            "decimal": favorable_outcomes / total_outcomes
        }
    
    @staticmethod
    def dice_sum(target: int, num_dice: int = 2) -> dict:
        """
        Calculate probability of getting a specific sum
        with multiple dice rolls.
        """
        sample_space = list(product(range(1, 7), repeat=num_dice))
        favorable = [outcome for outcome in sample_space 
                    if sum(outcome) == target]
        
        return {
            "probability": Fraction(len(favorable), len(sample_space)),
            "favorable_outcomes": favorable,
            "total_outcomes": len(sample_space)
        }
    
    @staticmethod
    def card_probability(
        suit: str = None,
        rank: str = None,
        is_face_card: bool = False
    ) -> Fraction:
        """
        Calculate probability for various card drawing scenarios.
        """
        total = 52
        
        if suit and rank:
            favorable = 1
        elif suit:
            favorable = 13
        elif rank:
            favorable = 4
        elif is_face_card:
            favorable = 12
        else:
            favorable = 0
        
        return Fraction(favorable, total)
    
    @staticmethod
    def at_least_one(event_prob: Fraction, trials: int) -> Fraction:
        """
        P(at least one success) = 1 - P(all failures)
        P(all failures) = (1 - p)^n
        
        Critical for reliability calculations.
        """
        p_failure = Fraction(1) - event_prob
        p_all_failures = p_failure ** trials
        return Fraction(1) - p_all_failures


# Example: At least one service failure
# Given 0.1% failure rate per request, 10000 requests
single_failure_rate = Fraction(1, 1000)
at_least_one_failure = ProbabilityExamples.at_least_one(
    single_failure_rate, 10000
)
print(f"P(at least one failure in 10000 requests): {float(at_least_one_failure):.4f}")
# Output: ~0.99995 — near certainty despite low per-request rate

from fractions import Fraction
from dataclasses import dataclass
from typing import List
from io.thecodeforge.reliability import SystemModel

@dataclass
class ServiceLevelAgreement:
    """
    SLA calculation using theoretical probability.
    """
    target_availability: float  # e.g., 0.9999 for four nines
    num_components: int
    component_reliability: float
    
    def calculate_system_reliability(self) -> float:
        """
        For independent components in series:
        R_system = R1 × R2 × ... × Rn
        """
        return self.component_reliability ** self.num_components
    
    def required_component_reliability(self) -> float:
        """
        Given target system reliability, calculate required
        per-component reliability.
        
        R_component = R_system ^ (1/n)
        """
        return self.target_availability ** (1 / self.num_components)
    
    def max_allowed_downtime_minutes_per_year(self) -> float:
        """
        Convert availability percentage to downtime.
        """
        minutes_per_year = 365.25 * 24 * 60
        return minutes_per_year * (1 - self.target_availability)


class LoadBalancerProbability:
    """
    Theoretical probability models for load balancing.
    """
    
    @staticmethod
    def probability_all_requests_to_one_server(
        num_servers: int,
        num_requests: int
    ) -> Fraction:
        """
        P(all requests to single server) with random distribution.
        This is the "thundering herd" worst case.
        """
        # Each request independently picks a server
        # P(all pick server i) = (1/n)^requests for one server
        # P(all pick same server) = n × (1/n)^requests
        single_server_prob = Fraction(1, num_servers) ** num_requests
        return num_servers * single_server_prob
    
    @staticmethod
    def expected_requests_per_server(
        total_requests: int,
        num_servers: int
    ) -> float:
        """
        Expected load per server with uniform random distribution.
        """
        return total_requests / num_servers


# Example: SLA calculation
sla = ServiceLevelAgreement(
    target_availability=0.9999,
    num_components=10,
    component_reliability=0.9999
)
print(f"System reliability: {sla.calculate_system_reliability():.6f}")
print(f"Required per-component: {sla.required_component_reliability():.6f}")
print(f"Max downtime: {sla.max_allowed_downtime_minutes_per_year():.2f} min/year")