Upload 3 files

src/mm_predictor.py

@@ -0,0 +1,217 @@
+import pandas as pd
+import random
+from collections import Counter
+from datetime import timedelta
+
+def is_sum_in_range(numbers, min_sum, max_sum):
+    total = sum(numbers)
+    return min_sum <= total <= max_sum
+
+def mm_predict_star_ball(df, star_probs=None):
+    from collections import Counter
+    from datetime import timedelta
+    import random
+
+    cutoff_sb = df["Date"].max() - timedelta(days=30)
+    recent_starballs = df[df["Date"] >= cutoff_sb]["MB"].astype(int).tolist()
+
+    star_freq_all = Counter(df["MB"].astype(int))
+    star_freq_recent = Counter(recent_starballs)
+
+    star_probs = star_probs or {}
+
+    star_ball_weights = {}
+    for sb in range(1, 25):   #MegaMillions Starball is 1-24 
+        w = (
+            star_freq_all.get(sb, 0) * 0.6 +
+            star_freq_recent.get(sb, 0) * 0.2 +
+            star_probs.get(sb, 0) * 0.2
+        )
+        star_ball_weights[sb] = w
+
+    elements, weight_vals = zip(*star_ball_weights.items())
+    return random.choices(elements, weights=weight_vals, k=1)[0]
+
+
+def weighted_choice(counter_dict, k=1):
+    elements, weights = zip(*counter_dict.items())
+    return random.choices(elements, weights=weights, k=k)
+
+
+def get_ml_number_probs(df):
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import OneHotEncoder
+    from sklearn.pipeline import make_pipeline
+    import numpy as np
+
+    df["Date"] = pd.to_datetime(df["Date"])
+    df["DayOfWeek"] = df["Date"].dt.dayofweek
+
+    # PRE-PROCESS THE DATA
+    records = []
+    for _, row in df.iterrows():
+        for col in ['1', '2', '3', '4', '5']:
+            records.append({
+                "DayOfWeek": row["Date"].dayofweek,
+                "DrawNumber": int(row[col])
+            })
+    data = pd.DataFrame(records)
+
+    X = data[["DayOfWeek"]]
+    y = data["DrawNumber"]
+
+    model = make_pipeline(
+        OneHotEncoder(),
+        RandomForestClassifier(n_estimators=100, random_state=42)
+    )
+    model.fit(X, y)
+
+    latest_day = df["Date"].max().dayofweek
+    X_predict = pd.DataFrame({"DayOfWeek": [latest_day] * 70})
+    X_predict["Num"] = list(range(1, 71))
+
+    probs = model.predict_proba(X_predict[["DayOfWeek"]])
+    number_probs = dict(zip(model.classes_, probs[0]))
+
+    return number_probs
+
+
+def generate_mm_prediction(df, allow_sequences=True):
+    
+    NUMBER_RANGE = range(1, 71)  # MegaMillions RANGE
+
+    df["Date"] = pd.to_datetime(df["Date"])
+    df = df.sort_values("Date", ascending=False)
+
+    last_draw = df.iloc[0][['1', '2', '3', '4', '5']].astype(int).tolist()
+    
+    flat_all = df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_all = Counter(flat_all)
+
+    cutoff = df["Date"].max() - timedelta(days=30)
+    recent_df = df[df["Date"] >= cutoff]
+    flat_recent = recent_df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_recent = Counter(flat_recent)
+
+    # PICK A NUMBER FROM THE LAST DRAW (FREQUENCY BASED)
+    intersection = set(last_draw) & set(freq_all.keys())
+    if intersection:
+        weights = {n: freq_all[n] for n in intersection}
+        selected = [weighted_choice(weights)[0]]
+        #print(f"🔹 First Number (From previous Draw): {selected[0]}")
+    else:
+        selected = [weighted_choice(freq_all)[0]]
+
+    number_probs = get_ml_number_probs(df)
+
+    # WEIGHTED NUMBER POOL (ALL FREQUENCY %60 - LAST 30 DAYS %20 - MACHINE LEARNING %20)
+    combined_weights = {}
+    for num in NUMBER_RANGE:
+        if num not in selected:
+            w = (
+            freq_all.get(num, 0) * 0.6 +   #* 0.6 +
+            freq_recent.get(num, 0) *0.2 + #* 0.2 +
+            number_probs.get(num, 0) *0.2 #* 0.2
+            )
+            #print(f"Number {num}: w = {w:.4f} (freq_all={freq_all.get(num, 0)}, freq_recent={freq_recent.get(num, 0)}, ml={number_probs.get(num, 0):.4f})")
+            combined_weights[num] = w
+    
+
+    # SEQUENCE NUMBERS PART
+    seq_pair = []
+    if allow_sequences:
+        for _ in range(5):
+            pool = sorted(set(weighted_choice(combined_weights, 20)))
+            adjacent_pairs = []
+            #print(f"there is pool variable: {pool}")
+            for i in range(len(pool) - 1):
+                if pool[i] + 1 == pool[i + 1]:
+                    adjacent_pairs.append([pool[i], pool[i + 1]])
+            if adjacent_pairs:
+                seq_pair = random.choice(adjacent_pairs)  # 🔄 Rastgele ardışık çift seç
+                break
+
+        if seq_pair:
+            selected += seq_pair
+            #print(f"🔗 Sequencial Numbers are selected: {seq_pair}")
+            for n in seq_pair:
+                combined_weights.pop(n, None)
+
+
+    # MAKE IT 5 AGAIN
+    while len(selected) < 5:
+        pick = weighted_choice(combined_weights)[0]
+        if pick not in selected:
+            #print(f"➕ Weighted Number is added (combined_weights): {pick}")
+            selected.append(pick)
+            combined_weights.pop(pick, None)
+
+
+    # Parity FIXING (2-3 / 3-2)
+    while True:
+        even = [n for n in selected if n % 2 == 0]
+        odd = [n for n in selected if n % 2 == 1]
+        #print(f"Current parity: {len(even)} even, {len(odd)} odd -> {selected}")
+
+        
+        if len(even) in [2, 3] and len(odd) in [2, 3]:
+            #print("✅ Parity OK. Breaking loop.")
+            break
+            
+        for i, num in enumerate(selected):
+            if len(even) in [2, 3] and len(odd) in [2, 3]:
+                break
+            elif len(even) > 3 or len(odd) < 2:
+                target_parity = 1
+            else:
+                target_parity = 0
+            
+            parity_pool = {
+                n: w for n, w in combined_weights.items()
+                if n % 2 == target_parity and n not in selected
+            }
+
+            if parity_pool:
+                r = weighted_choice(parity_pool)[0]
+                #print(f"♻️ Parity Fixing → {selected[i]} instead of {r}")
+                selected[i] = r
+                even = [n for n in selected if n % 2 == 0]
+                odd = [n for n in selected if n % 2 == 1]
+
+                #break
+
+
+    # print("✅ Final selected:", sorted(selected))
+    while not is_sum_in_range(selected, 75, 280):
+        return generate_mm_prediction(df, allow_sequences)
+    return sorted(selected)
+
+    
+def get_hot_and_cold_numbers(df, top_n=10):
+    from collections import Counter
+
+    NUMBER_RANGE = range(1, 71)  # MegaMillions: 1–70
+
+    flat_all = df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_all = Counter(flat_all)
+
+    freq_sorted = sorted(freq_all.items(), key=lambda x: x[1], reverse=True)
+
+    hot = freq_sorted[:top_n]
+    cold = sorted(freq_sorted[-top_n:], key=lambda x: x[1])
+
+    return hot, cold
+
+
+if __name__ == "__main__":
+    import pandas as pd
+    df = pd.read_csv("../data/mm_results.csv")  
+    result = generate_mm_prediction(df)
+
+    predicted_star_ball = mm_predict_star_ball(df)
+    print(f"🌟 Predicted Star Ball: {predicted_star_ball}")
+
+    #print("Final result:", result)
+
+    

