optimization-ai999x: capability guide

Creator / engineer: Ibnul Jaif Farabi · Company: AI999X. Ask the package Who created you? or call optimization_ai999x.about() for the same answer.

Every capability optimization-ai999x supports, generated from its certified capability contracts. Every example below was executed when this guide was built. The structured call solve("<capability id>", ...) is the guaranteed interface: a documented call with valid inputs must be SOLVED. Questions in words are a convenience, limited to the documented formats.

Quick start

import optimization_ai999x

result = optimization_ai999x.solve('linear_program', sense='maximize', c='3, 5', A='1 0; 0 2; 3 2', b='4, 12, 18')
result.show()
# optimal_value = 36, x = [2.0, 6.0], solution_unique = yes, shadow_prices = [0.0, 1.5, 1.0]

By topic

Outcomes

Result fields

Common mistakes

• Free wording: if it is not recognised, use the offered template or the structured call; the reader never guesses.
• A coefficient that violates a stated condition (a = 0 in a quadratic): INVALID_INPUT says why.
• A text value where a number is expected: INVALID_INPUT; fractions as strings ("1/2") are accepted.
• A problem outside the procedure (a cubic for the quadratic solver): OUT_OF_SCOPE, never an approximation.

Procedures: algorithms with several outputs

Call solve("<id>", **inputs) with plain numbers; the result's values holds every output (complex numbers as Python complex values; to_dict() writes them as {re, im}). Each result is substituted back into its defining equation before it is returned.

Linear program (simplex method) — linear_program

Optimise a linear objective subject to linear constraints with non-negative variables: the optimal value, an optimal solution (stated as unique only when it is) and the shadow prices.

• Method: two-phase simplex in exact rational arithmetic with Bland's anti-cycling rule; optimality certified by a dual solution (primal feasibility, dual feasibility, equal objective values); uniqueness proved by an auxiliary LP over the optimal face
• Assumes: all variables >= 0; the LP is feasible and bounded (otherwise INVALID_INPUT says which); at most 12 variables and constraints
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('linear_program', sense='maximize', c='3, 5', A='1 0; 0 2; 3 2', b='4, 12, 18')
# -> optimal_value = 36, x = [2.0, 6.0], solution_unique = yes, shadow_prices = [0.0, 1.5, 1.0]   (SOLVED)

optimization_ai999x.solve('linear_program', sense='minimize', c=[2, 3], A=[[1, 1], [1, 3]], b=[4, 6], relations='>=, >=')
# -> optimal_value = 9, x = [3.0, 1.0], solution_unique = yes, shadow_prices = [1.5, 0.5]   (SOLVED)

optimization_ai999x.solve('linear_program', sense='maximize', c=[2, 4], A=[[1, 2], [1, 0]], b=[8, 5])
# -> optimal_value = 16, x_one_optimal = [5.0, 1.5], solution_unique = no, shadow_prices = [2.0, 0.0]   (SOLVED)

Questions in words (documented forms), as executed:

Two-variable linear program (graphical corner-point method) — lp_two_variable_graphical

Solve a linear program in two variables by evaluating the objective at every corner point of the feasible region.

• Method: intersect every pair of boundary lines (exact fractions), keep the feasible corners, evaluate the objective; unboundedness detected from the extreme rays of the recession cone
• Assumes: exactly two variables, both >= 0; a feasible region and a finite optimum
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('lp_two_variable_graphical', sense='maximize', c=[3, 5], A=[[1, 0], [0, 2], [3, 2]], b=[4, 12, 18])
# -> optimal_value = 36, optimal_corners = [[2.0, 6.0]], corner_points = [[0.0, 0.0], [0.0, 6.0], [2.0, 6.0], [4.0, 0.0], [4.0, 3.0]], x = 2, y = 6, solution_unique = yes   (SOLVED)

optimization_ai999x.solve('lp_two_variable_graphical', sense='minimize', c=[2, 3], A=[[1, 1], [1, 3]], b=[4, 6], relations='>=,>=')
# -> optimal_value = 9, optimal_corners = [[3.0, 1.0]], corner_points = [[0.0, 4.0], [3.0, 1.0], [6.0, 0.0]], x = 3, y = 1, solution_unique = yes   (SOLVED)

Questions in words (documented forms), as executed:

Integer linear program (branch and bound) — integer_program

Optimise a linear objective over non-negative INTEGER points satisfying linear constraints: the optimal value and one optimal integer solution.

• Method: LP-based branch and bound; every relaxation solved exactly (rational simplex), so pruning and integrality tests are exact
• Assumes: all variables integer and >= 0; a bounded LP relaxation; at most 4000 branch-and-bound nodes
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('integer_program', sense='maximize', c=[5, 4], A=[[6, 4], [1, 2]], b=[24, 6])
# -> optimal_value = 20, x_one_optimal = [4.0, 0.0], nodes = 5   (SOLVED)

optimization_ai999x.solve('integer_program', sense='minimize', c=[3, 2], A=[[1, 1]], b=[3.5], relations='>=')
# -> optimal_value = 8, x_one_optimal = [0.0, 4.0], nodes = 17   (SOLVED)

Questions in words (documented forms), as executed:

Shadow prices of a linear program — lp_shadow_prices

The shadow price (dual value) of each constraint: the change of the optimal value per unit increase of its right-hand side, when it is uniquely defined.

