Enhance lineup optimization by adding cascading constraints and new parameters for objective value tracking. The optimize_single_lineup function now returns both the optimized row and the achieved objective value, allowing for more refined control over lineup adjustments. Additionally, the optimize_lineup function incorporates cascading optimization logic to ensure each row's objective is constrained by the previous row's performance.

app.py

@@ -1855,7 +1855,6 @@ if selected_tab == 'Projections Management':
             position_options = ['All Positions'] + sorted(projections_editor_df['position'].unique().tolist())
             position_filter = st.selectbox("Filter by Position", options=position_options, key='proj_position_filter')
         
-        # Apply filters
         filtered_df = projections_editor_df.copy()
         if player_search:
             filtered_df = filtered_df[filtered_df['player_names'].str.contains(player_search, case=False, na=False)]
@@ -1864,7 +1863,6 @@ if selected_tab == 'Projections Management':
         if position_filter != 'All Positions':
             filtered_df = filtered_df[filtered_df['position'] == position_filter]
         
-        # Display the editable dataframe
         edited_df = st.data_editor(
             filtered_df,
             column_config=column_config,
@@ -1879,11 +1877,9 @@ if selected_tab == 'Projections Management':
             changed_rows = edited_df[changed_mask]
             
             if len(changed_rows) > 0:
-                # Update the projections_df in session state
                 for idx, row in changed_rows.iterrows():
                     player_name = row['player_names']
                     
-                    # Find and update the original projections_df
                     orig_idx = st.session_state['portfolio_inc_proj'][st.session_state['portfolio_inc_proj']['player_names'] == player_name].index
                     if len(orig_idx) > 0:
                         # Player exists in portfolio_inc_proj - update existing row

global_func/optimize_lineup.py

@@ -22,8 +22,9 @@ def optimize_single_lineup(
     type_var: str,
     sport_var: str,
     salary_max: int,
-    optimize_by: str = 'median'
-) -> pd.Series:
+    optimize_by: str = 'median',
+    max_objective_value: float = None  # NEW PARAMETER
+) -> tuple[pd.Series, float]:  # NOW RETURNS (row, objective_value)
     """
     Optimize a single lineup row using linear programming.
     
@@ -40,9 +41,10 @@ def optimize_single_lineup(
         sport_var: Sport identifier (NFL, NBA, MLB, etc.)
         salary_max: Maximum salary cap for the lineup
         optimize_by: 'median' or 'ownership' - which metric to optimize for
+        max_objective_value: Maximum allowed objective value (for cascading optimization)
         
     Returns:
-        Optimized row with potentially upgraded players
+        Tuple of (optimized_row, achieved_objective_value)
     """
     # Create a copy of the row to modify
     optimized_row = row.copy()