src/pb_predictor.py

@@ -0,0 +1,229 @@
+import pandas as pd
+import random
+from collections import Counter
+from datetime import timedelta
+
+def clean_powerball_df(raw_df):
+    #DELETE THE ROWS WHICH CONTAINS "DOUBLE PLAY"
+
+    df = raw_df[~raw_df["DrawDate"].str.contains("Double Play", na=False)].copy()
+    df["Date"] = pd.to_datetime(df["DrawDate"])
+    return df
+
+
+
+
+def is_sum_in_range(numbers, min_sum, max_sum):
+    total = sum(numbers)
+    return min_sum <= total <= max_sum
+
+def pb_predict_star_ball(df, star_probs=None):
+    from collections import Counter
+    from datetime import timedelta
+    import random
+
+    cutoff_sb = df["Date"].max() - timedelta(days=30)
+    recent_starballs = df[df["Date"] >= cutoff_sb]["PB"].astype(int).tolist()
+
+    star_freq_all = Counter(df["PB"].astype(int))
+    star_freq_recent = Counter(recent_starballs)
+
+    star_probs = star_probs or {}
+
+    star_ball_weights = {}
+    for sb in range(1, 27):   #Powerball's Starball is 1-26 
+        w = (
+            star_freq_all.get(sb, 0) * 0.6 +
+            star_freq_recent.get(sb, 0) * 0.2 +
+            star_probs.get(sb, 0) * 0.2
+        )
+        star_ball_weights[sb] = w
+
+    elements, weight_vals = zip(*star_ball_weights.items())
+    return random.choices(elements, weights=weight_vals, k=1)[0]
+
+
+def weighted_choice(counter_dict, k=1):
+    elements, weights = zip(*counter_dict.items())
+    return random.choices(elements, weights=weights, k=k)
+
+
+def get_ml_number_probs(df):
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import OneHotEncoder
+    from sklearn.pipeline import make_pipeline
+    import numpy as np
+
+    df["Date"] = pd.to_datetime(df["DrawDate"])
+    df["DayOfWeek"] = df["Date"].dt.dayofweek
+
+    # PRE-PROCESS THE DATA
+    records = []
+    for _, row in df.iterrows():
+        for col in ['1', '2', '3', '4', '5']:
+            records.append({
+                "DayOfWeek": row["Date"].dayofweek,
+                "DrawNumber": int(row[col])
+            })
+    data = pd.DataFrame(records)
+
+    X = data[["DayOfWeek"]]
+    y = data["DrawNumber"]
+
+    model = make_pipeline(
+        OneHotEncoder(),
+        RandomForestClassifier(n_estimators=100, random_state=42)
+    )
+    model.fit(X, y)
+
+    latest_day = df["Date"].max().dayofweek
+    X_predict = pd.DataFrame({"DayOfWeek": [latest_day] * 69})  #PowerBall 1-69
+    X_predict["Num"] = list(range(1, 70))  #PowerBall 1-69
+
+    probs = model.predict_proba(X_predict[["DayOfWeek"]])
+    number_probs = dict(zip(model.classes_, probs[0]))
+
+    return number_probs
+
+
+def generate_pb_prediction(df, allow_sequences=True):
+    
+
+    NUMBER_RANGE = range(1, 70)  # Powerball RANGE
+
+    df = df.sort_values("Date", ascending=False)
+
+    last_draw = df.iloc[0][['1', '2', '3', '4', '5']].astype(int).tolist()
+    flat_all = df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_all = Counter(flat_all)
+
+    cutoff = df["Date"].max() - timedelta(days=30)
+    recent_df = df[df["Date"] >= cutoff]
+    flat_recent = recent_df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_recent = Counter(flat_recent)
+
+    # PICK A NUMBER FROM THE LAST DRAW (FREQUENCY BASED)
+    intersection = set(last_draw) & set(freq_all.keys())
+    if intersection:
+        weights = {n: freq_all[n] for n in intersection}
+        selected = [weighted_choice(weights)[0]]
+        #print(f"🔹 First Number (From previous Draw): {selected[0]}")
+    else:
+        selected = [weighted_choice(freq_all)[0]]
+
+    number_probs = get_ml_number_probs(df)
+
+    # WEIGHTED NUMBER POOL (ALL FREQUENCY %60 - LAST 30 DAYS %20 - MACHINE LEARNING %20)
+    combined_weights = {}
+    for num in NUMBER_RANGE:
+        if num not in selected:
+            w = (
+            freq_all.get(num, 0) * 0.6 +   #* 0.6 +
+            freq_recent.get(num, 0) *0.2 + #* 0.2 +
+            number_probs.get(num, 0) *0.2 #* 0.2
+            )
+            #print(f"Number {num}: w = {w:.4f} (freq_all={freq_all.get(num, 0)}, freq_recent={freq_recent.get(num, 0)}, ml={number_probs.get(num, 0):.4f})")
+            combined_weights[num] = w
+    
+
+    # SEQUENCE NUMBERS PART
+    seq_pair = []
+    if allow_sequences:
+        for _ in range(5):
+            pool = sorted(set(weighted_choice(combined_weights, 20)))
+            adjacent_pairs = []
+            #print(f"there is pool variable: {pool}")
+            for i in range(len(pool) - 1):
+                if pool[i] + 1 == pool[i + 1]:
+                    adjacent_pairs.append([pool[i], pool[i + 1]])
+            if adjacent_pairs:
+                seq_pair = random.choice(adjacent_pairs)  # 🔄 Rastgele ardışık çift seç
+                break
+
+        if seq_pair:
+            selected += seq_pair
+            #print(f"🔗 Sequencial Numbers are selected: {seq_pair}")
+            for n in seq_pair:
+                combined_weights.pop(n, None)
+
+
+    # MAKE IT 5 AGAIN
+    while len(selected) < 5:
+        pick = weighted_choice(combined_weights)[0]
+        if pick not in selected:
+            #print(f"➕ Weighted Number is added (combined_weights): {pick}")
+            selected.append(pick)
+            combined_weights.pop(pick, None)
+
+
+    # Parity FIXING (2-3 / 3-2)
+    while True:
+        even = [n for n in selected if n % 2 == 0]
+        odd = [n for n in selected if n % 2 == 1]
+        #print(f"Current parity: {len(even)} even, {len(odd)} odd -> {selected}")
+
+        
+        if len(even) in [2, 3] and len(odd) in [2, 3]:
+            #print("✅ Parity OK. Breaking loop.")
+            break
+            
+        for i, num in enumerate(selected):
+            if len(even) in [2, 3] and len(odd) in [2, 3]:
+                break
+            elif len(even) > 3 or len(odd) < 2:
+                target_parity = 1
+            else:
+                target_parity = 0
+            
+            parity_pool = {
+                n: w for n, w in combined_weights.items()
+                if n % 2 == target_parity and n not in selected
+            }
+
+            if parity_pool:
+                r = weighted_choice(parity_pool)[0]
+                #print(f"♻️ Parity Fixing → {selected[i]} instead of {r}")
+                selected[i] = r
+                even = [n for n in selected if n % 2 == 0]
+                odd = [n for n in selected if n % 2 == 1]
+
+                #break
+
+
+    print("✅ Final selected:", sorted(selected))
+    while not is_sum_in_range(selected, 65, 265):   #Powerball Sum Range
+        return generate_pb_prediction(df, allow_sequences)
+    return sorted(selected)
+
+    
+def get_hot_and_cold_numbers(df, top_n=10):
+    from collections import Counter
+
+    NUMBER_RANGE = range(1, 70)  # Powerball: 1–69
+
+    flat_all = df[['1', '2', '3', '4', '5']].values.flatten()
+    freq_all = Counter(flat_all)
+
+    freq_sorted = sorted(freq_all.items(), key=lambda x: x[1], reverse=True)
+
+    hot = freq_sorted[:top_n]
+    cold = sorted(freq_sorted[-top_n:], key=lambda x: x[1])  # sort from less to much
+
+    return hot, cold
+
+
+if __name__ == "__main__":
+    
+    raw = pd.read_csv("../data/pb_results.csv")  
+    
+    df = clean_powerball_df(raw) #DELETE ROWS WHICH CONTAINS "DOUBLE PLAY"
+    
+    result = generate_pb_prediction(df)
+
+    predicted_star_ball = pb_predict_star_ball(df)
+    print(f"🌟 Predicted Star Ball: {predicted_star_ball}")
+
+    #print("Final result:", result)
+
+    

