Update app.py

app.py

@@ -1,536 +1,536 @@
-import gradio as gr
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-import io 
-from scipy.stats import norm # Using scipy.stats, but it's a common numpy-adjacent lib for stats. If not allowed, can be replaced.
-# Let's stick to numpy. We can use norm.ppf or just ask for Z-score.
-# User said NO new concepts. Z-score is simple. I will just ask for the Z-score directly.
-
-# --- Calculation Functions ---
-
-def calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit):
-    """Calculates EOQ and related metrics for the basic model."""
-    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0:
-        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
-
-    eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit)
-    num_orders_per_year = annual_demand / eoq if eoq > 0 else np.inf
-    avg_inventory = eoq / 2
-    annual_ordering_cost = num_orders_per_year * order_cost
-    annual_holding_cost = avg_inventory * holding_cost_per_unit
-    total_annual_cost = annual_ordering_cost + annual_holding_cost
-    
-    demand_per_day = annual_demand / 365
-    
-    return eoq, num_orders_per_year, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day
-
-def calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, unit_cost, discount_tiers):
-    """Calculates EOQ with quantity discounts."""
-    if annual_demand <= 0 or order_cost <= 0 or holding_cost_rate <= 0 or unit_cost <= 0:
-        return pd.DataFrame(), np.nan, np.nan, np.nan, np.nan, "Invalid inputs for discount model."
-
-    results = []
-    best_total_cost = np.inf
-    best_eoq = np.nan
-    best_unit_cost = np.nan
-    best_tier = ""
-
-    discount_tiers = sorted(discount_tiers, key=lambda x: x[0])
-
-    for i, (min_qty, max_qty, tier_unit_cost) in enumerate(discount_tiers):
-        holding_cost_per_unit = holding_cost_rate * tier_unit_cost
-        
-        tier_eoq, _, _, _, _, _, _ = calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit)
-        
-        if tier_eoq < min_qty:
-            relevant_qty = min_qty
-        elif tier_eoq > max_qty and max_qty != np.inf:
-            relevant_qty = max_qty
-        else: 
-            relevant_qty = tier_eoq
-        
-        if relevant_qty <= 0:
-            num_orders = np.inf
-            ordering_cost = np.inf
-            holding_cost = 0 
-            purchase_cost = annual_demand * tier_unit_cost
-            total_cost = np.inf
-        else:
-            num_orders = annual_demand / relevant_qty
-            ordering_cost = num_orders * order_cost
-            holding_cost = (relevant_qty / 2) * holding_cost_per_unit
-            purchase_cost = annual_demand * tier_unit_cost
-            total_cost = ordering_cost + holding_cost + purchase_cost
-            
-        results.append({
-            "Tier": f"Tier {i+1} ({min_qty}-{max_qty if max_qty != np.inf else '∞'})",
-            "Unit Cost ($)": tier_unit_cost,
-            "Holding Cost/Unit/Year ($)": f"{holding_cost_per_unit:.2f}",
-            "Theoretical EOQ (Units)": f"{tier_eoq:.0f}",
-            "Relevant Q (Units)": f"{relevant_qty:.0f}",
-            "Annual Ordering Cost ($)": f"{ordering_cost:.2f}",
-            "Annual Holding Cost ($)": f"{holding_cost:.2f}",
-            "Annual Purchase Cost ($)": f"{purchase_cost:.2f}",
-            "Total Annual Cost ($)": f"{total_cost:.2f}"
-        })
-
-        if total_cost < best_total_cost:
-            best_total_cost = total_cost
-            best_eoq = relevant_qty
-            best_unit_cost = tier_unit_cost
-            best_tier = f"Tier {i+1}"
-
-    df = pd.DataFrame(results)
-    
-    return df, best_eoq, best_total_cost, best_unit_cost, best_tier, "Analysis complete."
-
-
-def calculate_poq(annual_demand, order_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate):
-    """Calculates Production Order Quantity (POQ) and related metrics."""
-    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0 or \
-       daily_production_rate <= 0 or daily_demand_rate <= 0:
-        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
-    
-    if daily_production_rate <= daily_demand_rate:
-        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, "Production rate must be greater than demand rate."
-
-    poq = np.sqrt((2 * annual_demand * order_cost) / (holding_cost_per_unit * (1 - (daily_demand_rate / daily_production_rate))))
-    
-    num_setups_per_year = annual_demand / poq if poq > 0 else np.inf
-    max_inventory_level = poq * (1 - (daily_demand_rate / daily_production_rate))
-    avg_inventory = max_inventory_level / 2
-    
-    annual_setup_cost = num_setups_per_year * order_cost
-    annual_holding_cost = avg_inventory * holding_cost_per_unit
-    total_annual_cost = annual_setup_cost + annual_holding_cost
-    
-    production_run_days = poq / daily_production_rate
-    inventory_cycle_days = poq / daily_demand_rate
-    
-    return poq, num_setups_per_year, max_inventory_level, avg_inventory, annual_setup_cost, \
-           annual_holding_cost, total_annual_cost, production_run_days, inventory_cycle_days
-
-def calculate_rop_and_ss(avg_daily_demand, lead_time_days, std_dev_daily_demand, service_level_z):
-    """Calculates Reorder Point and Safety Stock."""
-    if avg_daily_demand < 0 or lead_time_days < 0 or std_dev_daily_demand < 0 or service_level_z < 0:
-        return 0, 0, 0, "Inputs must be non-negative."
-        
-    std_dev_lead_time = std_dev_daily_demand * np.sqrt(lead_time_days)
-    safety_stock = std_dev_lead_time * service_level_z
-    demand_during_lead_time = avg_daily_demand * lead_time_days
-    reorder_point = demand_during_lead_time + safety_stock
-    
-    return safety_stock, demand_during_lead_time, reorder_point, "Calculation successful."
-
-def calculate_sma_forecast(demand_data_str, window_size):
-    """Calculates Simple Moving Average (SMA) forecast."""
-    if not demand_data_str:
-        return pd.DataFrame(), None, "Please enter demand data."
-    
-    try:
-        demand_values = [float(d.strip()) for d in demand_data_str.split(',') if d.strip()]
-        if len(demand_values) < window_size:
-            return pd.DataFrame(), None, f"Not enough data for window size {window_size}. Need at least {window_size} data points."
-        
-        df = pd.DataFrame({'Demand': demand_values})
-        df['Period'] = range(1, len(df) + 1)
-        
-        # Calculate SMA
-        df[f'SMA (Window={window_size})'] = df['Demand'].rolling(window=window_size).mean()
-        
-        # Forecast next period
-        forecast_next_period = df['Demand'].tail(window_size).mean()
-        
-        # Create plot
-        fig, ax = plt.subplots(figsize=(8, 4))
-        ax.plot(df['Period'], df['Demand'], label='Actual Demand', marker='o', linestyle='-')
-        ax.plot(df['Period'], df[f'SMA (Window={window_size})'], label='SMA', marker='x', linestyle='--')
-        
-        ax.set_title('Simple Moving Average (SMA) Forecast', fontsize=14)
-        ax.set_xlabel('Period', fontsize=10)
-        ax.set_ylabel('Demand', fontsize=10)
-        ax.legend()
-        ax.grid(True, linestyle=':', alpha=0.7)
-        plt.tight_layout()
-        plt.close(fig)
-        
-        return df, fig, f"Forecast for next period: {forecast_next_period:.2f}"
-
-    except Exception as e:
-        return pd.DataFrame(), None, f"Error: {e}. Ensure data is comma-separated numbers."
-
-# --- Plotting Function ---
-
-def create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, min_q=1, max_q_multiplier=2.5, current_eoq=None):
-    """Generates the EOQ cost curves plot."""
-    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0:
-        fig, ax = plt.subplots(figsize=(6, 4))
-        ax.text(0.5, 0.5, "Invalid input for plot.", horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
-        ax.axis('off')
-        plt.close(fig)
-        return fig
-
-    if current_eoq is None or np.isnan(current_eoq) or current_eoq <= 0:
-        current_eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit)
-        if np.isnan(current_eoq) or current_eoq <= 0:
-            current_eoq = 100 
-
-    quantity_range = np.linspace(min_q, current_eoq * max_q_multiplier, 300)
-    
-    quantity_range = quantity_range[quantity_range > 0] 
-    
-    ordering_costs = (annual_demand / quantity_range) * order_cost
-    holding_costs = (quantity_range / 2) * holding_cost_per_unit
-    total_costs = ordering_costs + holding_costs
-
-    fig, ax = plt.subplots(figsize=(6, 4))
-
-    ax.plot(quantity_range, holding_costs, label='Annual Holding Cost', color='orange')
-    ax.plot(quantity_range, ordering_costs, label='Annual Ordering Cost', color='blue')
-    ax.plot(quantity_range, total_costs, label='Total Cost', color='green', linewidth=2.5)
-    
-    if not np.isnan(current_eoq) and current_eoq > 0:
-        ax.axvline(x=current_eoq, color='red', linestyle='--', label=f'EOQ: {current_eoq:.0f} units')
-        total_cost_at_eoq_idx = np.argmin(np.abs(quantity_range - current_eoq))
-        total_cost_at_eoq = total_costs[total_cost_at_eoq_idx]
-        ax.plot(current_eoq, total_cost_at_eoq, 'ro')
-    
-    ax.set_title('EOQ Cost Analysis', fontsize=12)
-    ax.set_xlabel('Order Quantity (Units)', fontsize=10)
-    ax.set_ylabel('Annual Cost ($)', fontsize=10)
-    ax.legend(fontsize=8, loc='upper right')
-    ax.grid(True, linestyle=':', alpha=0.7)
-    ax.set_ylim(bottom=0)
-    ax.set_xlim(left=0)
-    ax.tick_params(axis='both', which='major', labelsize=8)
-    
-    plt.tight_layout()
-    plt.close(fig)
-    return fig
-
-# --- Combined Interface Function for Basic EOQ ---
-
-def update_basic_eoq(annual_demand, order_cost, holding_cost_per_unit, lead_time_days):
-    """Updates all outputs for the Basic EOQ tab."""
-    if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_per_unit]):
-        return None, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all basic EOQ parameters."
-
-    eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day = \
-        calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit)
-
-    # Simple Reorder Point (no safety stock)
-    reorder_point = demand_per_day * lead_time_days
-    
-    plot_fig = create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, current_eoq=eoq)
-
-    return plot_fig, eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, \
-           total_annual_cost, reorder_point, "Calculation successful."
-
-# --- Combined Interface Function for POQ ---
-def update_poq_model(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate):
-    """Updates all outputs for the POQ tab."""
-    if any(x <= 0 for x in [annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate]):
-        return None, 0, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all POQ parameters."
-    
-    if daily_production_rate <= daily_demand_rate:
-         return None, 0, 0, 0, 0, 0, 0, 0, 0, "Production rate must be greater than demand rate."
-
-    poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, prod_days, cycle_days = \
-        calculate_poq(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate)
-    
-    plot_fig = create_eoq_plot(annual_demand, setup_cost, holding_cost_per_unit, current_eoq=poq, max_q_multiplier=2.0)
-
-    return plot_fig, poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, \
-           prod_days, cycle_days, "Calculation successful."
-
-# --- Helper for Discount Tiers ---
-def create_discount_tiers_df(tier1_min, tier1_max, tier1_uc,
-                             tier2_min, tier2_max, tier2_uc,
-                             tier3_min, tier3_max, tier3_uc):
-    """Helper to create the discount_tiers list from Gradio inputs."""
-    tiers = []
-    if tier1_min is not None and tier1_uc is not None and tier1_min >= 0 and tier1_uc >= 0:
-        tiers.append((tier1_min, tier1_max if tier1_max is not None else np.inf, tier1_uc))
-    if tier2_min is not None and tier2_uc is not None and tier2_min >= 0 and tier2_uc >= 0:
-        tiers.append((tier2_min, tier2_max if tier2_max is not None else np.inf, tier2_uc))
-    if tier3_min is not None and tier3_uc is not None and tier3_min >= 0 and tier3_uc >= 0:
-        tiers.append((tier3_min, tier3_max if tier3_max is not None else np.inf, tier3_uc))
-    
-    valid_tiers = []
-    for t in tiers:
-        if t[1] != np.inf and t[0] >= t[1]:
-            print(f"Warning: Invalid tier range {t}. Skipping.")
-        else:
-            valid_tiers.append(t)
-
-    valid_tiers = sorted(valid_tiers, key=lambda x: x[0])
-    
-    return valid_tiers
-
-# --- Combined Interface Function for Discount Model ---
-def update_discount_model(annual_demand, order_cost, holding_cost_rate_percent, 
-                          tier1_min, tier1_max, tier1_uc,
-                          tier2_min, tier2_max, tier2_uc,
-                          tier3_min, tier3_max, tier3_uc):
-    """Updates all outputs for the Quantity Discount tab."""
-    holding_cost_rate = holding_cost_rate_percent / 100.0
-
-    if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_rate_percent]):
-        return pd.DataFrame(), 0, 0, 0, "", "Please enter positive values for core discount parameters."
-    
-    discount_tiers = create_discount_tiers_df(
-        tier1_min, tier1_max, tier1_uc,
-        tier2_min, tier2_max, tier2_uc,
-        tier3_min, tier3_max, tier3_uc
-    )
-    
-    if not discount_tiers:
-        return pd.DataFrame(), 0, 0, 0, "", "No valid discount tiers defined. Please define at least one tier with positive min quantity and unit cost."
-
-    for i in range(len(discount_tiers) - 1):
-        if discount_tiers[i][2] < discount_tiers[i+1][2]:
-            return pd.DataFrame(), 0, 0, 0, "", "Error: Unit costs must be non-increasing with quantity."
-            
-    df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message = \
-        calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, discount_tiers[0][2], discount_tiers)
-
-    return df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message
-
-# --- Gradio Interface ---
-
-with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Operations Management Dashboard") as demo:
-    gr.Markdown(
-        """
-        # 📊 Advanced Operations Management Dashboard (Xyphor Advisors)
-        Welcome to your comprehensive tool for optimizing operations and inventory decisions.
-        """
-    )
-    
-    with gr.Tabs():
-        # --- Tab 1: Basic EOQ Model ---
-        with gr.TabItem("Basic EOQ Model"):
-            gr.Markdown("## Economic Order Quantity (EOQ) Calculation")
-            gr.Markdown("Find the optimal order quantity that minimizes the sum of ordering and holding costs.")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 🛠️ Input Parameters")
-                    basic_demand = gr.Slider(100, 50000, value=12000, step=100, label="Annual Demand (D) [units/year]")
-                    basic_order_cost = gr.Slider(5, 500, value=100, step=5, label="Ordering Cost (S) [$/order]")
-                    basic_holding_cost = gr.Slider(0.1, 50, value=5, step=0.1, label="Holding Cost (H) [$/unit/year]")
-                    basic_lead_time = gr.Slider(0, 30, value=7, step=1, label="Lead Time [days]", info="Time from order placement to receipt.")
-                    
-                    basic_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
-
-                with gr.Column():
-                    gr.Markdown("### 📈 Cost Analysis & Optimal Q")
-                    basic_plot_output = gr.Plot(label="EOQ Cost Curves", scale=2)
-
-                    with gr.Accordion("Detailed Results", open=True):
-                        gr.Markdown("#### Key Metrics")
-                        with gr.Row():
-                            basic_eoq_out = gr.Number(label="Optimal Order Quantity (EOQ) [units]", precision=0)
-                            basic_num_orders_out = gr.Number(label="Annual Orders [count]", precision=2)
-                            basic_avg_inventory_out = gr.Number(label="Average Inventory [units]", precision=2)
-                        gr.Markdown("#### Annual Costs")
-                        with gr.Row():
-                            basic_ordering_cost_out = gr.Number(label="Annual Ordering Cost [$]", precision=2)
-                            basic_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2)
-                            basic_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2)
-                        gr.Markdown("#### Reorder Point (Simple)")
-                        with gr.Row():
-                            basic_reorder_point_out = gr.Number(label="Reorder Point (without Safety Stock) [units]", precision=0)
-
-            basic_inputs = [basic_demand, basic_order_cost, basic_holding_cost, basic_lead_time]
-            basic_outputs = [basic_plot_output, basic_eoq_out, basic_num_orders_out, basic_avg_inventory_out,
-                             basic_ordering_cost_out, basic_holding_cost_out, basic_total_cost_out,
-                             basic_reorder_point_out, basic_status_message]
-            
-            for inp in basic_inputs:
-                inp.change(
-                    fn=update_basic_eoq, 
-                    inputs=basic_inputs, 
-                    outputs=basic_outputs
-                )
-            
-            demo.load(
-                fn=update_basic_eoq, 
-                inputs=basic_inputs, 
-                outputs=basic_outputs
-            )
-
-        # --- Tab 2: Reorder Point & Safety Stock ---
-        with gr.TabItem("Reorder Point (ROP) & Safety Stock"):
-            gr.Markdown("## Reorder Point & Safety Stock Calculator")
-            gr.Markdown("Determine the precise inventory level at which to place a new order to avoid stockouts.")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 🛠️ Input Parameters")
-                    rop_avg_demand = gr.Number(label="Average Daily Demand [units/day]", value=50)
-                    rop_lead_time = gr.Number(label="Lead Time [days]", value=10)
-                    rop_std_dev = gr.Number(label="Standard Deviation of Daily Demand", value=5)
-                    rop_z_score = gr.Slider(minimum=0.0, maximum=3.0, value=1.65, step=0.01, 
-                                            label="Z-Score (for Service Level)", 
-                                            info="e.g., 1.65 for 95% service level, 2.33 for 99%")
-                    rop_status = gr.Textbox(label="Status", interactive=False)
-                
-                with gr.Column():
-                    gr.Markdown("### 🔑 Calculated Metrics")
-                    rop_ss_out = gr.Number(label="Safety Stock (SS) [units]", precision=0, 
-                                           info="The buffer stock held to prevent stockouts.")
-                    rop_dlt_out = gr.Number(label="Demand During Lead Time [units]", precision=0,
-                                            info="Total expected demand while waiting for the order.")
-                    rop_out = gr.Number(label="Reorder Point (ROP) [units]", precision=0, 
-                                        info="Place an order when inventory hits this level. (ROP = SS + Demand During Lead Time)")
-
-            rop_inputs = [rop_avg_demand, rop_lead_time, rop_std_dev, rop_z_score]
-            rop_outputs = [rop_ss_out, rop_dlt_out, rop_out, rop_status]
-
-            for inp in rop_inputs:
-                inp.change(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs)
-            demo.load(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs)
-
-        # --- Tab 3: Quantity Discount Model ---
-        with gr.TabItem("Quantity Discount Model"):
-            gr.Markdown("## EOQ with Quantity Discounts")
-            gr.Markdown("Evaluate the impact of price breaks on the optimal order quantity and total cost.")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 🛠️ Core Parameters")
-                    discount_demand = gr.Slider(100, 50000, value=15000, step=100, label="Annual Demand (D) [units/year]")
-                    discount_order_cost = gr.Slider(5, 500, value=75, step=5, label="Ordering Cost (S) [$/order]")
-                    discount_holding_rate = gr.Slider(0.01, 0.5, value=0.2, step=0.01, label="Holding Cost Rate [% of Unit Cost]", info="e.g., 20% = 0.2")
-
-                    gr.Markdown("### 🏷️ Discount Tiers")
-                    gr.Markdown("Define up to three discount tiers. Unit costs must be non-increasing.")
-                    with gr.Accordion("Tier 1", open=True):
-                        with gr.Row():
-                            tier1_min_qty = gr.Number(label="Min Qty", value=0, precision=0)
-                            tier1_max_qty = gr.Number(label="Max Qty", value=999, precision=0)
-                            tier1_unit_cost = gr.Number(label="Unit Cost ($)", value=10.00, precision=2)
-                    with gr.Accordion("Tier 2"):
-                        with gr.Row():
-                            tier2_min_qty = gr.Number(label="Min Qty", value=1000, precision=0)
-                            tier2_max_qty = gr.Number(label="Max Qty", value=4999, precision=0)
-                            tier2_unit_cost = gr.Number(label="Unit Cost ($)", value=9.50, precision=2)
-                    with gr.Accordion("Tier 3"):
-                        with gr.Row():
-                            tier3_min_qty = gr.Number(label="Min Qty", value=5000, precision=0)
-                            tier3_max_qty = gr.Number(label="Max Qty", value=None, precision=0, info="Leave blank for infinity") 
-                            tier3_unit_cost = gr.Number(label="Unit Cost ($)", value=9.00, precision=2)
-                    
-                    discount_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
-
-                with gr.Column():
-                    gr.Markdown("### 📊 Tier Analysis & Optimal Selection")
-                    discount_output_df = gr.DataFrame(label="Discount Tier Analysis", interactive=False)
-                    gr.Markdown("#### Optimal Discount Solution")
-                    with gr.Row():
-                        best_discount_eoq_out = gr.Number(label="Optimal Order Quantity [units]", precision=0)
-                        best_discount_cost_out = gr.Number(label="Minimum Total Annual Cost [$]", precision=2)
-                    with gr.Row():
-                        best_discount_unit_cost_out = gr.Number(label="Unit Cost at Optimal Q [$]", precision=2)
-                        best_discount_tier_out = gr.Textbox(label="Optimal Tier", interactive=False)
-            
-            discount_inputs = [discount_demand, discount_order_cost, discount_holding_rate,
-                               tier1_min_qty, tier1_max_qty, tier1_unit_cost,
-                               tier2_min_qty, tier2_max_qty, tier2_unit_cost,
-                               tier3_min_qty, tier3_max_qty, tier3_unit_cost]
-            discount_outputs = [discount_output_df, best_discount_eoq_out, best_discount_cost_out, 
-                                best_discount_unit_cost_out, best_discount_tier_out, discount_status_message]
-
-            for inp in discount_inputs:
-                inp.change(
-                    fn=update_discount_model, 
-                    inputs=discount_inputs, 
-                    outputs=discount_outputs
-                )
-            
-            demo.load(
-                fn=update_discount_model, 
-                inputs=discount_inputs, 
-                outputs=discount_outputs
-            )
-
-        # --- Tab 4: Production Order Quantity (POQ) Model ---
-        with gr.TabItem("Production Order Quantity (POQ) Model"):
-            gr.Markdown("## Production Order Quantity (POQ) Calculation")
-            gr.Markdown("Determine the optimal batch size when production is internal and gradual.")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 🛠️ Input Parameters")
-                    poq_demand = gr.Slider(100, 50000, value=20000, step=100, label="Annual Demand (D) [units/year]")
-                    poq_setup_cost = gr.Slider(5, 500, value=200, step=5, label="Setup Cost (S) [$/setup]")
-                    poq_holding_cost = gr.Slider(0.1, 50, value=8, step=0.1, label="Holding Cost (H) [$/unit/year]")
-                    gr.Markdown("### 🏭 Production Specifics")
-                    poq_prod_rate = gr.Slider(10, 2000, value=500, step=10, label="Daily Production Rate (P) [units/day]")
-                    poq_demand_rate = gr.Slider(1, 1000, value=80, step=1, label="Daily Demand Rate (d) [units/day]", info="Must be less than Daily Production Rate.")
-                    
-                    poq_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
-
-                with gr.Column():
-                    gr.Markdown("### 📈 Cost Analysis & Optimal Batch Size")
-                    poq_plot_output = gr.Plot(label="POQ Cost Curves", scale=2)
-
-                    with gr.Accordion("Detailed Results", open=True):
-                        gr.Markdown("#### Key Metrics")
-                        with gr.Row():
-                            poq_out = gr.Number(label="Optimal Production Quantity (POQ) [units]", precision=0)
-                            poq_num_setups_out = gr.Number(label="Annual Setups [count]", precision=2)
-                            poq_max_inv_out = gr.Number(label="Maximum Inventory Level [units]", precision=2)
-                            poq_avg_inv_out = gr.Number(label="Average Inventory [units]", precision=2)
-                        gr.Markdown("#### Annual Costs")
-                        with gr.Row():
-                            poq_setup_cost_out = gr.Number(label="Annual Setup Cost [$]", precision=2)
-                            poq_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2)
-                            poq_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2)
-                        gr.Markdown("#### Production Cycle Details")
-                        with gr.Row():
-                            poq_prod_days_out = gr.Number(label="Production Run Duration [days]", precision=2)
-                            poq_cycle_days_out = gr.Number(label="Inventory Cycle Duration [days]", precision=2)
-
-            poq_inputs = [poq_demand, poq_setup_cost, poq_holding_cost, poq_prod_rate, poq_demand_rate]
-            poq_outputs = [poq_plot_output, poq_out, poq_num_setups_out, poq_max_inv_out, poq_avg_inv_out,
-                           poq_setup_cost_out, poq_holding_cost_out, poq_total_cost_out,
-                           poq_prod_days_out, poq_cycle_days_out, poq_status_message]
-
-            for inp in poq_inputs:
-                inp.change(
-                    fn=update_poq_model, 
-                    inputs=poq_inputs, 
-                    outputs=poq_outputs
-                )
-            
-            demo.load(
-                fn=update_poq_model, 
-                inputs=poq_inputs, 
-                outputs=poq_outputs
-            )
-
-        # --- Tab 5: Demand Forecasting (SMA) ---
-        with gr.TabItem("Demand Forecasting (SMA)"):
-            gr.Markdown("## Simple Moving Average (SMA) Forecasting")
-            gr.Markdown("Forecast future demand based on the average of past demand data.")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🛠️ Input Parameters")
-                    sma_data = gr.Textbox(label="Past Demand Data (comma-separated)", 
-                                          value="100, 110, 105, 120, 115, 125, 130, 122, 135, 140")
-                    sma_window = gr.Slider(minimum=2, maximum=10, value=3, step=1, 
-                                           label="SMA Window Size (Periods)")
-                    sma_status = gr.Textbox(label="Status & Forecast", interactive=False)
-                
-                with gr.Column(scale=2):
-                    gr.Markdown("### 📈 Forecast Plot")
-                    sma_plot = gr.Plot()
-                    sma_df = gr.DataFrame(label="Data and SMA")
-
-            sma_inputs = [sma_data, sma_window]
-            sma_outputs = [sma_df, sma_plot, sma_status]
-
-            for inp in sma_inputs:
-                inp.change(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs)
-            demo.load(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs)
-
-if __name__ == "__main__":
-    demo.launch(debug=True)
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import io 
+from scipy.stats import norm # Using scipy.stats, but it's a common numpy-adjacent lib for stats. If not allowed, can be replaced.
+# Let's stick to numpy. We can use norm.ppf or just ask for Z-score.
+# User said NO new concepts. Z-score is simple. I will just ask for the Z-score directly.
+
+# --- Calculation Functions ---
+
+def calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit):
+    """Calculates EOQ and related metrics for the basic model."""
+    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0:
+        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+
+    eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit)
+    num_orders_per_year = annual_demand / eoq if eoq > 0 else np.inf
+    avg_inventory = eoq / 2
+    annual_ordering_cost = num_orders_per_year * order_cost
+    annual_holding_cost = avg_inventory * holding_cost_per_unit
+    total_annual_cost = annual_ordering_cost + annual_holding_cost
+    
+    demand_per_day = annual_demand / 365
+    
+    return eoq, num_orders_per_year, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day
+
+def calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, unit_cost, discount_tiers):
+    """Calculates EOQ with quantity discounts."""
+    if annual_demand <= 0 or order_cost <= 0 or holding_cost_rate <= 0 or unit_cost <= 0:
+        return pd.DataFrame(), np.nan, np.nan, np.nan, np.nan, "Invalid inputs for discount model."
+
+    results = []
+    best_total_cost = np.inf
+    best_eoq = np.nan
+    best_unit_cost = np.nan
+    best_tier = ""
+
+    discount_tiers = sorted(discount_tiers, key=lambda x: x[0])
+
+    for i, (min_qty, max_qty, tier_unit_cost) in enumerate(discount_tiers):
+        holding_cost_per_unit = holding_cost_rate * tier_unit_cost
+        
+        tier_eoq, _, _, _, _, _, _ = calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit)
+        
+        if tier_eoq < min_qty:
+            relevant_qty = min_qty
+        elif tier_eoq > max_qty and max_qty != np.inf:
+            relevant_qty = max_qty
+        else: 
+            relevant_qty = tier_eoq
+        
+        if relevant_qty <= 0:
+            num_orders = np.inf
+            ordering_cost = np.inf
+            holding_cost = 0 
+            purchase_cost = annual_demand * tier_unit_cost
+            total_cost = np.inf
+        else:
+            num_orders = annual_demand / relevant_qty
+            ordering_cost = num_orders * order_cost
+            holding_cost = (relevant_qty / 2) * holding_cost_per_unit
+            purchase_cost = annual_demand * tier_unit_cost
+            total_cost = ordering_cost + holding_cost + purchase_cost
+            
+        results.append({
+            "Tier": f"Tier {i+1} ({min_qty}-{max_qty if max_qty != np.inf else '∞'})",
+            "Unit Cost ($)": tier_unit_cost,
+            "Holding Cost/Unit/Year ($)": f"{holding_cost_per_unit:.2f}",
+            "Theoretical EOQ (Units)": f"{tier_eoq:.0f}",
+            "Relevant Q (Units)": f"{relevant_qty:.0f}",
+            "Annual Ordering Cost ($)": f"{ordering_cost:.2f}",
+            "Annual Holding Cost ($)": f"{holding_cost:.2f}",
+            "Annual Purchase Cost ($)": f"{purchase_cost:.2f}",
+            "Total Annual Cost ($)": f"{total_cost:.2f}"
+        })
+
+        if total_cost < best_total_cost:
+            best_total_cost = total_cost
+            best_eoq = relevant_qty
+            best_unit_cost = tier_unit_cost
+            best_tier = f"Tier {i+1}"
+
+    df = pd.DataFrame(results)
+    
+    return df, best_eoq, best_total_cost, best_unit_cost, best_tier, "Analysis complete."
+
+
+def calculate_poq(annual_demand, order_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate):
+    """Calculates Production Order Quantity (POQ) and related metrics."""
+    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0 or \
+       daily_production_rate <= 0 or daily_demand_rate <= 0:
+        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+    
+    if daily_production_rate <= daily_demand_rate:
+        return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, "Production rate must be greater than demand rate."
+
+    poq = np.sqrt((2 * annual_demand * order_cost) / (holding_cost_per_unit * (1 - (daily_demand_rate / daily_production_rate))))
+    
+    num_setups_per_year = annual_demand / poq if poq > 0 else np.inf
+    max_inventory_level = poq * (1 - (daily_demand_rate / daily_production_rate))
+    avg_inventory = max_inventory_level / 2
+    
+    annual_setup_cost = num_setups_per_year * order_cost
+    annual_holding_cost = avg_inventory * holding_cost_per_unit
+    total_annual_cost = annual_setup_cost + annual_holding_cost
+    
+    production_run_days = poq / daily_production_rate
+    inventory_cycle_days = poq / daily_demand_rate
+    
+    return poq, num_setups_per_year, max_inventory_level, avg_inventory, annual_setup_cost, \
+           annual_holding_cost, total_annual_cost, production_run_days, inventory_cycle_days
+
+def calculate_rop_and_ss(avg_daily_demand, lead_time_days, std_dev_daily_demand, service_level_z):
+    """Calculates Reorder Point and Safety Stock."""
+    if avg_daily_demand < 0 or lead_time_days < 0 or std_dev_daily_demand < 0 or service_level_z < 0:
+        return 0, 0, 0, "Inputs must be non-negative."
+        
+    std_dev_lead_time = std_dev_daily_demand * np.sqrt(lead_time_days)
+    safety_stock = std_dev_lead_time * service_level_z
+    demand_during_lead_time = avg_daily_demand * lead_time_days
+    reorder_point = demand_during_lead_time + safety_stock
+    
+    return safety_stock, demand_during_lead_time, reorder_point, "Calculation successful."
+
+def calculate_sma_forecast(demand_data_str, window_size):
+    """Calculates Simple Moving Average (SMA) forecast."""
+    if not demand_data_str:
+        return pd.DataFrame(), None, "Please enter demand data."
+    
+    try:
+        demand_values = [float(d.strip()) for d in demand_data_str.split(',') if d.strip()]
+        if len(demand_values) < window_size:
+            return pd.DataFrame(), None, f"Not enough data for window size {window_size}. Need at least {window_size} data points."
+        
+        df = pd.DataFrame({'Demand': demand_values})
+        df['Period'] = range(1, len(df) + 1)
+        
+        # Calculate SMA
+        df[f'SMA (Window={window_size})'] = df['Demand'].rolling(window=window_size).mean()
+        
+        # Forecast next period
+        forecast_next_period = df['Demand'].tail(window_size).mean()
+        
+        # Create plot
+        fig, ax = plt.subplots(figsize=(8, 4))
+        ax.plot(df['Period'], df['Demand'], label='Actual Demand', marker='o', linestyle='-')
+        ax.plot(df['Period'], df[f'SMA (Window={window_size})'], label='SMA', marker='x', linestyle='--')
+        
+        ax.set_title('Simple Moving Average (SMA) Forecast', fontsize=14)
+        ax.set_xlabel('Period', fontsize=10)
+        ax.set_ylabel('Demand', fontsize=10)
+        ax.legend()
+        ax.grid(True, linestyle=':', alpha=0.7)
+        plt.tight_layout()
+        plt.close(fig)
+        
+        return df, fig, f"Forecast for next period: {forecast_next_period:.2f}"
+
+    except Exception as e:
+        return pd.DataFrame(), None, f"Error: {e}. Ensure data is comma-separated numbers."
+
+# --- Plotting Function ---
+
+def create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, min_q=1, max_q_multiplier=2.5, current_eoq=None):
+    """Generates the EOQ cost curves plot."""
+    if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0:
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.text(0.5, 0.5, "Invalid input for plot.", horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
+        ax.axis('off')
+        plt.close(fig)
+        return fig
+
+    if current_eoq is None or np.isnan(current_eoq) or current_eoq <= 0:
+        current_eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit)
+        if np.isnan(current_eoq) or current_eoq <= 0:
+            current_eoq = 100 
+
+    quantity_range = np.linspace(min_q, current_eoq * max_q_multiplier, 300)
+    
+    quantity_range = quantity_range[quantity_range > 0] 
+    
+    ordering_costs = (annual_demand / quantity_range) * order_cost
+    holding_costs = (quantity_range / 2) * holding_cost_per_unit
+    total_costs = ordering_costs + holding_costs
+
+    fig, ax = plt.subplots(figsize=(6, 4))
+
+    ax.plot(quantity_range, holding_costs, label='Annual Holding Cost', color='orange')
+    ax.plot(quantity_range, ordering_costs, label='Annual Ordering Cost', color='blue')
+    ax.plot(quantity_range, total_costs, label='Total Cost', color='green', linewidth=2.5)
+    
+    if not np.isnan(current_eoq) and current_eoq > 0:
+        ax.axvline(x=current_eoq, color='red', linestyle='--', label=f'EOQ: {current_eoq:.0f} units')
+        total_cost_at_eoq_idx = np.argmin(np.abs(quantity_range - current_eoq))
+        total_cost_at_eoq = total_costs[total_cost_at_eoq_idx]
+        ax.plot(current_eoq, total_cost_at_eoq, 'ro')
+    
+    ax.set_title('EOQ Cost Analysis', fontsize=12)
+    ax.set_xlabel('Order Quantity (Units)', fontsize=10)
+    ax.set_ylabel('Annual Cost ($)', fontsize=10)
+    ax.legend(fontsize=8, loc='upper right')
+    ax.grid(True, linestyle=':', alpha=0.7)
+    ax.set_ylim(bottom=0)
+    ax.set_xlim(left=0)
+    ax.tick_params(axis='both', which='major', labelsize=8)
+    
+    plt.tight_layout()
+    plt.close(fig)
+    return fig
+
+# --- Combined Interface Function for Basic EOQ ---
+
+def update_basic_eoq(annual_demand, order_cost, holding_cost_per_unit, lead_time_days):
+    """Updates all outputs for the Basic EOQ tab."""
+    if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_per_unit]):
+        return None, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all basic EOQ parameters."
+
+    eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day = \
+        calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit)
+
+    # Simple Reorder Point (no safety stock)
+    reorder_point = demand_per_day * lead_time_days
+    
+    plot_fig = create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, current_eoq=eoq)
+
+    return plot_fig, eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, \
+           total_annual_cost, reorder_point, "Calculation successful."
+
+# --- Combined Interface Function for POQ ---
+def update_poq_model(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate):
+    """Updates all outputs for the POQ tab."""
+    if any(x <= 0 for x in [annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate]):
+        return None, 0, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all POQ parameters."
+    
+    if daily_production_rate <= daily_demand_rate:
+         return None, 0, 0, 0, 0, 0, 0, 0, 0, "Production rate must be greater than demand rate."
+
+    poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, prod_days, cycle_days = \
+        calculate_poq(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate)
+    
+    plot_fig = create_eoq_plot(annual_demand, setup_cost, holding_cost_per_unit, current_eoq=poq, max_q_multiplier=2.0)
+
+    return plot_fig, poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, \
+           prod_days, cycle_days, "Calculation successful."
+
+# --- Helper for Discount Tiers ---
+def create_discount_tiers_df(tier1_min, tier1_max, tier1_uc,
+                             tier2_min, tier2_max, tier2_uc,
+                             tier3_min, tier3_max, tier3_uc):
+    """Helper to create the discount_tiers list from Gradio inputs."""
+    tiers = []
+    if tier1_min is not None and tier1_uc is not None and tier1_min >= 0 and tier1_uc >= 0:
+        tiers.append((tier1_min, tier1_max if tier1_max is not None else np.inf, tier1_uc))
+    if tier2_min is not None and tier2_uc is not None and tier2_min >= 0 and tier2_uc >= 0:
+        tiers.append((tier2_min, tier2_max if tier2_max is not None else np.inf, tier2_uc))
+    if tier3_min is not None and tier3_uc is not None and tier3_min >= 0 and tier3_uc >= 0:
+        tiers.append((tier3_min, tier3_max if tier3_max is not None else np.inf, tier3_uc))
+    
+    valid_tiers = []
+    for t in tiers:
+        if t[1] != np.inf and t[0] >= t[1]:
+            print(f"Warning: Invalid tier range {t}. Skipping.")
+        else:
+            valid_tiers.append(t)
+
+    valid_tiers = sorted(valid_tiers, key=lambda x: x[0])
+    
+    return valid_tiers
+
+# --- Combined Interface Function for Discount Model ---
+def update_discount_model(annual_demand, order_cost, holding_cost_rate_percent, 
+                          tier1_min, tier1_max, tier1_uc,
+                          tier2_min, tier2_max, tier2_uc,
+                          tier3_min, tier3_max, tier3_uc):
+    """Updates all outputs for the Quantity Discount tab."""
+    holding_cost_rate = holding_cost_rate_percent / 100.0
+
+    if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_rate_percent]):
+        return pd.DataFrame(), 0, 0, 0, "", "Please enter positive values for core discount parameters."
+    
+    discount_tiers = create_discount_tiers_df(
+        tier1_min, tier1_max, tier1_uc,
+        tier2_min, tier2_max, tier2_uc,
+        tier3_min, tier3_max, tier3_uc
+    )
+    
+    if not discount_tiers:
+        return pd.DataFrame(), 0, 0, 0, "", "No valid discount tiers defined. Please define at least one tier with positive min quantity and unit cost."
+
+    for i in range(len(discount_tiers) - 1):
+        if discount_tiers[i][2] < discount_tiers[i+1][2]:
+            return pd.DataFrame(), 0, 0, 0, "", "Error: Unit costs must be non-increasing with quantity."
+            
+    df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message = \
+        calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, discount_tiers[0][2], discount_tiers)
+
+    return df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message
+
+# --- Gradio Interface ---
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Operations Management Dashboard") as demo:
+    gr.Markdown(
+        """
+        # 📊 Advanced Operations Management Dashboard (Xyphor Advisors)
+        Welcome to your comprehensive tool for optimizing operations and inventory decisions.
+        """
+    )
+    
+    with gr.Tabs():
+        # --- Tab 1: Basic EOQ Model ---
+        with gr.TabItem("Basic EOQ Model"):
+            gr.Markdown("## Economic Order Quantity (EOQ) Calculation")
+            gr.Markdown("Find the optimal order quantity that minimizes the sum of ordering and holding costs.")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🛠️ Input Parameters")
+                    basic_demand = gr.Slider(100, 50000, value=12000, step=100, label="Annual Demand (D) [units/year]")
+                    basic_order_cost = gr.Slider(5, 500, value=100, step=5, label="Ordering Cost (S) [$/order]")
+                    basic_holding_cost = gr.Slider(0.1, 50, value=5, step=0.1, label="Holding Cost (H) [$/unit/year]")
+                    basic_lead_time = gr.Slider(0, 30, value=7, step=1, label="Lead Time [days]", info="Time from order placement to receipt.")
+                    
+                    basic_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
+
+                with gr.Column():
+                    gr.Markdown("### 📈 Cost Analysis & Optimal Q")
+                    basic_plot_output = gr.Plot(label="EOQ Cost Curves", scale=2)
+
+                    with gr.Accordion("Detailed Results", open=True):
+                        gr.Markdown("#### Key Metrics")
+                        with gr.Row():
+                            basic_eoq_out = gr.Number(label="Optimal Order Quantity (EOQ) [units]", precision=0)
+                            basic_num_orders_out = gr.Number(label="Annual Orders [count]", precision=2)
+                            basic_avg_inventory_out = gr.Number(label="Average Inventory [units]", precision=2)
+                        gr.Markdown("#### Annual Costs")
+                        with gr.Row():
+                            basic_ordering_cost_out = gr.Number(label="Annual Ordering Cost [$]", precision=2)
+                            basic_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2)
+                            basic_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2)
+                        gr.Markdown("#### Reorder Point (Simple)")
+                        with gr.Row():
+                            basic_reorder_point_out = gr.Number(label="Reorder Point (without Safety Stock) [units]", precision=0)
+
+            basic_inputs = [basic_demand, basic_order_cost, basic_holding_cost, basic_lead_time]
+            basic_outputs = [basic_plot_output, basic_eoq_out, basic_num_orders_out, basic_avg_inventory_out,
+                             basic_ordering_cost_out, basic_holding_cost_out, basic_total_cost_out,
+                             basic_reorder_point_out, basic_status_message]
+            
+            for inp in basic_inputs:
+                inp.change(
+                    fn=update_basic_eoq, 
+                    inputs=basic_inputs, 
+                    outputs=basic_outputs
+                )
+            
+            demo.load(
+                fn=update_basic_eoq, 
+                inputs=basic_inputs, 
+                outputs=basic_outputs
+            )
+
+        # --- Tab 2: Reorder Point & Safety Stock ---
+        with gr.TabItem("Reorder Point (ROP) & Safety Stock"):
+            gr.Markdown("## Reorder Point & Safety Stock Calculator")
+            gr.Markdown("Determine the precise inventory level at which to place a new order to avoid stockouts.")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🛠️ Input Parameters")
+                    rop_avg_demand = gr.Number(label="Average Daily Demand [units/day]", value=50)
+                    rop_lead_time = gr.Number(label="Lead Time [days]", value=10)
+                    rop_std_dev = gr.Number(label="Standard Deviation of Daily Demand", value=5)
+                    rop_z_score = gr.Slider(minimum=0.0, maximum=3.0, value=1.65, step=0.01, 
+                                            label="Z-Score (for Service Level)", 
+                                            info="e.g., 1.65 for 95% service level, 2.33 for 99%")
+                    rop_status = gr.Textbox(label="Status", interactive=False)
+                
+                with gr.Column():
+                    gr.Markdown("### 🔑 Calculated Metrics")
+                    rop_ss_out = gr.Number(label="Safety Stock (SS) [units]", precision=0, 
+                                           info="The buffer stock held to prevent stockouts.")
+                    rop_dlt_out = gr.Number(label="Demand During Lead Time [units]", precision=0,
+                                            info="Total expected demand while waiting for the order.")
+                    rop_out = gr.Number(label="Reorder Point (ROP) [units]", precision=0, 
+                                        info="Place an order when inventory hits this level. (ROP = SS + Demand During Lead Time)")
+
+            rop_inputs = [rop_avg_demand, rop_lead_time, rop_std_dev, rop_z_score]
+            rop_outputs = [rop_ss_out, rop_dlt_out, rop_out, rop_status]
+
+            for inp in rop_inputs:
+                inp.change(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs)
+            demo.load(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs)
+
+        # --- Tab 3: Quantity Discount Model ---
+        with gr.TabItem("Quantity Discount Model"):
+            gr.Markdown("## EOQ with Quantity Discounts")
+            gr.Markdown("Evaluate the impact of price breaks on the optimal order quantity and total cost.")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🛠️ Core Parameters")
+                    discount_demand = gr.Slider(100, 50000, value=15000, step=100, label="Annual Demand (D) [units/year]")
+                    discount_order_cost = gr.Slider(5, 500, value=75, step=5, label="Ordering Cost (S) [$/order]")
+                    discount_holding_rate = gr.Slider(0.01, 0.5, value=0.2, step=0.01, label="Holding Cost Rate [% of Unit Cost]", info="e.g., 20% = 0.2")
+
+                    gr.Markdown("### 🏷️ Discount Tiers")
+                    gr.Markdown("Define up to three discount tiers. Unit costs must be non-increasing.")
+                    with gr.Accordion("Tier 1", open=True):
+                        with gr.Row():
+                            tier1_min_qty = gr.Number(label="Min Qty", value=0, precision=0)
+                            tier1_max_qty = gr.Number(label="Max Qty", value=999, precision=0)
+                            tier1_unit_cost = gr.Number(label="Unit Cost ($)", value=10.00, precision=2)
+                    with gr.Accordion("Tier 2"):
+                        with gr.Row():
+                            tier2_min_qty = gr.Number(label="Min Qty", value=1000, precision=0)
+                            tier2_max_qty = gr.Number(label="Max Qty", value=4999, precision=0)
+                            tier2_unit_cost = gr.Number(label="Unit Cost ($)", value=9.50, precision=2)
+                    with gr.Accordion("Tier 3"):
+                        with gr.Row():
+                            tier3_min_qty = gr.Number(label="Min Qty", value=5000, precision=0)
+                            tier3_max_qty = gr.Number(label="Max Qty", value=None, precision=0, info="Leave blank for infinity") 
+                            tier3_unit_cost = gr.Number(label="Unit Cost ($)", value=9.00, precision=2)
+                    
+                    discount_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
+
+                with gr.Column():
+                    gr.Markdown("### 📊 Tier Analysis & Optimal Selection")
+                    discount_output_df = gr.DataFrame(label="Discount Tier Analysis", interactive=False)
+                    gr.Markdown("#### Optimal Discount Solution")
+                    with gr.Row():
+                        best_discount_eoq_out = gr.Number(label="Optimal Order Quantity [units]", precision=0)
+                        best_discount_cost_out = gr.Number(label="Minimum Total Annual Cost [$]", precision=2)
+                    with gr.Row():
+                        best_discount_unit_cost_out = gr.Number(label="Unit Cost at Optimal Q [$]", precision=2)
+                        best_discount_tier_out = gr.Textbox(label="Optimal Tier", interactive=False)
+            
+            discount_inputs = [discount_demand, discount_order_cost, discount_holding_rate,
+                               tier1_min_qty, tier1_max_qty, tier1_unit_cost,
+                               tier2_min_qty, tier2_max_qty, tier2_unit_cost,
+                               tier3_min_qty, tier3_max_qty, tier3_unit_cost]
+            discount_outputs = [discount_output_df, best_discount_eoq_out, best_discount_cost_out, 
+                                best_discount_unit_cost_out, best_discount_tier_out, discount_status_message]
+
+            for inp in discount_inputs:
+                inp.change(
+                    fn=update_discount_model, 
+                    inputs=discount_inputs, 
+                    outputs=discount_outputs
+                )
+            
+            demo.load(
+                fn=update_discount_model, 
+                inputs=discount_inputs, 
+                outputs=discount_outputs
+            )
+
+        # --- Tab 4: Production Order Quantity (POQ) Model ---
+        with gr.TabItem("Production Order Quantity (POQ) Model"):
+            gr.Markdown("## Production Order Quantity (POQ) Calculation")
+            gr.Markdown("Determine the optimal batch size when production is internal and gradual.")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🛠️ Input Parameters")
+                    poq_demand = gr.Slider(100, 50000, value=20000, step=100, label="Annual Demand (D) [units/year]")
+                    poq_setup_cost = gr.Slider(5, 500, value=200, step=5, label="Setup Cost (S) [$/setup]")
+                    poq_holding_cost = gr.Slider(0.1, 50, value=8, step=0.1, label="Holding Cost (H) [$/unit/year]")
+                    gr.Markdown("### 🏭 Production Specifics")
+                    poq_prod_rate = gr.Slider(10, 2000, value=500, step=10, label="Daily Production Rate (P) [units/day]")
+                    poq_demand_rate = gr.Slider(1, 1000, value=80, step=1, label="Daily Demand Rate (d) [units/day]", info="Must be less than Daily Production Rate.")
+                    
+                    poq_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.")
+
+                with gr.Column():
+                    gr.Markdown("### 📈 Cost Analysis & Optimal Batch Size")
+                    poq_plot_output = gr.Plot(label="POQ Cost Curves", scale=2)
+
+                    with gr.Accordion("Detailed Results", open=True):
+                        gr.Markdown("#### Key Metrics")
+                        with gr.Row():
+                            poq_out = gr.Number(label="Optimal Production Quantity (POQ) [units]", precision=0)
+                            poq_num_setups_out = gr.Number(label="Annual Setups [count]", precision=2)
+                            poq_max_inv_out = gr.Number(label="Maximum Inventory Level [units]", precision=2)
+                            poq_avg_inv_out = gr.Number(label="Average Inventory [units]", precision=2)
+                        gr.Markdown("#### Annual Costs")
+                        with gr.Row():
+                            poq_setup_cost_out = gr.Number(label="Annual Setup Cost [$]", precision=2)
+                            poq_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2)
+                            poq_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2)
+                        gr.Markdown("#### Production Cycle Details")
+                        with gr.Row():
+                            poq_prod_days_out = gr.Number(label="Production Run Duration [days]", precision=2)
+                            poq_cycle_days_out = gr.Number(label="Inventory Cycle Duration [days]", precision=2)
+
+            poq_inputs = [poq_demand, poq_setup_cost, poq_holding_cost, poq_prod_rate, poq_demand_rate]
+            poq_outputs = [poq_plot_output, poq_out, poq_num_setups_out, poq_max_inv_out, poq_avg_inv_out,
+                           poq_setup_cost_out, poq_holding_cost_out, poq_total_cost_out,
+                           poq_prod_days_out, poq_cycle_days_out, poq_status_message]
+
+            for inp in poq_inputs:
+                inp.change(
+                    fn=update_poq_model, 
+                    inputs=poq_inputs, 
+                    outputs=poq_outputs
+                )
+            
+            demo.load(
+                fn=update_poq_model, 
+                inputs=poq_inputs, 
+                outputs=poq_outputs
+            )
+
+        # --- Tab 5: Demand Forecasting (SMA) ---
+        with gr.TabItem("Demand Forecasting (SMA)"):
+            gr.Markdown("## Simple Moving Average (SMA) Forecasting")
+            gr.Markdown("Forecast future demand based on the average of past demand data.")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🛠️ Input Parameters")
+                    sma_data = gr.Textbox(label="Past Demand Data (comma-separated)", 
+                                          value="100, 110, 105, 120, 115, 125, 130, 122, 135, 140")
+                    sma_window = gr.Slider(minimum=2, maximum=10, value=3, step=1, 
+                                           label="SMA Window Size (Periods)")
+                    sma_status = gr.Textbox(label="Status & Forecast", interactive=False)
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### 📈 Forecast Plot")
+                    sma_plot = gr.Plot()
+                    sma_df = gr.DataFrame(label="Data and SMA")
+
+            sma_inputs = [sma_data, sma_window]
+            sma_outputs = [sma_df, sma_plot, sma_status]
+
+            for inp in sma_inputs:
+                inp.change(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs)
+            demo.load(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs)
+
+if __name__ == "__main__":
+    demo.launch(share=True, inbrowser=True, debug=True)