@@ -52,6 +54,7 @@ def optimize_single_lineup(
     open_columns = []
     locked_salary = 0
     locked_player_names = set()
+    locked_objective_value = 0  # Track locked player contribution to objective
     
     for col in player_columns:
         player_name = row[col]
@@ -62,17 +65,30 @@ def optimize_single_lineup(
             locked_players[col] = player_name
             locked_salary += get_effective_salary(player_name, col, map_dict, type_var)
             locked_player_names.add(player_name)
+            
+            # Add locked player's contribution to objective
+            player_data = player_pool[player_pool['player_names'] == player_name]
+            if not player_data.empty:
+                locked_objective_value += player_data.iloc[0].get(optimize_by, player_data.iloc[0].get('median', 0))
         else:
             # This position is open for optimization
             open_columns.append(col)
     
-    # If no open columns, nothing to optimize
+    # If no open columns, return with locked objective value
     if not open_columns:
-        return optimized_row
+        return optimized_row, locked_objective_value
     
     # Calculate remaining salary budget
     remaining_salary = salary_max - locked_salary
     
+    # Calculate remaining objective budget (if max_objective_value is set)
+    remaining_objective_budget = None
+    if max_objective_value is not None:
+        remaining_objective_budget = max_objective_value - locked_objective_value
+        # If we can't meet the constraint, return original row
+        if remaining_objective_budget < 0:
+            return optimized_row, locked_objective_value
+    
     # Filter player pool: exclude locked teams and already-locked players
     available_players = player_pool[
         (~player_pool['team'].isin(lock_teams)) & 
@@ -83,19 +99,18 @@ def optimize_single_lineup(
     available_players = available_players.drop_duplicates(subset=['player_names'], keep='first')
     
     if available_players.empty:
-        return optimized_row
+        return optimized_row, locked_objective_value
     
     # Build the optimization model
     solver = pywraplp.Solver.CreateSolver('CBC')
     if not solver:
         # Fallback if solver not available
-        return optimized_row
+        return optimized_row, locked_objective_value
     
     # Create decision variables: x[player_idx, col_idx] = 1 if player is assigned to column
     player_list = available_players.to_dict('records')
     num_players = len(player_list)
     num_open_cols = len(open_columns)
-    num_player_columns = len(player_columns)
     
     # x[i][j] = 1 if player i is assigned to open column j
     x = {}
@@ -112,10 +127,9 @@ def optimize_single_lineup(
         solver.Add(sum(x[i, j] for j in range(num_open_cols)) <= 1)
 
     # Constraint 3: Players already LOCKED in the row cannot be selected again
-    # (only check locked_player_names, not all players in row)
     for i, player in enumerate(player_list):
         player_name = player['player_names']
-        if player_name in locked_player_names:  # ✅ Only check locked players
+        if player_name in locked_player_names:
             for j in range(num_open_cols):
                 solver.Add(x[i, j] == 0)
 
@@ -138,27 +152,34 @@ def optimize_single_lineup(
             salary_constraint.append(x[i, j] * effective_salary)
     solver.Add(sum(salary_constraint) <= remaining_salary)
     
-    # Objective: Maximize the sum of the optimization metric
+    # NEW Constraint 6: Total objective value <= max_objective_value (if specified)
     objective_terms = []
     for i, player in enumerate(player_list):
         metric_value = player.get(optimize_by, player.get('median', 0))
         for j in range(num_open_cols):
             objective_terms.append(x[i, j] * metric_value)
     
+    if remaining_objective_budget is not None:
+        solver.Add(sum(objective_terms) <= remaining_objective_budget)
+    
+    # Objective: Maximize the sum of the optimization metric
     solver.Maximize(sum(objective_terms))
     
     # Solve
     status = solver.Solve()
     
+    achieved_objective = locked_objective_value  # Start with locked contribution
+    
     if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
         # Extract solution
         for j, col in enumerate(open_columns):
             for i, player in enumerate(player_list):
                 if x[i, j].solution_value() > 0.5:
                     optimized_row[col] = player['player_names']
+                    achieved_objective += player.get(optimize_by, player.get('median', 0))
                     break
     
-    return optimized_row
+    return optimized_row, achieved_objective
 
 
 def optimize_lineup(
@@ -171,7 +192,9 @@ def optimize_lineup(
     type_var: str,
     sport_var: str,
     salary_max: int,
-    optimize_by: str = 'median'
+    optimize_by: str = 'median',
+    use_cascading: bool = True,  # NEW PARAMETER
+    cascade_decrement: float = 0.01  # NEW PARAMETER
 ) -> pd.DataFrame:
     """
     Optimize all lineups in a portfolio using linear programming.
@@ -192,6 +215,8 @@ def optimize_lineup(
         sport_var: Sport identifier (NFL, NBA, MLB, etc.)
         salary_max: Maximum salary cap for lineups
         optimize_by: 'median' or 'ownership' - which metric to optimize for (higher is better)
+        use_cascading: If True, each row's max objective is constrained by previous row
+        cascade_decrement: Amount to subtract from previous row's objective (default 0.01)
         
     Returns:
         DataFrame with optimized lineups
@@ -199,10 +224,19 @@ def optimize_lineup(
     # Create a copy to avoid modifying the original
     optimized_frame = working_frame.copy()
     
+    # Track the previous row's objective value
+    previous_objective = None
+    
     # Optimize each row
     for idx in optimized_frame.index:
         row = optimized_frame.loc[idx]
-        optimized_row = optimize_single_lineup(
+        
+        # Set max_objective_value based on cascading setting
+        max_objective = None
+        if use_cascading and previous_objective is not None:
+            max_objective = previous_objective - cascade_decrement
+        
+        optimized_row, achieved_objective = optimize_single_lineup(
             row=row,
             player_columns=player_columns,
             player_pool=projections_df,
@@ -211,8 +245,12 @@ def optimize_lineup(
             type_var=type_var,
             sport_var=sport_var,
             salary_max=salary_max,
-            optimize_by=optimize_by
+            optimize_by=optimize_by,
+            max_objective_value=max_objective
         )
         optimized_frame.loc[idx] = optimized_row
+        
+        # Update previous_objective for next iteration
+        previous_objective = achieved_objective
     
-    return optimized_frame
+    return optimized_frame