src/streamlit_app.py

@@ -3,14 +3,73 @@ import pandas as pd
 from gimme5_predictor import generate_gimme5_prediction
 from la_predictor import generate_la_prediction, la_predict_star_ball
 from mb_predictor import generate_mb_prediction, mb_predict_star_ball
+from mm_predictor import generate_mm_prediction, mm_predict_star_ball
+from pb_predictor import generate_pb_prediction, pb_predict_star_ball
+
+from pb_predictor import clean_powerball_df
+
 from gimme5_predictor import get_hot_and_cold_numbers as g5_get_hot
 from la_predictor import get_hot_and_cold_numbers as la_get_hot 
 from mb_predictor import get_hot_and_cold_numbers as mb_get_hot
+from mm_predictor import get_hot_and_cold_numbers as mm_get_hot
+from pb_predictor import get_hot_and_cold_numbers as pb_get_hot
+
+def display_wheel_table(hot_df, cold_df):
+    """
+    10 hot + 10 cold sayıdan oluşan wheel havuzunu tablo olarak gösterir.
+    """
+    hot_numbers  = [int(n) for n, _ in hot_df.values]
+    cold_numbers = [int(n) for n, _ in cold_df.values]
+    wheel_numbers = sorted(hot_numbers + cold_numbers)
+    
+    if len(wheel_numbers) == 20:
+        wheel_labels = list("ABCDEFGHIJKLMNOPQRST")
+        wheel_df = pd.DataFrame([wheel_numbers], columns=wheel_labels)
+        # Comment out
+        # with st.expander("🎡 Your 20 Numbers to Wheel"):
+        #     st.table(wheel_df.style.hide(axis="index"))
+
+def display_hot_cold_tables(hot_df, cold_df):
+    """
+    Var olan hot_df ve cold_df tablolarını düzgünce gösterir.
+    """
+
+    hot_df.index = range(1, len(hot_df)+1)
+    hot_df.index.name = 'No'
+    cold_df.index = range(1, len(cold_df)+1)
+    cold_df.index.name = 'No'
+
+    with st.expander("🔥 Hot Numbers (Top 10)"):
+        st.table(hot_df)
+
+    with st.expander("❄️ Cold Numbers (Bottom 10)"):
+        st.table(cold_df)
 
 
 st.set_page_config(page_title="Multi Lotto AI Engine", layout="centered")
 
