Marketplace Dynamics and Multi-Sided Platforms Questions

Approach (brief): cluster by proximity implicitly via greedy per-vehicle route building. For each vehicle, pick the nearest unassigned order to its start as seed, then iteratively append the nearest unassigned order that fits remaining capacity and time-window (using simple Euclidean travel time at constant speed). Repeat until no feasible additions. Continue with next vehicle.

import math
from copy import deepcopy

def travel_time(a, b, speed=30.0):
    # a,b are (x,y) coordinates; speed in distance units per hour
    return math.hypot(a[0]-b[0], a[1]-b[1]) / speed

def fits_time_window(current_time, order, arrive_time):
    # order: dict with earliest_pickup, latest_delivery, service_time (opt)
    return arrive_time <= order['latest_delivery'] and arrive_time >= order['earliest_pickup']

def assign_orders_to_vehicles(orders, vehicles, speed=30.0):
    # shallow copies
    orders = deepcopy(orders)
    for o in orders:
        o['assigned'] = False
    assignments = {v['id']: [] for v in vehicles}

    # Precompute pairwise distances if needed (omitted for brevity)
    for v in vehicles:
        loc = v['start_loc']
        cap_left = v['capacity']
        time_now = 0.0  # assume start time 0 for simplicity
        while True:
            # find nearest feasible unassigned order
            best = None
            best_metric = float('inf')
            for o in orders:
                if o['assigned'] or o['volume'] > cap_left:
                    continue
                tt = travel_time(loc, o['destination'], speed)
                arrive = time_now + tt
                if not fits_time_window(time_now, o, arrive):
                    continue
                # metric: distance (could add time slack)
                if tt < best_metric:
                    best_metric, best = tt, o
            if not best:
                break
            # assign
            assignments[v['id']].append(best['id'])
            best['assigned'] = True
            cap_left -= best['volume']
            time_now += best_metric + best.get('service_time', 0.0)
            loc = best['destination']
    return assignments

Key concepts:

• Greedy nearest-feasible selection per vehicle builds spatial clusters around each vehicle start.
• Handles capacity and simple time-window checks (arrival within earliest/latest).

Complexity:

• O(V * O^2) in worst case (V vehicles, O orders) because each vehicle may scan remaining orders repeatedly. With pairwise precomputation you can reduce repeated distance compute.

Known failure modes / caveats:

• Suboptimal: greedy may pack early nearby small orders blocking later better global solutions.
• Time windows interplay: local feasibility checks ignore downstream infeasibility (no lookahead).
• Assumes constant speed and instant service unless service_time provided.
• No route optimization inside a vehicle (insertion heuristic could improve).
• Clustering bias by vehicle start — poor if vehicle starts poorly located.
• For production, add insertion heuristics, local-search (2-opt), or use VRP solvers (OR-Tools) and model full time-window constraints.

Situation: We need a multi-echelon mixed-integer program (MIP) that chooses production, shipments, inventory and stockout decisions across factories (F), distribution centers (D) and retail nodes (R) to minimize expected total cost while meeting service level, capacity and flow conservation constraints.

Decision variables:

• Continuous:
  • x_f,t ≥ 0: production at factory f in period t
  • y_{i,j,t} ≥ 0: shipment quantity from node i to j in period t (i∈F∪D, j∈D∪R)
  • I_{n,t} ≥ 0: on-hand inventory at node n (n∈F∪D∪R) at end of t
  • S_{r,t} ≥ 0: lost sales or backorders at retail r in t
• Binary:
  • z_{i,j,t} ∈ {0,1}: open/activate shipment route i→j in t (if fixed cost or limited routes)

Parameters:

• c^p_f: unit production cost; c^{tr}_{i,j}: unit transport cost; h_n: unit holding cost; c^s_r: stockout cost per unit (or penalty)
• Cap^p_f, Cap^{tr}_{i,j}, Cap^inv_n: capacities
• D_{r,t}: demand (stochastic) at retail r in t; P scenarios ω with probability p_ω if stochastic

Objective (expected total cost over scenarios):
Minimize sum_t [ Σ_f c^p_f x_{f,t} + Σ_{i,j} c^{tr}{i,j} y{i,j,t} + Σ_n h_n I_{n,t} + Σ_r c^s_r S_{r,t} + Σ_{i,j} K_{i,j} z_{i,j,t} ] averaged over scenarios (or weighted by p_ω).

Core constraints:

1. Flow conservation (for each non-factory node n and scenario ω, period t):
   I_{n,t-1} + Σ_{i} y_{i,n,t} + (inflow from production if factory) - Σ_{j} y_{n,j,t} = D_{n,t}^ω - S_{n,t} + I_{n,t}
   For retail, consumption equals demand minus stockout.
