Update app.py

app.py

@@ -5,13 +5,7 @@ import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from datetime import datetime, timedelta
-from sklearn.model_selection import train_test_split
-from sklearn.compose import ColumnTransformer
-from sklearn.preprocessing import OneHotEncoder
-from sklearn.pipeline import Pipeline
-from sklearn.ensemble import RandomForestRegressor
 from sklearn.linear_model import LinearRegression
-from sklearn.metrics import r2_score, mean_absolute_error
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -76,6 +70,7 @@ st.markdown("""
 
 @st.cache_data(show_spinner=False)
 def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
+    """Generate data with REALISTIC variance patterns"""
     rng = np.random.default_rng(seed)
     start_date = datetime.today().date() - timedelta(days=days)
     dates = pd.date_range(start_date, periods=days, freq="D")
@@ -90,44 +85,59 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     channel_discount_mean = {"Direct Sales": 0.06, "Distribution Partners": 0.12, "E-Commerce": 0.04}
     channel_discount_std = {"Direct Sales": 0.02, "Distribution Partners": 0.03, "E-Commerce": 0.02}
 
+    # Elasticity varies by segment
     seg_epsilon = {}
     for p in products:
         for r in regions:
             for c in channels:
-                base_eps = rng.uniform(-0.9, -0.25)
+                # More realistic elasticity range: -0.5 to -2.5
+                base_eps = rng.uniform(-2.5, -0.5)
                 if c == "Distribution Partners":
-                    base_eps -= rng.uniform(0.1, 0.3)
+                    base_eps -= rng.uniform(0.3, 0.8)  # More price sensitive
                 if c == "E-Commerce":
-                    base_eps += rng.uniform(0.05, 0.15)
+                    base_eps -= rng.uniform(0.2, 0.5)  # Also price sensitive
                 seg_epsilon[(p, r, c)] = base_eps
 
     records = []
-    for d in dates:
+    for idx, d in enumerate(dates):
         dow = d.weekday()
-        dow_mult = 1.0 + (0.06 if dow in (5, 6) else 0)
-        macro = 1.0 + 0.03*np.sin((d.toordinal()%365)/365*2*np.pi)
+        dow_mult = 1.0 + (0.08 if dow in (5, 6) else 0)
 
-        n = rows_per_day
+        # Add realistic seasonality and random shocks
+        seasonal = 1.0 + 0.05*np.sin((d.toordinal()%365)/365*2*np.pi)
+
+        # Random market shocks (some days have big changes)
+        if rng.random() < 0.15:  # 15% of days have shocks
+            market_shock = rng.uniform(0.85, 1.15)
+        else:
+            market_shock = 1.0
+
+        # Gradual cost trends
+        cost_trend = 1.0 + (idx / len(dates)) * 0.03  # 3% cost increase over period
+
+        n = int(rows_per_day * market_shock * seasonal)
         prod = rng.choice(products, size=n, p=[0.35, 0.3, 0.2, 0.15])
         reg = rng.choice(regions, size=n, p=[0.4, 0.35, 0.25])
         ch = rng.choice(channels, size=n, p=[0.45, 0.35, 0.20])
 
         base_p = np.array([base_price[x] for x in prod]) * np.array([region_price_bump[x] for x in reg])
-        base_c = np.array([base_cost[x] for x in prod]) * np.array([region_cost_bump[x] for x in reg])
+        base_c = np.array([base_cost[x] for x in prod]) * np.array([region_cost_bump[x] for x in reg]) * cost_trend
 
+        # More variance in discounts
         discount = np.clip(
             np.array([channel_discount_mean[x] for x in ch]) +
-            rng.normal(0, [channel_discount_std[x] for x in ch]), 0, 0.45
+            rng.normal(0, [channel_discount_std[x] * 2 for x in ch]),  # Double the variance
+            0, 0.45
         )
 
-        list_price = rng.normal(base_p, 5)
+        list_price = rng.normal(base_p, 8)  # More price variance
         net_price = np.clip(list_price * (1 - discount), 20, None)
-        unit_cost = np.clip(rng.normal(base_c, 4), 10, None)
+        unit_cost = np.clip(rng.normal(base_c, 6), 10, None)
 
         eps = np.array([seg_epsilon[(pp, rr, cc)] for pp, rr, cc in zip(prod, reg, ch)])
         ref_price = np.array([base_price[x] for x in prod])
         qty_mu = np.exp(eps * (net_price - ref_price) / np.maximum(ref_price, 1e-6))
-        qty = np.maximum(1, rng.poisson(8 * dow_mult * macro * qty_mu))
+        qty = np.maximum(1, rng.poisson(8 * dow_mult * seasonal * market_shock * qty_mu))
 
         revenue = net_price * qty
         cogs = unit_cost * qty
@@ -156,14 +166,10 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     return df
 
 def analyze_margin_bridge(df, current_date, prior_date):
-    """
-    Professional Price-Volume-Mix (PVM) analysis following FP&A best practices
-    Breaks down GM variance into: Price Effect, Volume Effect, Mix Effect, Cost Effect
-    """
+    """Professional Price-Volume-Mix (PVM) analysis"""
     current_data = df[df["date"] == current_date].copy()
     prior_data = df[df["date"] == prior_date].copy()
 
-    # Calculate totals for both periods
     current_total_revenue = current_data["revenue"].sum()
     current_total_cogs = current_data["cogs"].sum()
     current_total_gm = current_total_revenue - current_total_cogs
@@ -176,7 +182,6 @@ def analyze_margin_bridge(df, current_date, prior_date):
 
     total_gm_variance = current_total_gm - prior_total_gm
 
-    # Aggregate by segment
     current_seg = current_data.groupby(["product", "region", "channel"]).agg({
         "revenue": "sum",
         "cogs": "sum",
@@ -197,7 +202,6 @@ def analyze_margin_bridge(df, current_date, prior_date):
     prior_seg["gm"] = prior_seg["revenue"] - prior_seg["cogs"]
     prior_seg["gm_pct"] = prior_seg["gm"] / prior_seg["revenue"]
 
-    # Merge segments
     merged = pd.merge(
         current_seg, 
         prior_seg, 
@@ -206,17 +210,10 @@ def analyze_margin_bridge(df, current_date, prior_date):
         how="outer"
     ).fillna(0)
 
-    # Price-Volume-Mix Decomposition (industry standard method)
-    # Price Effect: (Current Price - Prior Price) × Current Volume
+    # PVM Decomposition
     merged["price_effect"] = (merged["net_price_curr"] - merged["net_price_prior"]) * merged["qty_curr"]
-
-    # Volume Effect: (Current Volume - Prior Volume) × Prior Price × Prior GM%
     merged["volume_effect"] = (merged["qty_curr"] - merged["qty_prior"]) * merged["net_price_prior"] * merged["gm_pct_prior"]
-
-    # Cost Effect: -(Current Cost - Prior Cost) × Current Volume
     merged["cost_effect"] = -(merged["unit_cost_curr"] - merged["unit_cost_prior"]) * merged["qty_curr"]
-
-    # Mix Effect: Residual (actual GM change minus price/volume/cost effects)
     merged["gm_variance"] = merged["gm_curr"] - merged["gm_prior"]
     merged["mix_effect"] = merged["gm_variance"] - (merged["price_effect"] + merged["volume_effect"] + merged["cost_effect"])
 
@@ -233,62 +230,86 @@ def analyze_margin_bridge(df, current_date, prior_date):
     }
 
 def estimate_segment_elasticity(df, product, region, channel):
+    """Estimate price elasticity for a segment"""
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
     if len(seg_df) < 100 or seg_df["net_price"].std() < 1e-6 or seg_df["qty"].std() < 1e-6:
-        return -0.5, False
+        return -1.2, False  # Default elasticity
     try:
         x = np.log(np.clip(seg_df["net_price"].values, 1e-6, None)).reshape(-1,1)
         y = np.log(np.clip(seg_df["qty"].values, 1e-6, None))
         lin = LinearRegression().fit(x, y)
-        return float(lin.coef_[0]), True
+        elasticity = float(lin.coef_[0])
+        # Bound elasticity to realistic range
+        elasticity = np.clip(elasticity, -5.0, -0.3)
+        return elasticity, True
     except:
-        return -0.5, False
+        return -1.2, False
 
-def simulate_pricing_action(segment_df, elasticity, discount_reduction_pct):
-    if segment_df.empty:
-        return None
-    try:
-        base = segment_df.iloc[-1]
-        p0 = base["net_price"]
-        c0 = base["unit_cost"]
-        q0 = base["qty"]
-        d0 = base["discount_pct"]
-
-        new_discount = np.clip(d0 - (discount_reduction_pct/100), 0.0, 0.45)
-        p1 = max(0.01, base["list_price"] * (1 - new_discount))
-        c1 = c0
-
-        if p0 <= 0:
-            q1 = q0
+def find_optimal_discount(base_data, elasticity, search_range=(-10, 10)):
+    """
+    Find profit-maximizing discount using price elasticity of demand
+    Can recommend INCREASING or DECREASING discount
+    """
+    current_discount = base_data["discount_pct"]
+    current_list_price = base_data["list_price"]
+    current_price = base_data["net_price"]
+    current_cost = base_data["unit_cost"]
+    current_qty = base_data["qty"]
+
+    # Test discount changes from -10pp to +10pp
+    discount_changes = np.linspace(search_range[0], search_range[1], 41)
+    results = []
+
+    for disc_change in discount_changes:
+        new_discount = np.clip(current_discount + (disc_change/100), 0.0, 0.50)
+        new_price = current_list_price * (1 - new_discount)
+
+        # Apply elasticity
+        if current_price > 0:
+            price_ratio = new_price / current_price
+            new_qty = current_qty * (price_ratio ** elasticity)
         else:
-            q1 = max(0.0, q0 * (p1 / p0) ** elasticity)
-
-        rev0 = p0 * q0
-        cogs0 = c0 * q0
-        rev1 = p1 * q1
-        cogs1 = c1 * q1
-
-        gm_delta_value = (rev1 - cogs1) - (rev0 - cogs0)
-        gm0_pct = (rev0 - cogs0)/rev0 if rev0>0 else 0.0
-        gm1_pct = (rev1 - cogs1)/rev1 if rev1>0 else 0.0
-
-        return {
-            "baseline_price": p0, "new_price": p1,
-            "baseline_cost": c0, "new_cost": c1,
-            "baseline_qty": q0, "new_qty": q1,
-            "baseline_discount": d0*100, "new_discount": new_discount*100,
-            "gm_delta_value": gm_delta_value,
-            "gm0_pct": gm0_pct, "gm1_pct": gm1_pct,
-            "revenue_delta": rev1 - rev0
-        }
-    except:
-        return None
+            new_qty = current_qty
+
+        new_revenue = new_price * new_qty
+        new_cogs = current_cost * new_qty
+        new_gm = new_revenue - new_cogs
+
+        results.append({
+            "discount_change": disc_change,
+            "new_discount": new_discount * 100,
+            "new_price": new_price,
+            "new_qty": new_qty,
+            "new_gm": new_gm,
+            "new_revenue": new_revenue
+        })
+
+    results_df = pd.DataFrame(results)
+    optimal_idx = results_df["new_gm"].idxmax()
+    optimal = results_df.iloc[optimal_idx]
+
+    current_gm = current_price * current_qty - current_cost * current_qty
+
+    return {
+        "current_discount": current_discount * 100,
+        "optimal_discount": optimal["new_discount"],
+        "discount_change": optimal["discount_change"],
+        "current_price": current_price,
+        "optimal_price": optimal["new_price"],
+        "current_qty": current_qty,
+        "optimal_qty": optimal["new_qty"],
+        "current_gm": current_gm,
+        "optimal_gm": optimal["new_gm"],
+        "gm_uplift": optimal["new_gm"] - current_gm,
+        "elasticity": elasticity,
+        "all_scenarios": results_df
+    }
 
 # Main App
 st.markdown('<h1 class="main-header">🎯 Daily Profitability Variance Analysis</h1>', unsafe_allow_html=True)
 st.markdown('<p class="sub-header">Understanding What Drives Daily Margin Changes</p>', unsafe_allow_html=True)
 
-# Generate data
+# Generate data with realistic variance
 with st.spinner("🔄 Loading business data..."):
     df = generate_synthetic_data(days=60, seed=42, rows_per_day=600)
 
@@ -350,7 +371,7 @@ with col4:
         delta_color="normal"
     )
 
-# Trend chart
+# Trend chart with REAL variance
 st.markdown("#### 📈 Gross Margin Trend (Last 30 Days)")
 recent_daily = daily.tail(30)
 
@@ -365,7 +386,7 @@ fig_trend.add_trace(go.Scatter(
     fillcolor="rgba(31, 119, 180, 0.1)"
 ))
 fig_trend.add_hline(y=roll7*100, line_dash="dash", line_color="red", 
-                   annotation_text="7-Day Average", annotation_position="right")
+                   annotation_text=f"7-Day Avg: {roll7*100:.2f}%", annotation_position="right")
 fig_trend.update_layout(
     xaxis_title="Date",
     yaxis_title="Gross Margin %",
@@ -380,8 +401,8 @@ st.markdown("---")
 with st.spinner("🔬 Performing Price-Volume-Mix analysis..."):
     variance_detail, summary = analyze_margin_bridge(df, current_date, prior_date)
 
-# Main Analysis Tabs
-tab1, tab2, tab3 = st.tabs(["📊 Margin Bridge (PVM)", "🔍 Segment Deep Dive", "💡 Pricing Opportunities"])
+# Main Tabs
+tab1, tab2, tab3 = st.tabs(["📊 Margin Bridge (PVM)", "🔍 Segment Deep Dive", "💡 Optimal Pricing"])
 
 with tab1:
     st.markdown(f"### Gross Margin Bridge: {prior_date.strftime('%b %d')} → {current_date.strftime('%b %d')}")
@@ -394,7 +415,7 @@ with tab1:
     </div>
     """, unsafe_allow_html=True)
 