-st.title("🎯 Lotto AI Engine (V1.2)")
+st.title("🎯 Lotto AI Engine (V1.3)")
+
+with st.expander("🛠️ Requirements (click to view)"):
+    st.markdown("""
+1- powerball (pb) and megamillions (mm) game will be added. they also 
+    should have sum_range.   
+    **pb = 65 - 265**  
+    **mm = 75 - 280**
+    
+2- their regular numbers:  
+                **pb = 1-69**  
+                **mm = 1-70** 
+                   
+their powerball:   
+                **pb = 1-26**  
+                **mm = 1-24**
+
+3- a wheel will be added. it will contain 10 hot and 10 cold numbers. 
+so it will be 20 numbers. it will be sorted. and later by using txt
+file which Randy provided to us, it will return 76 ticket combinations. 
+                                 
+                """)        
 
 with st.expander("🛠️ App Features (click to view)"):
     st.markdown("""
@@ -54,32 +113,42 @@ high totals, which historically have a lower likelihood of being drawn.
 If a generated set falls outside the allowed range, the system 
 regenerates a new one until the condition is satisfied.                
 
-**7- Fortuna favet ludens, qui non ludit, non vincit, In ludo est spes**
-""")
+**7- Fortuna favet ludens, qui non ludit, non vincit, In ludo est spes**               
 