• Method: exact simplex; the dual solution $y = c_B$ B^{-1}; uniqueness of the dual proved by an auxiliary LP over the dual optimal face
• Assumes: all variables >= 0; a finite optimum; unique dual solution (otherwise INVALID_INPUT)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('lp_shadow_prices', sense='maximize', c=[3, 5], A=[[1, 0], [0, 2], [3, 2]], b=[4, 12, 18])
# -> optimal_value = 36, x = [2.0, 6.0], solution_unique = yes, shadow_prices = [0.0, 1.5, 1.0]   (SOLVED)

Questions in words (documented forms), as executed:

Optimum of a quadratic function — quadratic_optimum

The minimum or maximum of f(x) = a $x^{2} + b$ x + c: where it occurs and its value.

• Method: first-order condition f'$(x) = 2ax + b = 0$, exact fractions
• Assumes: $a \neq 0$; a minimum asked needs $a > 0$, a maximum $a < 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('quadratic_optimum', a=2, b=-8, c=3)
# -> x_opt = 2, f_opt = -5, type = minimum   (SOLVED)

optimization_ai999x.solve('quadratic_optimum', a=-1, b=6, c=1)
# -> x_opt = 3, f_opt = 10, type = maximum   (SOLVED)

Questions in words (documented forms), as executed:

Break-even quantity — break_even_point

The number of units at which revenue equals total cost (fixed plus variable), and the revenue there.

• Method: solve p $Q = F + v$ Q
• Assumes: fixed cost >= 0; price > variable cost
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('break_even_point', F_=5000, p=25, v=15)
# -> quantity = 500, revenue = 12500, contribution_margin = 10   (SOLVED)

optimization_ai999x.solve('break_even_point', F_=1200, p=7.5, v=4.5)
# -> quantity = 400, revenue = 3000, contribution_margin = 3   (SOLVED)

Questions in words (documented forms), as executed:

Profit-maximising output with linear demand — profit_max_linear_demand

With inverse demand $p = a - b$ q and cost $C = F + c$ q, the output, price and profit at the profit maximum.

• Method: marginal revenue equals marginal cost: $a - 2$ b $q = c$
• Assumes: $b > 0$; $a > c$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('profit_max_linear_demand', a=100, b=2, cv=20, F_=300)
# -> quantity = 20, price = 60, profit = 500   (SOLVED)

optimization_ai999x.solve('profit_max_linear_demand', a=50, b=0.5, cv=10)
# -> quantity = 40, price = 30, profit = 800   (SOLVED)

Questions in words (documented forms), as executed:

Revenue-maximising price with linear demand — revenue_max_linear_demand

With demand $q = \alpha - \beta$ p, the price that maximises revenue p q, the quantity sold and the revenue.

• Method: $dR/dp = \alpha - 2$ beta $p = 0$ (unit elasticity)
• Assumes: $\alpha > 0$; $\beta > 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('revenue_max_linear_demand', alpha=1000, beta=20)
# -> price = 25, quantity = 500, revenue = 12500   (SOLVED)

Questions in words (documented forms), as executed:

Largest rectangle for a given length of fencing — fence_max_area

The dimensions and maximum area of a rectangle enclosed by a fence of length L, on four sides or on three sides with a wall or river as the fourth.

• Method: area as a function of one side, derivative set to zero
• Assumes: $L > 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('fence_max_area', L=200)
# -> width = 50, length = 50, max_area = 2500   (SOLVED)

optimization_ai999x.solve('fence_max_area', L=200, wall=True)
# -> width = 50, length = 100, max_area = 5000   (SOLVED)

Questions in words (documented forms), as executed:

Open box of maximum volume from a rectangular sheet — open_box_max_volume

Squares of side x are cut from the corners of an L by W sheet and the sides folded up: the cut that maximises the volume, and that volume.

• Method: V(x) = x $(L - 2x)$$(W - 2x)$; V'$(x) = 0$, the root in (0, min(L, W)/2)
• Assumes: $L > 0$ and $W > 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('open_box_max_volume', L=12, W=12)
# -> cut = 2, max_volume = 128   (SOLVED)

optimization_ai999x.solve('open_box_max_volume', L=8, W=5)
# -> cut = 1, max_volume = 18   (SOLVED)

Questions in words (documented forms), as executed:

Closed cylinder of least surface area for a given volume — can_min_surface

The radius, height and surface area of the closed cylindrical can that holds a volume V with the least material.

• Method: A(r) = 2 pi $r^{2} + 2V/r$; A'$(r) = 0$
• Assumes: $V > 0$; closed top and bottom
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('can_min_surface', V=6.283185307179586)
# -> radius = 1, height = 2, min_area = 18.8496   (SOLVED)

Questions in words (documented forms), as executed:

Economic order quantity (EOQ) — eoq

The order size that minimises ordering plus holding cost for a steady demand, the minimum cost, the number of orders per period and the time between orders.

• Method: minimise D S / Q + H $Q / 2$ (at the optimum ordering cost equals holding cost)
• Assumes: D, S, $H > 0$; constant demand, instant replenishment, no shortages
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('eoq', D=1200, S=50, H=3)
# -> Q = 200, total_cost = 600, orders_per_period = 6, cycle_time = 0.166667   (SOLVED)

optimization_ai999x.solve('eoq', D=1000, S=10, H=0.5)
# -> Q = 200, total_cost = 100, orders_per_period = 5, cycle_time = 0.2   (SOLVED)

Questions in words (documented forms), as executed:

EOQ with planned backorders — eoq_planned_shortages

The order quantity and the planned maximum backorder that minimise ordering, holding and shortage cost when unmet demand is backordered.