-    # Waterfall Chart - Professional PVM Analysis
+    # Waterfall Chart
     st.markdown("#### Price-Volume-Mix (PVM) Waterfall Analysis")
 
     waterfall_data = pd.DataFrame({
@@ -438,23 +459,21 @@ with tab1:
     )
     st.plotly_chart(fig_waterfall, use_container_width=True)
 
-    # Explanation of each component
+    # Explanations
     col_exp1, col_exp2 = st.columns(2)
 
     with col_exp1:
         st.markdown(f"""
         <div class="insight-box">
         <b>💰 Price Effect:</b> ${summary['price_effect_total']/1000:+.1f}K<br>
-        <small>Impact of changes in average selling prices across all transactions.
-        Positive = higher prices captured, Negative = price erosion or higher discounts.</small>
+        <small>Impact of changes in realized selling prices</small>
         </div>
         """, unsafe_allow_html=True)
 
         st.markdown(f"""
         <div class="insight-box">
         <b>📦 Volume Effect:</b> ${summary['volume_effect_total']/1000:+.1f}K<br>
-        <small>Impact of selling more or fewer units at prior period margins.
-        Positive = higher volumes, Negative = volume decline.</small>
+        <small>Impact of selling more/fewer units</small>
         </div>
         """, unsafe_allow_html=True)
 
@@ -462,187 +481,173 @@ with tab1:
         st.markdown(f"""
         <div class="insight-box">
         <b>🏭 Cost Effect:</b> ${summary['cost_effect_total']/1000:+.1f}K<br>
-        <small>Impact of changes in unit costs (COGS).
-        Positive = cost reduction, Negative = cost inflation.</small>
+        <small>Impact of changes in unit costs</small>
         </div>
         """, unsafe_allow_html=True)
 
         st.markdown(f"""
         <div class="insight-box">
         <b>🔀 Mix Effect:</b> ${summary['mix_effect_total']/1000:+.1f}K<br>
-        <small>Impact of shifts in product, channel, or customer mix.
-        Reflects selling relatively more/less of high-margin items.</small>
+        <small>Impact of product/channel mix shifts</small>
         </div>
         """, unsafe_allow_html=True)
 
-    # Key Insight
-    dominant_effect = max([
-        ("Price changes", summary['price_effect_total']),
-        ("Volume changes", summary['volume_effect_total']),
-        ("Cost changes", summary['cost_effect_total']),
-        ("Mix shifts", summary['mix_effect_total'])
-    ], key=lambda x: abs(x[1]))
-
-    st.markdown(f"""
-    <div class="{'insight-box' if gm_variance_dollar > 0 else 'warning-box'}">
-    <b>🎯 Key Takeaway:</b><br>
-    The primary driver of today's margin {'improvement' if gm_variance_dollar > 0 else 'decline'} was 
-    <b>{dominant_effect[0]}</b>, contributing ${dominant_effect[1]/1000:+.1f}K to the overall variance.
-    </div>
-    """, unsafe_allow_html=True)
-
 with tab2:
     st.markdown("### Segment-Level Variance Analysis")
-    st.markdown("""
-    <div class="insight-box">
-    <b>🔍 Detailed Breakdown:</b> Which specific product-region-channel combinations drove the margin change?
-    </div>
-    """, unsafe_allow_html=True)
 
-    # Top positive and negative contributors
     variance_detail_sorted = variance_detail.sort_values("gm_variance", ascending=False)
 
     col_seg1, col_seg2 = st.columns(2)
 
     with col_seg1:
         st.markdown("#### 📈 Top 5 Margin Gainers")
-        top_gainers = variance_detail_sorted.head(5)
-
-        for idx, row in top_gainers.iterrows():
+        for _, row in variance_detail_sorted.head(5).iterrows():
             if row["gm_variance"] > 0:
                 st.markdown(f"""
                 <div class="recommendation-card" style="border-left: 4px solid #28a745;">
                 <b>{row['product']}</b><br>
                 <small>{row['region']} • {row['channel']}</small><br>
                 <span class="positive-impact">+${row['gm_variance']:.2f}</span><br>
-                <small>
-                • Price Effect: ${row['price_effect']:+.2f}<br>
-                • Volume Effect: ${row['volume_effect']:+.2f}<br>
-                • Cost Effect: ${row['cost_effect']:+.2f}<br>
-                • Mix Effect: ${row['mix_effect']:+.2f}
-                </small>
+                <small>Price: ${row['price_effect']:+.2f} | Volume: ${row['volume_effect']:+.2f} | Cost: ${row['cost_effect']:+.2f}</small>
                 </div>
                 """, unsafe_allow_html=True)
 
     with col_seg2:
         st.markdown("#### 📉 Top 5 Margin Losers")
-        top_losers = variance_detail_sorted.tail(5)
-
-        for idx, row in top_losers.iterrows():
+        for _, row in variance_detail_sorted.tail(5).iterrows():
             if row["gm_variance"] < 0:
                 st.markdown(f"""
                 <div class="recommendation-card" style="border-left: 4px solid #dc3545;">
                 <b>{row['product']}</b><br>
                 <small>{row['region']} • {row['channel']}</small><br>
                 <span class="negative-impact">${row['gm_variance']:.2f}</span><br>
-                <small>
-                • Price Effect: ${row['price_effect']:+.2f}<br>
-                • Volume Effect: ${row['volume_effect']:+.2f}<br>
-                • Cost Effect: ${row['cost_effect']:+.2f}<br>
-                • Mix Effect: ${row['mix_effect']:+.2f}
-                </small>
+                <small>Price: ${row['price_effect']:+.2f} | Volume: ${row['volume_effect']:+.2f} | Cost: ${row['cost_effect']:+.2f}</small>
                 </div>
                 """, unsafe_allow_html=True)
 
-    # Detailed table
-    st.markdown("---")
-    st.markdown("#### Complete Segment Variance Table")
-
-    display_variance = variance_detail[[
-        "product", "region", "channel", "gm_variance",
-        "price_effect", "volume_effect", "cost_effect", "mix_effect"
-    ]].sort_values("gm_variance", ascending=False)
-
-    display_variance.columns = [
-        "Product", "Region", "Channel", "GM Variance",
-        "Price Effect", "Volume Effect", "Cost Effect", "Mix Effect"
-    ]
-
-    st.dataframe(display_variance.style.format({
-        "GM Variance": "${:,.2f}",
-        "Price Effect": "${:,.2f}",
-        "Volume Effect": "${:,.2f}",
-        "Cost Effect": "${:,.2f}",
-        "Mix Effect": "${:,.2f}"
-    }).background_gradient(subset=["GM Variance"], cmap="RdYlGn", vmin=-1000, vmax=1000),
-    use_container_width=True, height=400)
-
 with tab3:
-    st.markdown("### Pricing Optimization Opportunities")
+    st.markdown("### Optimal Pricing Analysis")
     st.markdown("""
     <div class="insight-box">
-    <b>💡 AI Recommendations:</b> Based on segments with declining margins, here are pricing actions to consider.
+    <b>🎯 Profit Maximization:</b> Using price elasticity of demand to find the optimal discount level.
+    <br>May recommend <b>increasing</b> or <b>decreasing</b> discount depending on elasticity.
     </div>
     """, unsafe_allow_html=True)
 
-    # Focus on segments with negative GM variance and negative price effects
-    problem_segments = variance_detail[
-        (variance_detail["gm_variance"] < -50) | 
-        (variance_detail["price_effect"] < -50)
-    ].copy()
-    problem_segments["priority_score"] = problem_segments["gm_variance"]
-    problem_segments = problem_segments.sort_values("priority_score")
+    # Get segments with meaningful volume
+    recent_segments = df[df["date"] >= (current_date - timedelta(days=7))].groupby(["product", "region", "channel"]).agg({
+        "qty": "sum",
+        "gm_value": "sum"
+    }).reset_index()
+    recent_segments = recent_segments[recent_segments["qty"] > 100]  # Minimum volume threshold
+
+    optimization_results = []
 
-    recs = []
-    for _, seg in problem_segments.head(15).iterrows():
+    for _, seg in recent_segments.iterrows():
         p, r, c = seg["product"], seg["region"], seg["channel"]
         hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
 
-        if hist.empty or len(hist) < 50:
+        if hist.empty or len(hist) < 100:
             continue
 
-        eps, _ = estimate_segment_elasticity(hist, p, r, c)
-        discount_reduction = 2.0  # Standard 2pp reduction
-        sim = simulate_pricing_action(hist, eps, discount_reduction)
+        elasticity, is_valid = estimate_segment_elasticity(hist, p, r, c)
 
-        if sim and sim["gm_delta_value"] > 0:
-            daily_txns = len(hist) / ((hist["date"].max() - hist["date"].min()).days + 1)
-            annual_impact = sim["gm_delta_value"] * daily_txns * 365
+        if not is_valid:
+            continue
+
+        current_state = hist.iloc[-1]
+        optimal_result = find_optimal_discount(current_state, elasticity)
 
-            recs.append({
-                "Segment": p,
+        if abs(optimal_result["gm_uplift"]) > 5:  # Only show meaningful opportunities
+            optimization_results.append({
+                "Product": p,
                 "Region": r,
                 "Channel": c,
-                "Yesterday GM Loss": seg["gm_variance"],
-                "Root Cause": "Price erosion" if seg["price_effect"] < -30 else "Volume decline" if seg["volume_effect"] < -30 else "Cost increase",
-                "Recommended Action": f"Reduce discount from {sim['baseline_discount']:.1f}% to {sim['new_discount']:.1f}%",
-                "Expected Daily GM Uplift": sim["gm_delta_value"],
-                "Estimated Annual Impact": annual_impact
+                "Current Discount": optimal_result["current_discount"],
+                "Optimal Discount": optimal_result["optimal_discount"],
+                "Discount Change": optimal_result["discount_change"],
+                "Price Elasticity": elasticity,
+                "Current GM/Day": optimal_result["current_gm"],
+                "Optimal GM/Day": optimal_result["optimal_gm"],
+                "Daily GM Uplift": optimal_result["gm_uplift"],
+                "Direction": "Increase Discount" if optimal_result["discount_change"] > 0 else "Decrease Discount",
+                "all_scenarios": optimal_result["all_scenarios"]
             })
 
-    recs_df = pd.DataFrame(recs).sort_values("Expected Daily GM Uplift", ascending=False)
+    opt_df = pd.DataFrame(optimization_results).sort_values("Daily GM Uplift", ascending=False)
 
-    if len(recs_df) > 0:
-        st.markdown("#### 🏆 Top 3 Priority Actions")
+    if len(opt_df) > 0:
+        st.markdown("#### 🏆 Top 5 Optimization Opportunities")
+
+        for i, (_, rec) in enumerate(opt_df.head(5).iterrows()):
+            direction_color = "#ff7f0e" if rec["Direction"] == "Increase Discount" else "#1f77b4"
 
-        for i, (_, rec) in enumerate(recs_df.head(3).iterrows()):
             st.markdown(f"""
-            <div class="recommendation-card">
-                <h4>#{i+1}: {rec['Segment']} • {rec['Region']} • {rec['Channel']}</h4>
-                <p><b>Yesterday's Performance:</b> Lost ${abs(rec['Yesterday GM Loss']):.2f} in gross margin</p>
-                <p><b>Root Cause:</b> {rec['Root Cause']}</p>
-                <p><b>Recommended Action:</b> {rec['Recommended Action']}</p>
-                <p class="positive-impact">💰 Expected Daily Recovery: ${rec['Expected Daily GM Uplift']:.2f}</p>
-                <p><small>📊 Annual Impact Estimate: ${rec['Estimated Annual Impact']/1e3:.1f}K</small></p>
+            <div class="recommendation-card" style="border-left: 5px solid {direction_color};">
+                <h4>#{i+1}: {rec['Product']} • {rec['Region']} • {rec['Channel']}</h4>
+                <p><b>Elasticity:</b> {rec['Price Elasticity']:.2f} ({"Elastic" if rec['Price Elasticity'] < -1.5 else "Inelastic"})</p>
+                <p><b>Recommendation:</b> {rec['Direction']} by {abs(rec['Discount Change']):.1f}pp</p>
+                <p><small>Current: {rec['Current Discount']:.1f}% → Optimal: {rec['Optimal Discount']:.1f}%</small></p>
+                <p class="positive-impact">💰 Expected Uplift: ${rec['Daily GM Uplift']:.2f}/day</p>
+                <p><small>Annual Impact: ${rec['Daily GM Uplift']*365/1000:.1f}K</small></p>
             </div>
             """, unsafe_allow_html=True)
 
+            # Show elasticity curve
+            with st.expander(f"📊 View Profit Curve for {rec['Product']} • {rec['Region']} • {rec['Channel']}"):
+                scenario_df = rec["all_scenarios"]
+
+                fig_curve = go.Figure()
+                fig_curve.add_trace(go.Scatter(
+                    x=scenario_df["new_discount"],
+                    y=scenario_df["new_gm"],
+                    mode='lines',
+                    name='Gross Margin',
+                    line=dict(color='#1f77b4', width=3)
+                ))
+
+                fig_curve.add_vline(x=rec["Current Discount"], line_dash="dash", line_color="red",
+                                   annotation_text=f"Current: {rec['Current Discount']:.1f}%")
+                fig_curve.add_vline(x=rec["Optimal Discount"], line_dash="dash", line_color="green",
+                                   annotation_text=f"Optimal: {rec['Optimal Discount']:.1f}%")
+
+                fig_curve.update_layout(
+                    title=f"Profit Maximization Curve (Elasticity: {rec['Price Elasticity']:.2f})",
+                    xaxis_title="Discount Level (%)",
+                    yaxis_title="Expected Gross Margin ($)",
+                    height=400
+                )
+                st.plotly_chart(fig_curve, use_container_width=True)
+
         st.markdown("---")
-        st.markdown("#### Complete Action Plan")
-        st.dataframe(recs_df, use_container_width=True)
+        st.markdown("#### Complete Optimization List")
+
+        display_opt = opt_df[[
+            "Product", "Region", "Channel", "Current Discount", "Optimal Discount",
+            "Discount Change", "Price Elasticity", "Daily GM Uplift", "Direction"
+        ]].copy()
+
+        st.dataframe(display_opt.style.format({
+            "Current Discount": "{:.1f}%",
+            "Optimal Discount": "{:.1f}%",
+            "Discount Change": "{:+.1f}pp",
+            "Price Elasticity": "{:.2f}",
+            "Daily GM Uplift": "${:,.2f}"
+        }).background_gradient(subset=["Daily GM Uplift"], cmap="Greens"),
+        use_container_width=True, height=400)
 
         st.download_button(
-            label="📥 Download Recommendations (CSV)",
-            data=recs_df.to_csv(index=False).encode("utf-8"),
-            file_name=f"margin_recovery_plan_{current_date.strftime('%Y%m%d')}.csv",
+            label="📥 Download Optimization Plan (CSV)",
+            data=opt_df.drop(columns=["all_scenarios"]).to_csv(index=False).encode("utf-8"),
+            file_name=f"optimal_pricing_plan_{current_date.strftime('%Y%m%d')}.csv",
             mime="text/csv"
         )
     else:
-        st.success("✅ All segments performing well. No immediate pricing interventions needed.")
+        st.info("All segments are currently near optimal pricing levels.")
 
 st.markdown("---")
 st.markdown("""
 <div style="text-align: center; color: #666; padding: 1rem;">
-    <small>🔒 Demo Mode: Using synthetic SAP-style transaction data for illustration</small>
+    <small>🔒 Demo Mode: Using synthetic transaction data with realistic variance patterns</small>
 </div>
 """, unsafe_allow_html=True)