+""")
 
 
 lotto_type = st.selectbox(
     "Select Lotto Type:",
-    options=["LA (Lotto America)", "MB (Megabucks)", "G5 (Gimme 5)"],
+    options=["LA (Lotto America)", "MB (Megabucks)", "G5 (Gimme 5)", "MM (Mega Millions)", "PB (Powerball)"],
     index=0
 )
 
 DATA_PATHS = {
     "G5 (Gimme 5)": "data/gimme5_results.csv",
     "LA (Lotto America)": "data/la_results.csv",
-    "MB (Megabucks)": "data/mb_results.csv"
+    "MB (Megabucks)": "data/mb_results.csv",
+    "MM (Mega Millions)": "data/mm_results.csv",
+    "PB (Powerball)": "data/pb_results.csv"
 }
 
 
 g5_df = pd.read_csv(DATA_PATHS["G5 (Gimme 5)"])
 la_df = pd.read_csv(DATA_PATHS["LA (Lotto America)"])
 mb_df = pd.read_csv(DATA_PATHS["MB (Megabucks)"])
+mm_df = pd.read_csv(DATA_PATHS["MM (Mega Millions)"])
+
+#POWERBALL SPECIAL CLEANING
+raw = pd.read_csv(DATA_PATHS["PB (Powerball)"])
+pb_df = clean_powerball_df(raw) #DELETE ROWS WHICH CONTAINS "DOUBLE PLAY"
 
 #WE CALCULATE HOT-COLD NUMBERS HERE
 hot_g5, cold_g5 = g5_get_hot(g5_df)
 hot_la, cold_la = la_get_hot(la_df)
 hot_mb, cold_mb = mb_get_hot(mb_df)
+hot_mm, cold_mm = mm_get_hot(mm_df)
+hot_pb, cold_pb = pb_get_hot(pb_df)
+
 
 try:
     data_path = DATA_PATHS[lotto_type]
@@ -98,30 +167,24 @@ try:
     </style>
     """, unsafe_allow_html=True)
 
