MEIO — EOQ→ROP Refinement & the Type-2 Loss Function

How the Economic Order Quantity refines the reorder point inside the MEIO engine: a V1 / V2 / V3 comparison and the plan to replace the EOQ averaging heuristic with the exact first-order loss function β = 1 − n₁(s)/Q.

1. The intuition — why ROP must drop as EOQ rises

Consider a continuous-review (s, Q) policy: when the inventory position drops to the reorder point s, an order of size Q (the EOQ) is placed. The order arrives after the lead time L. During that lead time, demand continues to arrive and the on-hand inventory is consumed.

The key insight is that a larger order quantity spreads the risk of a stockout over a longer cycle. Each replenishment cycle places the system back at inventory position = s + Q. A stockout within the cycle can only occur during the lead-time window, but the fraction of demand that is back-ordered depends on how much demand the cycle must satisfy relative to the shortage:

where n₁(s) = E[(X − s)⁺] is the first-order loss function (expected shortage) for demand-during-lead-time X at reorder point s.

Because n₁(s)/Q shrinks as Q grows, β rises with Q at fixed s. Therefore, to hold a target fill rate β* constant, s (the ROP, and hence the safety stock SS = s − d̅L) must decrease as the EOQ increases.

This is the planner's intuition, and it is the textbook result (Silver, Pyke & Peterson; Axsäter). It is also the reason the MEIO engine accepts an eoq field per SKU — the EOQ is not only a cycle-stock input, it is a safety-stock input.

2. Type-1 vs Type-2 service — the crux

There are two distinct “service level” definitions, and only one of them depends on the EOQ:

Worked example

Demand-during-lead-time X ~ Normal(μ=100, σ=30), target fill rate β* = 0.99:

As Q grows, the same target fill rate is achieved with a lower reorder point — eventually dropping below the mean lead-time demand (negative safety stock), which is correct: a large enough order quantity back-fills the shortage from the cycle's own surplus.

3. The (s, Q) loss-function theory

The first-order loss function is the expected shortage above a threshold:

The exact Type-2 fill rate is then:

and the inverse (find s for a target β*) solves n₁(s) = Q(1 − β*).

Per-distribution loss functions

The Normal case σ·L(z) is the standard “normal loss” tabulated in every inventory textbook; the others are the natural generalisations.

4. Current state — V1 (Python)

The legacy V1 implementation lives in files/MEIO/intial/. It is not the production MEIO path (production runs the Rust V2/V3 optimizer), but it is the historical reference and is intentionally left unchanged for legacy comparison.

The averaging forward loop

Distributions.py:90 — golden_formula_ROP2FR and the sibling poisson_distribution_ROP2FR (:32) compute the fill rate by averaging the CDF over the inventory-position range [ROP, ROP + EOQ]:

step = int(max(1, avgsize, math.ceil((eoq)/maxEoqFreq)))   # maxEoqFreq = 10
tested_eoq = 0
while tested_eoq < eoq + step:
    maxEoq = min(eoq, tested_eoq)
    fill_rate = ndtr(safetyStock / racine)                # normal CDF at ROP+tested_eoq
    total_fill_rate += fill_rate
    tested_eoq += step
return total_fill_rate / loop_counter                      # average over ~10 points

This is a midpoint / trapezoidal approximation of (1/Q) ∫F(s + q) dq, which is related to the loss function (the integral form of n₁ is (1/Q) ∫(1−F(s+q)) dq) but only coarsely. It effectively subtracts roughly eoq/2 from the buffer.

The −eoq/2 heuristic in the inverse & jump

• poisson_distribution_FR2ROP (Distributions.py:20): rop = poisson.ppf(FR)·avgsize − int(eoq)/2 — a direct −eoq/2 heuristic.
• MEIO.initialJump (MEIO.py:131): returned_buffer = max(avg_size, ceil(forecast_ovr_lt·avg_size − ceil(eoq/2))).

The EOQ-blind gaps (V1)

• normal_distribution_FR2ROP (Distributions.py:78): rop = norm.ppf(FR, loc=forecastlt, scale=lt_stdev)·avgsize — ignores EOQ entirely. So high-volume (Normal) SKUs get no EOQ-driven ROP reduction.
• MEIO.minMaxROPQty (MEIO.py:481): tgt_min_rop_qty = tgt_min_sl_qty + effective_total_lt_fcst — the ROP bounds ignore EOQ, so the EOQ-driven reduction can be capped by the floor.

5. Current state — V2/V3 (Rust)

The production optimizer lives in files/MEIO_v3/src/ and serves both V2 and V3 (the V3 additions are the empirical/bootstrap distributions; the fill-rate math path is shared). See meio_runner.py:1375 — V3 is the default, V2 is the explicit fallback.

The V2 eoq_step fix

math.rs:175 — the integration step is now driven by the route lot size (effective_lot_size(), i.e. route.mult_qty) instead of the demand-line avg_size. V1 used avg_size, which for weekly demand buckets made the step ~13× too large (meio_runner.py:1164). The forward averaging loop in distributions.rs:300 (golden_formula_rop_to_fr), :363 (poisson_rop_to_fr) and :381 (fitted_cdf_rop_to_fr) is structurally identical to V1 — same averaging approximation, just with a corrected step.

Where EOQ is applied correctly (V2/V3)

• distributions.rs:402 poisson_fr_to_rop: rop = k·avg_size − eoq/2 — keeps the −eoq/2 heuristic ✓
• marginal.rs:146 initial_jump: first_buf = max(lot_size, ceil(fcst_lt·lot_size − eoq/2)) ✓