• Method: minimise D S/Q + H $(Q-s)^{2}/(2Q) + B$ $s^{2}/(2Q)$ over Q and s
• Assumes: D, S, H, $B > 0$; backorders filled when the order arrives
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('eoq_planned_shortages', D=1200, S=50, H=3, B=6)
# -> Q = 244.949, max_backorder = 81.6497, max_inventory = 163.299, total_cost = 489.898   (SOLVED)

Questions in words (documented forms), as executed:

Economic production quantity (EPQ) — epq_production_lot

The production lot size that minimises setup plus holding cost when stock builds up gradually at a finite production rate.

• Method: minimise D S/Q + H Q $(1 - D/P)/2$
• Assumes: $P > D > 0$; S, $H > 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('epq_production_lot', D=1000, P=2000, S=100, H=4)
# -> Q = 316.228, max_inventory = 158.114, total_cost = 632.456, runs_per_period = 3.16228   (SOLVED)

Questions in words (documented forms), as executed:

Order quantity with quantity discounts (all-units) — eoq_quantity_discount

With all-units price breaks, the order quantity that minimises purchase + ordering + holding cost, the price paid and the minimum total cost per period.

• Method: EOQ per tier at its price, raised to the tier minimum when below it; tiers whose EOQ exceeds their upper limit are dominated; least total cost
• Assumes: D, S, $i > 0$; breaks increasing from 0; ties broken toward the lower-quantity tier
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('eoq_quantity_discount', D=5000, S=49, i_rate=0.2, breaks='0, 1000, 2000', prices='5, 4.8, 4.75')
# -> order_quantity = 1000, total_cost = 24725, unit_price = 4.8   (SOLVED)

Questions in words (documented forms), as executed:

Reorder point with safety stock — reorder_point

The stock level at which to reorder so that demand during the lead time is covered with a given cycle service level, for normally distributed demand per period.

• Method: $z = Phi$^{-1}(SL); ROP = d L + z sigma sqrt(L)
• Assumes: $0.5 \leq SL < 1$; independent normal demand per period
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('reorder_point', d=40, L=9, sigma=8, SL=0.95)
# -> reorder_point = 399.476, safety_stock = 39.4765, z = 1.64485, lead_time_demand = 360   (SOLVED)

optimization_ai999x.solve('reorder_point', d=100, L=4, sigma=0, SL=0.9)
# -> reorder_point = 400, safety_stock = 0, z = 1.28155, lead_time_demand = 400   (SOLVED)

Questions in words (documented forms), as executed:

Periodic-review order-up-to level — order_up_to_level

The target inventory position S of a periodic-review system that covers demand over the review period plus the lead time with a given cycle service level.

• Method: $S = d$ (R + L) + z sigma sqrt(R + L)
• Assumes: $0.5 \leq SL < 1$; independent normal demand per period
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('order_up_to_level', d=20, sigma=4, R=7, L=2, SL=0.95)
# -> order_up_to_level = 199.738, safety_stock = 19.7382, z = 1.64485   (SOLVED)

Questions in words (documented forms), as executed:

Newsvendor order quantity (normal demand) — newsvendor_normal

The single-period order quantity that maximises expected profit for normally distributed demand: the critical ratio, the optimal quantity and the expected profit.

• Method: critical fractile: F(Q) = (p - c)/(p - s); expected profit from the standard normal loss function
• Assumes: salvage < cost < price; $\sigma > 0$; continuous normal demand
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('newsvendor_normal', p=2, c=0.5, s=0.2, mu=100, sigma=20)
# -> critical_ratio = 0.833333, Q = 119.348, expected_profit = 141.005, expected_shortage = 1.77228   (SOLVED)

optimization_ai999x.solve('newsvendor_normal', p=10, c=5, mu=500, sigma=50)
# -> critical_ratio = 0.5, Q = 500, expected_profit = 2300.53, expected_shortage = 19.9471   (SOLVED)

Questions in words (documented forms), as executed:

Newsvendor order quantity (uniform demand) — newsvendor_uniform

The single-period order quantity that maximises expected profit when demand is uniform on [a, b].

• Method: critical fractile of the uniform distribution
• Assumes: salvage < cost < price; $0 \leq a < b$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('newsvendor_uniform', p=10, c=4, lo=100, hi=300)
# -> critical_ratio = 0.6, Q = 220, expected_profit = 960   (SOLVED)

Questions in words (documented forms), as executed:

Newsvendor order quantity (discrete demand) — newsvendor_discrete

For demand taking listed values with given probabilities, the order quantity that maximises expected profit (the smallest demand value whose cumulative probability reaches the critical ratio) and that profit.

• Method: cumulative distribution against the critical ratio, in exact fractions
• Assumes: salvage < cost < price; probabilities sum to 1; order quantities restricted to the listed demand values
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('newsvendor_discrete', p=10, c=4, demands='10, 20, 30, 40', probs='0.1, 0.3, 0.4, 0.2')
# -> critical_ratio = 0.6, Q = 30, expected_profit = 130   (SOLVED)

Questions in words (documented forms), as executed:

Littlewood's rule (two-fare protection level) — littlewood_protection

How many seats (units) to protect for full-fare demand when a discount fare is also sold: the protection level and, with a capacity, the booking limit for the discount class.

• Method: protect y with P(D1 > y) = p2/p1
• Assumes: $0 < p_{2} < p_{1}$; normally distributed full-fare demand; continuous approximation (no rounding)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('littlewood_protection', p1=400, p2=150, mu=60, sigma=20)
# -> protection_level = 66.3728, z = 0.318639   (SOLVED)