-
+    #GIMME5
     if lotto_type == "G5 (Gimme 5)":
         use_sequence = st.checkbox("🔗 Include Sequential Numbers", value=False)
         if st.button("🎰 Generate Prediction"):
             result = generate_gimme5_prediction(g5_df, allow_sequences=use_sequence)
             st.success(f"🧠 Predicted Numbers: {result}")
-            st.success("ℹ️ No Star Ball or Megabucks Number for Gimme5")
+            st.success("ℹ️ No Additional Number for Gimme5")
             st.info(f"🔢 Total Sum of Picks: {sum(result)}")
 
             #HOT-COLD NUMBERS
             hot_df = pd.DataFrame(hot_g5, columns=["Number", "Frequency"])
             cold_df = pd.DataFrame(cold_g5, columns=["Number", "Frequency"])
 
-            hot_df.index = range(1, len(hot_df)+1)
-            hot_df.index.name = 'No'
-            cold_df.index = range(1, len(hot_df)+1)
-            cold_df.index.name = 'No'
-
-            with st.expander("🔥 Hot Numbers (Top 10)"):
-                st.table(hot_df)
+            display_hot_cold_tables(hot_df, cold_df)
+            display_wheel_table(hot_df, cold_df)
 
-            with st.expander("❄️ Cold Numbers (Bottom 10)"):
-                st.table(cold_df)
 