2. Production & transport capacity:
   x_{f,t} ≤ Cap^p_f
   y_{i,j,t} ≤ Cap^{tr}{i,j} * z{i,j,t}
3. Inventory nonnegativity and linking:
   I_{n,t} ≥ 0; S_{r,t} ≥ 0
4. Service level constraint (chance or equivalent):
   Chance form: Pω( S_{r,t} ≤ s_threshold ) ≥ 1 - α OR
   Deterministic equivalent using safety stock: I_{r,t} ≥ Φ^{-1}(1-α) * σ_{demand,r,t} + expected lead-time demand
   Or use Expected Shortfall constraint: Eω[S_{r,t}] ≤ allowable_stockout
5. Integrality if route decisions or setup decisions required.

Stochastic modeling:

• Use scenario-based stochastic programming with first-stage decisions (e.g., production plans, route openings) and second-stage recourse (shipments, inventories, stockouts) per scenario. Solve expected cost over scenarios.

Scalability & heuristics for large instances:

• Scenario reduction or Sample Average Approximation (SAA) to approximate expectation with manageable scenarios.
• Decomposition:
  • Benders decomposition (master: integer first-stage vars z, x; subproblems: scenario-specific linear recourse solved in parallel; generate Benders cuts).
  • Lagrangian relaxation: relax coupling capacity or flow constraints; solve separable subproblems per facility or scenario; update multipliers via subgradient.
  • Dantzig–Wolfe / column generation for routing/lot-sizing formulations.
• Heuristics and metaheuristics:
  • Rolling-horizon heuristic: solve shorter horizons sequentially with warm starts.
  • Greedy + local search: fix route openings greedily, then optimize continuous variables; apply local search (swap open/closed routes).
  • Hybrid matheuristics: combine MILP for aggregate planning and heuristics for allocation; use LP-relaxation rounding.
• Practical tips:
  • Tighten formulation with valid inequalities (cover constraints, flow bounds).
  • Preprocess capacities/demand to prune infeasible arcs.
  • Use warm starts from LP-relaxation and exploit parallel solvers for scenario subproblems.
    Expected trade-offs: exact MIP gives optimality but scales poorly with scenarios and network size; decomposition and heuristics trade optimality gap for tractability and speed—choose based on service-level risk tolerance and compute budget.

This model can be extended to multi-period lead times, perishability, and dynamic pricing; calibrate cost/penalty parameters to reflect business KPIs (fill rate, lost-sales vs backorder).

Requirements & clarifying assumptions:

• Objective: estimate causal effect of a UI change on driver earnings and completed rides per city over time.
• Granularity: daily city-level panel; rollout dates per city known. Assume no simultaneous other treatment that perfectly colocalizes with rollout (we will control for promotions).

High-level pipeline:

1. Data ingest: daily metrics per city (earnings, completed rides), promotions, weather, supply/demand proxies, holidays, city population, rollout flag.
2. Pre-processing:
   • Impute missing data; align time zones.
   • Deseasonalize/time-decompose: fit STL or seasonal-trend decomposition per city to remove weekly/annual seasonality while retaining trend/residuals.
   • Create time-varying covariates (promo intensity, active drivers, fares) and lagged outcomes to control dynamics.
   • Covariate balancing: generate pre-treatment balance table; apply entropy balancing / propensity-score weighting across treated and donor cities using pre-period outcomes and covariates.
3. Identification strategies (triangulate):
   • Staggered DID (event-study) with Sun & Abraham or Callaway & Sant’Anna estimators to avoid bias from treatment effect heterogeneity.
   • Synthetic Control: for each treated city, build a synthetic donor using pre-treatment weighted combination of control cities on deseasonalized outcomes and covariates.
   • Matrix completion / causal impact (Bayesian structural time series) as robustness.
4. Modeling:
   • Primary: Staggered DID (panel regression with city and date fixed effects, covariates, clustered SEs by city).
   • Complementary: SC estimates for individual cities to capture heterogeneity; BSTS for probabilistic counterfactuals.
5. Sensitivity & validation:
   • Placebo tests: fake rollout dates and in-time-placebo on control cities.
   • Balance checks pre/post weighting; pre-trend tests (event-study coefficients should be ≈0 pre-treatment).
   • Leave-one-out donor tests for synthetic control.
   • Control for time-varying confounders via covariates and lagged outcomes; run models with and without these controls to assess stability.
   • Bounding: Rosenbaum sensitivity / Oster delta to assess unobserved confounding.