The EOQ-blind gaps (V2/V3)

• distributions.rs:425 normal_fr_to_rop: rop = (forecast_lt + z·σ)·avg_size — ignores EOQ. Same defect as V1's normal_distribution_FR2ROP. High-volume Normal SKUs (the majority of the catalogue) get no EOQ-driven ROP reduction.
• marginal.rs:179 further_jump — the Normal branch (:212) computes the next buffer from the z-score and lead-time-demand only; EOQ is not in the formula. Only the Poisson branch (:201) calls the EOQ-aware poisson_fr_to_rop.
• marginal.rs:39 min_max_rop_qty: tgt_min_rop_qty = tgt_min_sl_qty + effective_total_lt_fcst — the floor ignores EOQ, so the reduction can be capped.

The V3 empirical path

The V3 empirical / compound-Poisson / bucketed distributions (distributions.rs:42-82) route through fitted_cdf_rop_to_fr (:381), which uses the same averaging loop as the parametric distributions — so the EOQ effect is the same coarse midpoint approximation, not the exact empirical mean-excess loss function.

6. Current state — V3 standalone Python

files/inventory_engine/rop.py is the V3 reference / dashboard engine (a pure-Python empirical-bootstrap inventory optimiser). It is not the production MEIO write path today (the Rust optimizer writes PIPE_meio_results), but it is the documented “future” ROP engine and is exposed via the service-level-curve API (main.py:27560).

rop.py:19 — reorder_point:

def reorder_point(simulated_ltd_samples, service_level):
    return EmpiricalDistribution(simulated_ltd_samples).inv_cdf(service_level)

rop.py:73 — fill_rate_for_buffer:

def fill_rate_for_buffer(simulated_ltd_samples, buffer):
    return EmpiricalDistribution(simulated_ltd_samples).cdf(buffer)

7. Version-comparison matrix

✓ = EOQ applied (heuristic). ✗ = EOQ-blind gap.

8. The three problems

9. The improvement plan

Replace the EOQ averaging approximation with the exact Type-2 loss-function fill rate β = 1 − n₁(s)/Q across the Rust MEIO_v3 engine and the V3 Python inventory_engine reference. V1 Python is left as legacy.

1. New loss module — files/MEIO_v3/src/math.rs (or loss.rs)

Implement n₁(s) and its inverse solve_n1(target, Q, β) → s for every DistributionType (see the per-distribution table above).

2. Forward fill rate — files/MEIO_v3/src/distributions.rs

Rewrite fill_rate_for_rop (:225) to a single exact formula:

if eoq <= 0.0 {
    fr = dist.cdf(buffer)                              // Type-1 fallback (transfer routes)
} else {
    fr = (1.0 - n1(dist, buffer) / eoq).clamp(0.0, 1.0) // Type-2 exact
}

Delete the tested_eoq averaging loops in golden_formula_rop_to_fr (:300), normal_rop_to_fr (:344), poisson_rop_to_fr (:363), fitted_cdf_rop_to_fr (:381).

3. Inverse ROP — files/MEIO_v3/src/distributions.rs

• poisson_fr_to_rop (:402): s = solve_n1(…) instead of k·avg_size − Q/2.
• normal_fr_to_rop (:425): s = solve_n1(…) — now EOQ-aware. Key fix for high-volume Normal SKUs.
• New fitted_fr_to_rop(dist, target, eoq, …) for Gamma/LogNormal/Weibull/NegBin/Empirical so the fitted & V3-empirical paths also get the exact inverse.

4. Jumps & bounds — files/MEIO_v3/src/marginal.rs

• initial_jump (:146): derive first_buf from the exact inverse at sku_min_fill_rate (floored at lot_size).
• further_jump (:179): both branches use the exact inverse — the Normal branch stops ignoring EOQ.
• min_max_rop_qty (:39): add the EOQ term to the floor so the reduction is not capped: tgt_min_rop_qty = max(0, tgt_min_sl_qty + fcst_lt − eoq/2).

5. V3 Python reference — files/inventory_engine/rop.py

• reorder_point(samples, service_level, eoq=0.0): when eoq > 0, solve mean_excess(samples, s) = eoq·(1−service_level); else keep the percentile.
• fill_rate_for_buffer(samples, buffer, eoq=0.0): 1 − mean_excess/eoq when eoq > 0, else empirical CDF.
• Default eoq=0.0 preserves all existing call sites.

6. Tests & validation

• Property tests: β monotone in s; β increasing in Q; ROP non-increasing in Q; eoq=0 returns F(s) (Type-1 parity).
• Numerical parity vs scipy for Normal/Poisson/Gamma loss functions.
• Dev-pipeline A/B: confirm committed_buffer decreases as EOQ increases and group fill-rate targets still hold.

Full task breakdown: see the implementation plan at .kilo/plans/1782658808592-meio-eoq-rop-loss-function.md.

10. Risks & validation

• Weibull numerical integral adds cost per fill_rate_for_rop call; the greedy loop calls it many times per SKU. Profile and cache the quadrature nodes.
• Empirical inverse via mean-excess over sorted samples is O(log N) per evaluation after a one-time sort — acceptable.
• min_max_rop_qty floor change can raise the minimum for SKUs whose sl_qty + fcst_lt − eoq/2 was previously below the old floor — verify no SKU is forced above its target-driven ROP by the floor in the A/B.
• Transfer routes (eoq=0): buffers must be unchanged vs the old build (Type-1 fallback parity) — assert in the A/B.

11. Key files

Companion to the MEIO algorithm docs — see MEIO Theory, Safety Stock, and EOQ & Lot-Sizing for the surrounding theory.