+    #LOTTO AMERICA 
     elif lotto_type == "LA (Lotto America)":
         use_sequence = st.checkbox("🔗 Include Sequential Numbers", value=False)
         if st.button("🎰 Generate Prediction"):
@@ -135,17 +198,10 @@ try:
             hot_df = pd.DataFrame(hot_la, columns=["Number", "Frequency"])
             cold_df = pd.DataFrame(cold_la, columns=["Number", "Frequency"])
 
-            hot_df.index = range(1, len(hot_df)+1)
-            hot_df.index.name = 'No'
-            cold_df.index = range(1, len(hot_df)+1)
-            cold_df.index.name = 'No'
-
-            with st.expander("🔥 Hot Numbers (Top 10)"):
-                st.table(hot_df)
-
-            with st.expander("❄️ Cold Numbers (Bottom 10)"):
-                st.table(cold_df)
+            display_hot_cold_tables(hot_df, cold_df)
+            display_wheel_table(hot_df, cold_df)
 
+    #MEGABUCKS
     elif lotto_type == "MB (Megabucks)":
         use_sequence = st.checkbox("🔗 Include Sequential Numbers", value=False)
         if st.button("🎰 Generate Prediction"):
@@ -159,16 +215,42 @@ try:
             hot_df = pd.DataFrame(hot_mb, columns=["Number", "Frequency"])
             cold_df = pd.DataFrame(cold_mb, columns=["Number", "Frequency"])
 
-            hot_df.index = range(1, len(hot_df)+1)
-            hot_df.index.name = 'No'
-            cold_df.index = range(1, len(hot_df)+1)
-            cold_df.index.name = 'No'
+            display_hot_cold_tables(hot_df, cold_df)
+            display_wheel_table(hot_df, cold_df)
+
+    #MEGA MILLIONS
+    elif lotto_type == "MM (Mega Millions)":
+        use_sequence = st.checkbox("🔗 Include Sequential Numbers", value=False)
+        if st.button("🎰 Generate Prediction"):
+            main_numbers = generate_mm_prediction(mm_df, allow_sequences=use_sequence)
+            star_ball = mm_predict_star_ball(mm_df)
+            st.success(f"🧠 Predicted Numbers: {main_numbers}")
+            st.success(f"🌟 Predicted Mega Ball Number: [{star_ball}]")
+            st.info(f"🔢 Total Sum of Picks: {sum(main_numbers)}")
+
+            #HOT AND COLD NUMBERS  
+            hot_df = pd.DataFrame(hot_mm, columns=["Number", "Frequency"])
+            cold_df = pd.DataFrame(cold_mm, columns=["Number", "Frequency"])
+
+            display_hot_cold_tables(hot_df, cold_df)
+            display_wheel_table(hot_df, cold_df)
 
-            with st.expander("🔥 Hot Numbers (Top 10)"):
-                st.table(hot_df)
+    #POWER BALL
+    elif lotto_type == "PB (Powerball)":
+        use_sequence = st.checkbox("🔗 Include Sequential Numbers", value=False)
+        if st.button("🎰 Generate Prediction"):
+            main_numbers = generate_pb_prediction(pb_df, allow_sequences=use_sequence)
+            star_ball = pb_predict_star_ball(pb_df)
+            st.success(f"🧠 Predicted Numbers: {main_numbers}")
+            st.success(f"🌟 Predicted Powerball Number: [{star_ball}]")
+            st.info(f"🔢 Total Sum of Picks: {sum(main_numbers)}")
+
+            #HOT AND COLD NUMBERS  
+            hot_df = pd.DataFrame(hot_pb, columns=["Number", "Frequency"])
+            cold_df = pd.DataFrame(cold_pb, columns=["Number", "Frequency"])
 
-            with st.expander("❄️ Cold Numbers (Bottom 10)"):
-                st.table(cold_df)
+            display_hot_cold_tables(hot_df, cold_df)
+            display_wheel_table(hot_df, cold_df)
 
 except FileNotFoundError:
     st.error(f"❌ File not found: `{data_path}`")