optimization_ai999x.solve('littlewood_protection', p1=200, p2=100, mu=50, sigma=10, capacity=120)
# -> protection_level = 50, z = 0, booking_limit = 70   (SOLVED)

Questions in words (documented forms), as executed:

M/M/1 queue — mm1_queue

Steady-state measures of a single-server queue with Poisson arrivals and exponential service: utilisation, mean numbers in system and in queue, mean times in system and in queue, probability of an empty system.

• Method: geometric stationary distribution; Little's law
• Assumes: $\lambda < mu$ (stable); Poisson arrivals, exponential service, one server, unlimited capacity
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mm1_queue', lam=8, mu=10)
# -> rho = 0.8, L = 4, Lq = 3.2, W = 0.5, Wq = 0.4, P0 = 0.2   (SOLVED)

optimization_ai999x.solve('mm1_queue', lam=2, mu=3)
# -> rho = 0.666667, L = 2, Lq = 1.33333, W = 1, Wq = 0.666667, P0 = 0.333333   (SOLVED)

Questions in words (documented forms), as executed:

M/M/c queue (Erlang C) — mmc_queue

Steady-state measures of a queue with c parallel identical servers, Poisson arrivals and exponential service: probability of waiting (Erlang C), mean queue length and waiting times.

• Method: Erlang B by its stable recursion, then Erlang C = B / (1 - rho $(1 - B)$); Little's law
• Assumes: $\lambda < c$ mu (stable); unlimited queue capacity
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mmc_queue', lam=2, mu=3, c=2)
# -> rho = 0.333333, P_wait = 0.166667, Lq = 0.0833333, Wq = 0.0416667, W = 0.375, L = 0.75, P0 = 0.5   (SOLVED)

optimization_ai999x.solve('mmc_queue', lam=2, mu=3, c=1)
# -> rho = 0.666667, P_wait = 0.666667, Lq = 1.33333, Wq = 0.666667, W = 1, L = 2, P0 = 0.333333   (SOLVED)

Questions in words (documented forms), as executed:

M/M/c/K queue (finite capacity) — mmck_finite_queue

Steady-state measures of a queue with c servers and room for at most K customers in the system (arrivals finding it full are lost): blocking probability, effective arrival rate, mean numbers and times.

• Method: truncated birth-death distribution computed in log space; Little's law with the effective arrival rate
• Assumes: $1 \leq c \leq K$; any utilisation (finite capacity is always stable)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mmck_finite_queue', lam=2, mu=2, c=1, K=3)
# -> P_block = 0.25, lam_eff = 1.5, L = 1.5, Lq = 0.75, W = 1, Wq = 0.5, P0 = 0.25   (SOLVED)

optimization_ai999x.solve('mmck_finite_queue', lam=3, mu=1, c=2, K=2)
# -> P_block = 0.529412, lam_eff = 1.41176, L = 1.41176, Lq = 0, W = 1, Wq = 0, P0 = 0.117647   (SOLVED)

Questions in words (documented forms), as executed:

Erlang B blocking probability (M/M/c/c loss system) — erlang_b

The probability that a call (customer) is blocked in a loss system with c servers and no waiting room, for an offered traffic of A erlangs, with the carried and lost traffic.

• Method: stable recursion B(k) = A B($k-1) / (k + A$ B(k-1))
• Assumes: blocked customers are lost (no waiting); $A > 0$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('erlang_b', A=3, c=5)
# -> blocking_probability = 0.110054, carried_traffic = 2.66984, lost_traffic = 0.330163   (SOLVED)

optimization_ai999x.solve('erlang_b', A=1, c=1)
# -> blocking_probability = 0.5, carried_traffic = 0.5, lost_traffic = 0.5   (SOLVED)

Questions in words (documented forms), as executed:

Machine-repair (finite-source) queue — machine_repair_queue

N machines each fail at rate lambda while running and c repairers fix them at rate mu each: mean number of machines down and waiting, failure rate, downtime and the mean number working.

• Method: finite birth-death distribution (birth (N - n) lambda, death min(n, c) mu) in log space; Little's law
• Assumes: $1 \leq c \leq N$; exponential failure and repair times
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('machine_repair_queue', N=2, lam=1, mu=1, c=1)
# -> L = 1.2, Lq = 0.4, lam_eff = 0.8, W = 1.5, Wq = 0.5, P0 = 0.2, working = 0.8   (SOLVED)

optimization_ai999x.solve('machine_repair_queue', N=5, lam=0.2, mu=1, c=1)
# -> L = 1.42434, Lq = 0.709207, lam_eff = 0.715132, W = 1.99171, Wq = 0.991714, P0 = 0.284868, working = 3.57566   (SOLVED)

Questions in words (documented forms), as executed:

M/G/1 queue (Pollaczek-Khinchine formula) — mg1_pollaczek_khinchine

Mean queue length and waiting times of a single-server queue with Poisson arrivals and a GENERAL service time distribution given by its mean and standard deviation (M/D/1 when the standard deviation is 0).

• Method: Pollaczek-Khinchine mean-value formula; Little's law
• Assumes: lambda E[S] < 1; Poisson arrivals, one server, first come first served
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mg1_pollaczek_khinchine', lam=0.5, ES=1, sd=1)
# -> rho = 0.5, Lq = 0.5, L = 1, Wq = 1, W = 2   (SOLVED)