6. Uncertainty & presentation:
   • Report point estimates with 95% CIs from bootstrap (for SC/BSTS) and robust clustered SEs (for DID).
   • Visuals: event-study plots, observed vs counterfactual time-series per city, aggregated cumulative lift with CI, table of heterogeneity by city.
   • Explicit assumptions slide: parallel trends (for DID), donor pool adequacy (for SC), no concurrent treatments; show diagnostics (pre-trend p-values, MSPE ratio).
   • Communicate actionable interpretation (average daily earnings lift per driver, incremental completed rides per week) and scenarios (best/worst) with recommendations (further A/B, monitor metrics).
     This triangulated approach plus sensitivity checks gives leadership transparent, testable causal claims with quantified uncertainty.

Type I error (false positive): concluding a treatment has an effect when it does not. Business example: we roll out a new surge-pricing algorithm and A/B test shows a “statistically significant” increase in revenue, but the result was due to chance — we launch and anger riders/drivers, losing long‑term trust and revenue.

Type II error (false negative): failing to detect a real effect. Business example: a new driver incentives program actually increases retention, but the experiment lacked power so we conclude “no effect” and cancel the program, losing potential gains.

Significance level (alpha): probability we tolerate for Type I error (common choices: 0.05 or 0.01). Alpha = 0.05 means we accept a 5% chance of a false positive when declaring significance.

Statistical power (1 − beta): probability the test detects a true effect of a given size. Higher power reduces Type II errors. Power depends on sample size, effect size, variance, and alpha.

Trade-offs choosing alpha (0.05 vs 0.01):

• Lower alpha (0.01) reduces false positives — useful for high-cost or risky changes (pricing, safety). But it requires larger sample sizes to maintain power, increasing experiment time and cost.
• Higher alpha (0.05) is more permissive, shorter experiments, faster iterations — suitable for low-risk UI tweaks. But increases chance of launching bad changes.
  Recommendation: pick alpha based on business risk and cost of errors. For exploratory tests or cheap features, 0.05 is fine; for billing/pricing/safety-sensitive experiments prefer 0.01 and plan larger samples to keep power ≥80%. Also report effect sizes, confidence intervals, and pre-register tests to avoid multiple-testing / p-hacking.

Framework (principled, repeatable):

1. Clarify objectives with stakeholders (KPIs: cost saved, ETA reduction, customer NPS, revenue).
2. Score each request on common dimensions: Impact, Uncertainty (risk), Implementation Complexity, Dependencies.
3. Weight dimensions to reflect business priorities.
4. Compute weighted score, group into: Quick wins, Strategic bets, Defer/kill.
5. Validate with stakeholders, run small experiments for high-uncertainty/high-impact items.

Scoring rubric (1 low — 5 high; for Uncertainty higher = worse so invert in final score):

• Impact (weight 40%): 1=minimal, 5=multi-million/major KPI shift
• Uncertainty (weight 20%): 1=data-rich/low model risk, 5=data-poor/high risk (we use 6 - score to invert)
• Complexity (weight 20%): 1=one-week prototype, 5=months + infra
• Dependencies (weight 20%): 1=ownerable by DS + eng, 5=multiple teams/third-party

Example prioritize three logistics projects (scores shown -> weighted total):

1. Route optimization for last-mile (Impact 5, Uncertainty 2, Complexity 3, Dependencies 2)
   Weighted = 0.45 + 0.2(6-2)+0.2*(6-3)+0.2*(6-2) = 2.0 + 0.8 + 0.6 + 0.8 = 4.2
   Justification: High cost savings and ETA improvements, data available from telematics, moderate infra work — highest ROI; start as prioritized project with A/B pilot.

2. Regional demand forecasting for hub allocation (Impact 4, Uncertainty 3, Complexity 4, Dependencies 3)
   Weighted = 0.44 + 0.2(6-3)+0.2*(6-4)+0.2*(6-3) = 1.6 + 0.6 + 0.4 + 0.6 = 3.2
   Justification: Strategic for capacity planning (reduces overtime/stockouts) but needs integration with inventory systems; schedule after route pilot or run in parallel if engineering capacity allows.

3. Promotional targeting to reduce delivery churn (Impact 2, Uncertainty 4, Complexity 2, Dependencies 2)
   Weighted = 0.42 + 0.2(6-4)+0.2*(6-2)+0.2*(6-2) = 0.8 + 0.4 + 0.8 + 0.8 = 2.8
   Justification: Low-medium direct logistics impact, higher uncertainty on behavior lift; treat as quick experiment/POC with marketing-owned KPIs.

Next steps: present rubric and scores to stakeholders, align weights to org goals, run pilots for #1 and #3 (fast), scope engineering for #2. Re-score quarterly.