optimization_ai999x.solve('mg1_pollaczek_khinchine', lam=0.5, ES=1, sd=0)
# -> rho = 0.5, Lq = 0.25, L = 0.75, Wq = 0.5, W = 1.5   (SOLVED)

Questions in words (documented forms), as executed:

Minimum number of servers for a service target (Erlang C) — mmc_staffing

The smallest number of servers c of an M/M/c queue for which the probability of waiting, or the mean waiting time, meets a target.

• Method: increase c from floor(lambda/mu) + 1 until the Erlang C measure meets the target
• Assumes: Poisson arrivals, exponential service; target > 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mmc_staffing', lam=24, mu=10, target=0.2)
# -> servers = 5, P_wait = 0.113504, Wq = 0.00436553, utilisation = 0.48   (SOLVED)

Questions in words (documented forms), as executed:

Shortest processing time rule (minimum mean flow time) — spt_mean_flow_time

The job order that minimises the mean flow (completion) time on one machine, and that minimum.

• Method: sort by processing time (SPT); optimal by the exchange argument
• Assumes: all jobs available at time 0; processing times >= 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('spt_mean_flow_time', p='4, 2, 6, 3')
# -> sequence = [2, 4, 1, 3], total_completion_time = 31, mean_flow_time = 7.75   (SOLVED)

Questions in words (documented forms), as executed:

Weighted shortest processing time (Smith's rule) — wspt_weighted_completion

The job order that minimises the total weighted completion time on one machine, and that minimum.

• Method: sort by p_j / w_j (Smith's ratio rule)
• Assumes: weights > 0; all jobs available at time 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('wspt_weighted_completion', p=[3, 1, 4], w=[1, 2, 3])
# -> sequence = [2, 3, 1], weighted_completion_time = 25   (SOLVED)

Questions in words (documented forms), as executed:

Earliest due date rule (minimum maximum lateness) — edd_max_lateness

The job order that minimises the maximum lateness (and so the maximum tardiness) on one machine.

• Method: sort by due date (Jackson's rule)
• Assumes: all jobs available at time 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('edd_max_lateness', p=[2, 4, 1, 3], d=[5, 6, 3, 9])
# -> sequence = [3, 1, 2, 4], max_lateness = 1, max_tardiness = 1, tardy_jobs_in_sequence = 2   (SOLVED)

Questions in words (documented forms), as executed:

Moore-Hodgson algorithm (minimum number of tardy jobs) — moore_hodgson_tardy_jobs

The smallest possible number of late jobs on one machine, with an order of the on-time jobs and the set of late jobs.

• Method: EDD order; whenever a job is late remove the longest job scheduled so far
• Assumes: all jobs available at time 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('moore_hodgson_tardy_jobs', p=[4, 3, 2, 5, 6], d=[5, 6, 8, 12, 15])
# -> min_tardy_jobs = 2, on_time_sequence = [2, 3, 4], tardy_jobs = [1, 5]   (SOLVED)

Questions in words (documented forms), as executed:

Johnson's rule (two-machine flow shop) — johnson_two_machine

The job order that minimises the makespan when every job is processed first on machine 1 and then on machine 2.

• Method: Johnson's rule
• Assumes: same job order on both machines; all jobs available at time 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('johnson_two_machine', a=[5, 2, 6, 7], b=[3, 4, 8, 2])
# -> makespan = 22, sequence = [2, 3, 1, 4]   (SOLVED)

Questions in words (documented forms), as executed:

Minimum makespan on identical parallel machines — parallel_machine_makespan

Assign jobs to m identical machines so that the last machine finishes as early as possible (P||Cmax), exactly.

• Method: exact depth-first branch and bound (longest job first, symmetric machines skipped), started from the LPT schedule
• Assumes: at most 12 jobs and 6 machines; jobs are not split
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('parallel_machine_makespan', p=[7, 5, 4, 3, 3, 2], m=2)
# -> makespan = 12, machine_of_job = [1, 2, 2, 1, 2, 1], lower_bound = 12   (SOLVED)

optimization_ai999x.solve('parallel_machine_makespan', p=[3, 3, 2, 2, 2], m=2)
# -> makespan = 6, machine_of_job = [1, 1, 2, 2, 2], lower_bound = 6   (SOLVED)

Questions in words (documented forms), as executed:

Critical path method (project duration and slack) — critical_path_method

For activities with durations and precedences, the minimum project duration, the critical activities and each activity's earliest start, latest start and slack (total float).

• Method: forward pass (earliest starts) and backward pass (latest finishes) on the activity-on-node network, exact fractions
• Assumes: finish-to-start precedences without cycles; deterministic durations
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('critical_path_method', durations='3, 4, 2, 5', precedences='A-B, A-C, B-D, C-D')
# -> project_duration = 12, critical_activities = ['A', 'B', 'D'], slack = [0.0, 0.0, 2.0, 0.0], earliest_start = [0.0, 3.0, 3.0, 7.0], latest_start = [0.0, 3.0, 5.0, 7.0]   (SOLVED)

Questions in words (documented forms), as executed:

PERT project duration and completion probability — pert_project

With optimistic, most likely and pessimistic times per activity, the expected project duration, its variance along the critical path and the probability of finishing by a deadline (normal approximation).

• Method: beta-PERT expected times, longest path in exact fractions with a count of longest paths, variance summed along it
• Assumes: a unique critical path (otherwise INVALID_INPUT); independent activity times; normal approximation
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('pert_project', times='2 4 6; 3 5 13; 1 2 3', precedences='A-B, A-C', deadline=10)
# -> expected_duration = 10, variance = 3.22222, std_dev = 1.79505, critical_path = ['A', 'B'], expected_times = [4.0, 6.0, 2.0], probability = 0.5   (SOLVED)

Questions in words (documented forms), as executed:

Shortest path (Dijkstra's algorithm) — shortest_path

The length of the shortest route between two nodes of a graph with non-negative edge weights, and the route itself (stated as the route only when it is the only shortest one).

• Method: Dijkstra's algorithm in exact arithmetic; shortest paths counted on the tight-edge subgraph
• Assumes: weights >= 0; a path from source to target exists; parallel edges: the lightest counts
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('shortest_path', edges='A-B 4, A-C 2, B-C 1, B-D 5, C-D 8', source='A', target='D', directed=False)
# -> distance = 8, path = ['A', 'C', 'B', 'D'], path_unique = yes   (SOLVED)

optimization_ai999x.solve('shortest_path', edges='A-B 1, B-C 1, A-C 2', source='A', target='C', directed=True)
# -> distance = 2, path_example = ['A', 'C'], path_unique = no   (SOLVED)

Questions in words (documented forms), as executed:

Shortest path with negative weights (Bellman-Ford) — bellman_ford_shortest_path

Shortest distance in a directed graph whose edge weights may be negative, with all distances from the source; a negative cycle reachable from the source is reported instead of a number.

• Method: Bellman-Ford relaxation in exact arithmetic; distances certified as feasible, tight potentials
• Assumes: directed graph; no negative cycle reachable from the source (otherwise INVALID_INPUT)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('bellman_ford_shortest_path', edges=[['S', 'A', 4], ['S', 'B', 5], ['A', 'T', 3], ['B', 'A', -3], ['B', 'T', 6]], source='S', target='T')
# -> distance = 5, distances_from_source = {'S': 0.0, 'A': 2.0, 'B': 5.0, 'T': 5.0}   (SOLVED)

Questions in words (documented forms), as executed:

All-pairs shortest distances (Floyd-Warshall) — all_pairs_shortest_paths

The table of shortest distances between every pair of nodes, and the graph's diameter.

• Method: Floyd-Warshall in exact arithmetic
• Assumes: every node reaches every other; no negative cycle; at most 40 nodes
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('all_pairs_shortest_paths', edges='A-B 3, B-C 4, A-C 9, C-D 2', directed=False)
# -> nodes = ['A', 'B', 'C', 'D'], distances = [[0.0, 3.0, 7.0, 9.0], [3.0, 0.0, 4.0, 6.0], [7.0, 4.0, 0.0, 2.0], [9.0, 6.0, 2.0, 0.0]], diameter = 9   (SOLVED)

Questions in words (documented forms), as executed:

Minimum spanning tree (Kruskal's algorithm) — minimum_spanning_tree

The least total weight of edges connecting all nodes of an undirected graph, and the tree (stated as THE tree only when the minimum spanning tree is unique).

• Method: Kruskal (edges by weight, union-find); uniqueness by the cycle property; total re-checked by Prim
• Assumes: connected undirected graph
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('minimum_spanning_tree', edges='A-B 4, A-C 1, B-C 2, B-D 5, C-D 8')
# -> total_weight = 8, tree_unique = yes, tree_edges = ['A-C', 'B-C', 'B-D']   (SOLVED)

Questions in words (documented forms), as executed:

Maximum flow and minimum cut (Edmonds-Karp) — max_flow

The largest flow that can be sent from a source to a sink through a network of capacitated arcs, a flow achieving it and the minimum cut that proves it optimal.

• Method: Edmonds-Karp (breadth-first augmenting paths) in exact arithmetic; certified by the max-flow min-cut theorem
• Assumes: directed arcs; capacities >= 0
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('max_flow', edges='S-A 10, S-B 5, A-B 15, A-T 5, B-T 10', source='S', target='T')
# -> max_flow = 15, min_cut_source_side = ['S'], edge_flows = [10.0, 5.0, 5.0, 5.0, 10.0]   (SOLVED)

Questions in words (documented forms), as executed:

Transportation problem (minimum shipping cost) — transportation_problem

Ship from sources with given supplies to destinations with given demands at least total cost: the minimum cost and a shipping plan (stated as THE plan only when it is unique).

• Method: the transportation LP solved exactly (rational simplex), certified by its dual $(u_i + v_j \leq c_ij)$
• Assumes: total supply >= total demand (surplus stays at the sources at no cost); at most 60 routes
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('transportation_problem', supply=[20, 30], demand=[10, 25, 15], cost=[[2, 3, 1], [5, 4, 8]])
# -> min_cost = 150, shipments = [[5.0, 0.0, 15.0], [5.0, 25.0, 0.0]], plan_unique = yes, dual = [-3.0, 0.0, 5.0, 4.0, 4.0]   (SOLVED)

Questions in words (documented forms), as executed:

Minimum-cost flow (transshipment) — min_cost_flow

Send flow from supply nodes to demand nodes through capacitated arcs at least total cost (transshipment allowed): the minimum cost and a flow achieving it.

• Method: the min-cost-flow LP solved exactly (rational simplex) and certified by its dual
• Assumes: supplies sum to 0; a feasible flow exists; at most 60 arcs
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('min_cost_flow', capacity=[[0, 10, 5], [0, 0, 10], [0, 0, 0]], cost=[[0, 1, 4], [0, 0, 2], [0, 0, 0]], supply=[8, 0, -8])
# -> min_cost = 24, flows = [[0.0, 8.0, 0.0], [0.0, 0.0, 8.0], [0.0, 0.0, 0.0]], flow_unique = yes, dual = [3.0, 2.0, 0.0, 0.0, 0.0, 0.0]   (SOLVED)

Questions in words (documented forms), as executed:

Assignment problem (Hungarian method), minimum total cost — assignment_min_cost

Assign each row (worker) to a different column (task) so that the total cost is as small as possible: the optimum and an optimal assignment (stated as THE assignment only when unique).

• Method: Hungarian method (shortest augmenting paths with potentials) in exact arithmetic; uniqueness by forbidding each chosen cell
• Assumes: square matrix, at most 12 x 12 (pad with zeros for unbalanced problems)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('assignment_min_cost', C='9 2 7; 6 4 3; 5 8 1')
# -> min_cost = 9, assignment = [2, 1, 3], assignment_unique = yes, dual_u = [4.0, 6.0, 4.0], dual_v = [0.0, -2.0, -3.0]   (SOLVED)

Questions in words (documented forms), as executed:

Assignment problem (Hungarian method), maximum total value — assignment_max_profit

Assign each row (worker) to a different column (task) so that the total value is as large as possible: the optimum and an optimal assignment (stated as THE assignment only when unique).

• Method: Hungarian method (shortest augmenting paths with potentials) in exact arithmetic; uniqueness by forbidding each chosen cell
• Assumes: square matrix, at most 12 x 12 (pad with zeros for unbalanced problems)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('assignment_max_profit', C='9 2 7; 6 4 3; 5 8 1')
# -> max_value = 21, assignment = [3, 1, 2], assignment_unique = yes, dual_u = [7.0, 4.0, 8.0], dual_v = [2.0, 0.0, 0.0]   (SOLVED)

Questions in words (documented forms), as executed:

Maximum bipartite matching — bipartite_matching

The largest number of pairs that can be formed between two groups (workers and jobs, students and projects) using only allowed pairs, with one maximum matching and a vertex cover proving it maximum.

• Method: augmenting paths (Kuhn); minimum vertex cover from alternating reachability (Konig)
• Assumes: bipartite: the first node of each pair is on the left, the second on the right
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('bipartite_matching', edges='W1-J1, W1-J2, W2-J1, W3-J2, W3-J3')
# -> max_matching = 3, matching_example = ['W1-J2', 'W2-J1', 'W3-J3'], vertex_cover = ['W1', 'W2', 'W3']   (SOLVED)

optimization_ai999x.solve('bipartite_matching', edges='A-X, B-X, C-X')
# -> max_matching = 1, matching_example = ['A-X'], vertex_cover = ['X']   (SOLVED)

Questions in words (documented forms), as executed:

Maximum-weight matching (general graph) — max_weight_matching

Pair up nodes of a graph (each node at most once) so that the total weight of the chosen edges is as large as possible: the maximum weight and one optimal matching.

• Method: exact dynamic programming over node subsets
• Assumes: at most 16 nodes; edges of weight <= 0 are never worth choosing
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('max_weight_matching', edges='A-B 6, B-C 5, C-D 6, A-D 2, A-C 4')
# -> max_weight = 12, matching_example = ['A-B', 'C-D']   (SOLVED)

Questions in words (documented forms), as executed:

Travelling salesman tour (exact, Held-Karp) — traveling_salesman

The shortest round trip visiting every city exactly once and returning to the start, for a distance matrix (symmetric or not): the minimum tour length and one optimal tour.

• Method: Held-Karp dynamic programming over city subsets, exact arithmetic
• Assumes: 2 to 11 cities
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('traveling_salesman', D=[[0, 10, 15, 20], [10, 0, 35, 25], [15, 35, 0, 30], [20, 25, 30, 0]])
# -> min_tour_length = 80, tour_example = [1, 3, 4, 2, 1]   (SOLVED)

Questions in words (documented forms), as executed:

0/1 knapsack problem — knapsack_01

Choose items (each at most once) to maximise total value without exceeding the capacity: the maximum value, one optimal choice and its weight.

• Method: exact dynamic programming over (weight, value) states with Pareto pruning, rational arithmetic
• Assumes: values, weights, capacity >= 0; at most 40 items
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('knapsack_01', values='60, 100, 120', weights='10, 20, 30', capacity=50)
# -> max_value = 220, items_example = [2, 3], total_weight = 50   (SOLVED)

Questions in words (documented forms), as executed:

Unbounded knapsack problem — knapsack_unbounded

Choose any number of copies of each item type to maximise total value within the capacity.

• Method: dynamic programming over capacities
• Assumes: positive whole-number weights; capacity a whole number <= 100000
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('knapsack_unbounded', values=[10, 40, 50, 70], weights=[1, 3, 4, 5], capacity=8)
# -> max_value = 110, copies_example = [0.0, 1.0, 0.0, 1.0]   (SOLVED)

Questions in words (documented forms), as executed:

Minimum-cost set cover — set_cover

Choose sets (each with a cost) that together contain every element, at least total cost.

• Method: exhaustive enumeration of set combinations (exact)
• Assumes: at most 18 sets; every element in some set
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('set_cover', sets=[[1, 1, 0, 0], [0, 1, 1, 0], [0, 0, 1, 1], [1, 0, 0, 1]], costs=[3, 2, 3, 2])
# -> min_cost = 4, sets_example = [2, 4]   (SOLVED)

Questions in words (documented forms), as executed:

Uncapacitated facility location — facility_location

Choose which facilities to open (each with a fixed cost) and serve every customer from its cheapest open facility, minimising fixed plus service cost.

• Method: exact enumeration of the facilities to open; each customer assigned to its cheapest open facility
• Assumes: at most 15 facilities; unlimited capacity
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('facility_location', fixed=[10, 15, 12], cost=[[3, 8, 6, 9], [7, 2, 4, 3], [5, 6, 2, 8]])
# -> min_cost = 31, open_example = [2]   (SOLVED)

Questions in words (documented forms), as executed:

Bin packing (minimum number of bins) — bin_packing

Pack items of given sizes into the fewest bins of a given capacity: the minimum number and one packing.

• Method: exact depth-first search (largest item first, symmetric bins skipped) with the volume bound
• Assumes: at most 14 items; every item fits in a bin
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('bin_packing', sizes=[4, 8, 1, 4, 2, 1], capacity=10)
# -> min_bins = 2, bin_of_item = [2, 1, 2, 2, 1, 2], lower_bound = 2   (SOLVED)

optimization_ai999x.solve('bin_packing', sizes=[6, 6, 6], capacity=10)
# -> min_bins = 3, bin_of_item = [1, 2, 3], lower_bound = 2   (SOLVED)

Questions in words (documented forms), as executed:

Two-person zero-sum game (value and optimal mixed strategies) — zero_sum_game

The value of a matrix game (row player maximises the payoff in the matrix, column player minimises it) and one optimal mixed strategy for each player.

• Method: the game as a pair of dual linear programs on the shifted matrix, solved exactly (rational simplex); the pair of strategies is the certificate (each guarantees the value)
• Assumes: at most 12 strategies per player
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('zero_sum_game', A=[[3, -1, 2], [-2, 4, 1], [0, 1, -1]])
# -> value = 1, row_strategy_example = [0.6, 0.4, 0.0], col_strategy_example = [0.5, 0.5, 0.0]   (SOLVED)

optimization_ai999x.solve('zero_sum_game', A=[[1, -1], [-1, 1]])
# -> value = 0, row_strategy_example = [0.5, 0.5], col_strategy_example = [0.5, 0.5]   (SOLVED)

Questions in words (documented forms), as executed:

2 x 2 zero-sum game (saddle point or mixed-strategy formula) — zero_sum_2x2

The value of a 2 x 2 matrix game: the saddle-point value when one exists, otherwise the mixed-strategy solution (probability of each player's first strategy, unique in that case).

• Method: maximin = minimax gives a saddle point; otherwise the indifference formulas in exact arithmetic
• Assumes: a 2 x 2 matrix
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('zero_sum_2x2', A=[[3, -1], [-2, 4]])
# -> value = 1, p_row1 = 0.6, q_col1 = 0.5, saddle_point = no   (SOLVED)

optimization_ai999x.solve('zero_sum_2x2', A=[[4, 2], [1, 3]])
# -> value = 2.5, p_row1 = 0.5, q_col1 = 0.25, saddle_point = no   (SOLVED)

optimization_ai999x.solve('zero_sum_2x2', A=[[5, 3], [4, 1]])
# -> value = 3, saddle_point = yes   (SOLVED)

Questions in words (documented forms), as executed:

Pure-strategy Nash equilibria of a bimatrix game — pure_nash_equilibria

Every pure-strategy Nash equilibrium (a cell where each player's strategy is a best reply to the other's) of a two-player game given by the two players' payoff matrices.

• Method: mutual best replies, cell by cell, in exact arithmetic
• Assumes: at most 8 strategies per player; weak best replies count (ties are equilibria)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('pure_nash_equilibria', A=[[3, 0], [5, 1]], B=[[3, 5], [0, 1]])
# -> count = 1, equilibria = [[2.0, 2.0]]   (SOLVED)

optimization_ai999x.solve('pure_nash_equilibria', A=[[2, 0], [0, 1]], B=[[1, 0], [0, 2]])
# -> count = 2, equilibria = [[1.0, 1.0], [2.0, 2.0]]   (SOLVED)

Questions in words (documented forms), as executed:

Mixed-strategy Nash equilibrium of a 2 x 2 game — mixed_nash_2x2

The equilibrium of a 2 x 2 two-player game without a pure equilibrium: each player's probability of the first strategy (chosen to make the OTHER player indifferent) and the expected payoffs.

• Method: indifference conditions in exact arithmetic: p from the column player's payoffs, q from the row player's
• Assumes: 2 x 2 matrices; no pure-strategy equilibrium (then the mixed one is unique)
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)

optimization_ai999x.solve('mixed_nash_2x2', A=[[3, -1], [-2, 1]], B=[[-1, 2], [1, -1]])
# -> p_row1 = 0.4, q_col1 = 0.285714, row_payoff = 0.142857, col_payoff = 0.2   (SOLVED)

Questions in words (documented forms), as executed:

TOPSIS ranking (closeness to the ideal solution) — topsis

Rank alternatives scored on several criteria by their relative closeness to the ideal and distance from the anti-ideal solution (vector normalisation, weighted Euclidean distances).

• Method: vector normalisation $r = x$ / ||x_col||, weighted; ideal = best per criterion, anti-ideal = worst; $C = D$- / (D+ + D-)
• Assumes: values > 0; weights > 0 (normalised to sum 1); types 1 $or -1$
• Evidence: certified procedure (gates: conditions, control, examples, fast_enough, questions, reference, sensitivity, templates)