@ohtaman/washi 0.4.0 → 0.6.0

package/docs/examples/knapsack.md

@@ -0,0 +1,60 @@
+# 0-1 Knapsack Problem (Binary MIP)
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| 0-1 Binary MIP | HiGHS (default) | `m.binary()`, `m.constraint()`, `expr`, `maximize`, `dot` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=knapsack">Open in Playground</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/02-knapsack-problem.ts">Source Code</a></li></ul> |
+
+The 0-1 Knapsack problem is an essential combinatorial optimization problem: given a set of items, each with a weight and a value, determine which items to include in a collection so that the total weight does not exceed a given limit and the total value is maximized.
+
+## Mathematical Formulation
+
+Let $x_i \in \{0, 1\}$ be binary decision variables indicating whether item $i$ is selected ($x_i = 1$) or not ($x_i = 0$):
+
+$$\begin{aligned}
+\text{Maximize} \quad & \sum_{i} v_i x_i & (\text{Total Value}) \\
+\text{Subject to} \quad & \sum_{i} w_i x_i \le W & (\text{Weight Capacity}) \\
+& x_i \in \{0, 1\} & (\text{Binary Decisions})
+\end{aligned}$$
+
+## Implementation in WaSHI
+
+<CodeRunner preset="knapsack">
+
+```typescript
+import { Model, maximize, dot, expr } from "@ohtaman/washi";
+
+async function solveKnapsack() {
+  const m = new Model("Knapsack");
+
+  const items = [
+    { name: "Laptop",   weight: 3, value: 50 },
+    { name: "Camera",   weight: 2, value: 40 },
+    { name: "Drone",    weight: 4, value: 65 },
+    { name: "FirstAid", weight: 1, value: 15 },
+    { name: "Tent",     weight: 5, value: 70 },
+  ];
+  const maxCapacity = 7; // kg
+
+  // Create binary variables: x[name] (0 or 1)
+  const x = m.binary(items.map((it) => it.name));
+
+  const values = Object.fromEntries(items.map((it) => [it.name, it.value]));
+  const weights = Object.fromEntries(items.map((it) => [it.name, it.weight]));
+
+  // Maximize total value via dot product
+  m.objective(maximize(dot(values, x)));
+
+  // Weight capacity constraint using natural expr and constraint() syntax
+  m.constraint(expr`${dot(weights, x)} <= ${maxCapacity}`, "capacity_limit");
+
+  const status = await m.solve();
+
+  console.log(`Status: ${status}`);
+  console.log(`Max Total Value: $${m.objectiveValue}`);
+  console.log("Selected Items:", m.getValues(x));
+}
+
+solveKnapsack();
+```
+
+</CodeRunner>

package/docs/examples/portfolio-qp.md

@@ -0,0 +1,83 @@
+# Portfolio Optimization (QP)
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| Convex Quadratic Programming (QP) | HiGHS (default) | `m.continuous()`, `m.constraint()`, `expr`, `minimize`, `dot`, `QuadExpr` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=portfolio_qp">Open in Playground</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/03-portfolio-qp.ts">Source Code</a></li></ul> |
+
+The Markowitz mean-variance portfolio optimization problem is the foundation of modern quantitative finance: allocate capital across risky assets to minimize overall portfolio variance (risk) subject to achieving a minimum required expected return.
+
+<PortfolioQpDemo />
+
+## Mathematical Formulation
+
+Let $w_i \ge 0$ denote the allocation weight for asset $i$:
+
+$$\begin{aligned}
+\text{Minimize} \quad & \mathbf{w}^T \boldsymbol{\Sigma} \mathbf{w} & (\text{Portfolio Variance}) \\
+\text{Subject to} \quad & \sum_{i=1}^n w_i = 1 & (\text{Full Capital Budget}) \\
+& \sum_{i=1}^n r_i w_i \ge R_{\text{target}} & (\text{Minimum Target Return}) \\
+& 0 \le w_i \le 1 & (\text{Long-Only Weights})
+\end{aligned}$$
+
+where $\boldsymbol{\Sigma}$ is the positive semi-definite asset return covariance matrix.
+
+## Implementation in WaSHI
+
+<CodeRunner preset="portfolio_qp">
+
+```typescript
+import { Model, QuadExpr, sum, dot, minimize, expr } from "@ohtaman/washi";
+
+async function solvePortfolio() {
+  const m = new Model("PortfolioQP");
+
+  const assets = ["Tech", "Bonds", "GlobalEq", "RealEstate", "Gold"];
+  const expectedReturns = [0.12, 0.04, 0.09, 0.07, 0.05];
+  const targetReturn = 0.085; // 8.5% minimum expected return
+
+  // 5x5 Covariance Matrix
+  const cov = [
+    [0.040, 0.002, 0.025, 0.015, 0.005],
+    [0.002, 0.005, 0.003, 0.002, 0.001],
+    [0.025, 0.003, 0.030, 0.018, 0.008],
+    [0.015, 0.002, 0.018, 0.025, 0.004],
+    [0.005, 0.001, 0.008, 0.004, 0.020],
+  ];
+
+  // Allocation weights w_i in [0, 1]
+  const w = m.continuous(assets, { lb: 0, ub: 1 });
+
+  // 1. Budget constraint: sum(w_i) == 1.0 (100%)
+  m.constraint(expr`${sum(assets, (a) => w[a])} == 1.0`, "budget_limit");
+
+  // 2. Expected return constraint: sum(r_i * w_i) >= 8.5%
+  const retMap = Object.fromEntries(assets.map((a, i) => [a, expectedReturns[i]]));
+  m.constraint(expr`${dot(retMap, w)} >= ${targetReturn}`, "target_return");
+
+  // 3. Quadratic Objective: minimize risk w^T * Sigma * w
+  let risk = new QuadExpr();
+  for (let i = 0; i < assets.length; i++) {
+    for (let j = 0; j < assets.length; j++) {
+      if (cov[i][j] !== 0) {
+        risk = risk.add(w[assets[i]].mul(w[assets[j]]).mul(cov[i][j]));
+      }
+    }
+  }
+  m.objective(minimize(risk));
+
+  // Solve natively with HiGHS Convex QP engine
+  const status = await m.solve();
+
+  console.log(`Status: ${status}`);
+  console.log(`Variance: ${m.objectiveValue?.toFixed(6)}`);
+  console.log(`Volatility (Std Dev): ${((Math.sqrt(m.objectiveValue || 0)) * 100).toFixed(2)}%`);
+
+  assets.forEach((name) => {
+    console.log(`  ${name.padEnd(10)}: ${((w[name].value ?? 0) * 100).toFixed(2)}%`);
+  });
+}
+
+solvePortfolio();
+```
+
+</CodeRunner>

package/docs/examples/production.md

@@ -0,0 +1,51 @@
+# Production Planning (LP / MIP)
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| Linear / Integer Programming (LP / MIP) | HiGHS (default) | `m.integer()`, `m.constraint()`, `expr` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=production">Open in Playground</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/01-production-planning.ts">Source Code</a></li></ul> |
+
+Production planning is a classic Linear Programming problem: determine the optimal quantity of each product to manufacture in order to maximize total profit while respecting resource constraints (raw materials, machine time, labor hours).
+
+## Mathematical Formulation
+
+Let $x$ be the number of chairs and $y$ be the number of tables.
+
+$$\begin{aligned}
+\text{Maximize} \quad & 45x + 80y & (\text{Profit}) \\
+\text{Subject to} \quad & 5x + 20y \le 400 & (\text{Mahogany Wood limit}) \\
+& 10x + 15y \le 450 & (\text{Carpentry Labor limit}) \\
+& x, y \ge 0, \quad x, y \in \mathbb{Z} & (\text{Integer Quantities})
+\end{aligned}$$
+
+## Implementation in WaSHI
+
+<CodeRunner preset="production">
+
+```typescript
+import { Model, expr, maximize } from "@ohtaman/washi";
+
+async function runProductionOptimization() {
+  const m = new Model("FactoryProduction");
+
+  // Decision variables: non-negative integer quantities
+  const chairs = m.integer("chairs", { lb: 0 });
+  const tables = m.integer("tables", { lb: 0 });
+
+  // Objective: Maximize total profit ($45 per chair, $80 per table)
+  m.objective(maximize(expr`45 * ${chairs} + 80 * ${tables}`));
+
+  // Resource constraints: declarative formulas via expr and fluent constraint()
+  m.constraint(expr`5 * ${chairs} + 20 * ${tables} <= 400`, "mahogany_limit")
+   .constraint(expr`10 * ${chairs} + 15 * ${tables} <= 450`, "labor_limit");
+
+  const status = await m.solve();
+
+  console.log(`Status: ${status}`);
+  console.log(`Optimal Profit: $${m.objectiveValue}`);
+  console.log(`Chairs: ${chairs.value}, Tables: ${tables.value}`);
+}
+
+runProductionOptimization();
+```
+
+</CodeRunner>

package/docs/examples/shift-scheduling.md

@@ -0,0 +1,175 @@
+# Staff Shift Scheduling & Conflict Diagnosis (MIP + Z3)
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| Binary MIP & SMT Unsat Core | HiGHS + Z3 | `m.binary(staff, days)`, `m.constraint()`, `expr`, `minimize`, `dot`, `m.check()` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=shift_scheduling">Playground (Roster)</a></li><li><a href="https://ohtaman.github.io/washi/demo/?preset=shift_conflict_unsat">Playground (Conflict)</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/11-shift-scheduling.ts">Source Code</a></li></ul> |
+
+Staff shift scheduling is a classic real-world application of Mixed-Integer Programming in SaaS and workforce management tools. However, in real applications, **staff vacation requests frequently collide with minimum coverage or leadership rules**, causing the solver to return `Infeasible`.
+
+This example demonstrates a practical production workflow:
+1. **Try HiGHS MIP Optimization First:** Solve the shift model under the given vacation requests and operational constraints.
+2. **Accept Solution if Optimal:** If a feasible roster is found, display the schedule and minimized payroll cost without unnecessary diagnostic overhead.
+3. **Diagnose with Z3 `unsatCore` Only When Infeasible:** If HiGHS reports `Infeasible`, diagnose the **exact same model and constraints** with Z3 to isolate the conflicting constraint subset (`unsatCore`), pinpointing which day's coverage rules and which staff requests collided.
+
+> [!IMPORTANT]
+> **Vacation Requests are Hard Constraints:**
+> In this model, vacation requests are enforced as strict hard constraints (`shift[staff][day] == 0`), not soft constraints with penalty relaxation. When requests collide with mandatory staffing requirements, the model is strictly infeasible.
+
+<ShiftSchedulingDemo />
+
+## Scenario & Rules
+
+We schedule **5 staff members** (`Alice`, `Bob`, `Charlie`, `Diana`, `Evan`) across **7 days** (`Mon`–`Sun`):
+
+- **Daily Headcount:** `Mon–Thu`: 3 staff, `Fri`: 4 staff, `Sat`: 3 staff, `Sun`: 2 staff.
+- **Senior Duty:** At least 1 senior staff member (`Alice` or `Bob`) must be on duty every day.
+- **Work Limit:** Each staff member works at most **5 days** per week.
+- **Weekend Premium:** Weekend shifts (`Sat`, `Sun`) incur an extra `+$30` shift premium on top of base daily wage.
+
+We evaluate two distinct, named scenarios with different vacation inputs to illustrate the full workflow:
+- **Scenario A (Balanced Requests — Feasible):** Alice (Sun), Bob (Mon), Charlie (Sat), Diana (Wed). All constraints can be satisfied simultaneously. HiGHS outputs an optimal roster.
+- **Scenario B (Conflicting Requests — Infeasible & Diagnosis):** Alice (Sat), Bob (Sat), Charlie (Sat), Diana (Wed). Because both senior leaders (Alice and Bob) request Saturday off simultaneously, the rule requiring at least 1 senior on duty every day cannot be satisfied. HiGHS reports `Infeasible`, triggering Z3 conflict diagnosis.
+
+## Implementation in WaSHI
+
+<CodeRunner preset="shift_scheduling">
+
+```typescript
+import { Model, sum, dot, minimize, expr } from "@ohtaman/washi";
+import "@ohtaman/washi/solvers/z3";
+
+const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] as const;
+type Day = (typeof days)[number];
+
+const staffList = [
+  { name: "Alice",   isSenior: true,  dailyWage: 220, maxShifts: 5 },
+  { name: "Bob",     isSenior: true,  dailyWage: 210, maxShifts: 5 },
+  { name: "Charlie", isSenior: false, dailyWage: 160, maxShifts: 5 },
+  { name: "Diana",   isSenior: false, dailyWage: 160, maxShifts: 5 },
+  { name: "Evan",    isSenior: false, dailyWage: 150, maxShifts: 5 },
+];
+
+const requiredCoverage: Record<Day, number> = {
+  Mon: 3, Tue: 3, Wed: 3, Thu: 3, Fri: 4, Sat: 3, Sun: 2,
+};
+
+function buildShiftModel(name: string, dayOffRequests: Array<{ staff: string; day: Day }>) {
+  const m = new Model(name);
+
+  // 2D binary matrix: shift[staff][day] ∈ {0, 1}
+  const shift = m.binary(staffList.map((s) => s.name), [...days]);
+
+  // Objective: Minimize weekly payroll cost via 2D dot product
+  const costMatrix = Object.fromEntries(
+    staffList.map((s) => [
+      s.name,
+      Object.fromEntries(
+        days.map((d) => [d, s.dailyWage + (d === "Sat" || d === "Sun" ? 30 : 0)])
+      ),
+    ])
+  );
+  m.objective(minimize(dot(costMatrix, shift)));
+
+  // Rule 1: Daily headcount coverage
+  for (const d of days) {
+    m.constraint(
+      expr`${sum(staffList, (s) => shift[s.name][d])} >= ${requiredCoverage[d]}`,
+      `coverage_${d}`
+    );
+  }
+
+  // Rule 2: At least 1 senior staff member per day
+  const seniors = staffList.filter((s) => s.isSenior);
+  for (const d of days) {
+    m.constraint(
+      expr`${sum(seniors, (s) => shift[s.name][d])} >= 1`,
+      `senior_duty_${d}`
+    );
+  }
+
+  // Rule 3: Max working days per staff member
+  for (const s of staffList) {
+    m.constraint(
+      expr`${sum(days, (d) => shift[s.name][d])} <= ${s.maxShifts}`,
+      `max_shifts_${s.name}`
+    );
+  }
+
+  // Rule 4: Named day-off requests as HARD constraints (shift[staff][day] == 0)
+  for (const req of dayOffRequests) {
+    m.constraint(
+      expr`${shift[req.staff][req.day]} == 0`,
+      `day_off_${req.staff}_${req.day}`
+    );
+  }
+
+  return { model: m, shift };
+}
+
+async function runScenario(
+  title: string,
+  modelName: string,
+  dayOffRequests: Array<{ staff: string; day: Day }>
+) {
+  console.log(`=== ${title} ===`);
+  console.log(
+    "Hard Vacation Requests: " +
+      dayOffRequests.map((r) => `${r.staff} (${r.day})`).join(", ")
+  );
+
+  const { model, shift } = buildShiftModel(modelName, dayOffRequests);
+
+  // Step 1: Optimize with HiGHS
+  const status = await model.solve();
+  console.log(`HiGHS Optimize Status: ${status}`);
+
+  if (status === "Optimal") {
+    console.log(`Optimal Weekly Payroll: $${model.objectiveValue}`);
+    for (const s of staffList) {
+      const schedule = days.map((d) => (Math.round(shift[s.name][d].value ?? 0) === 1 ? "ON" : " ·"));
+      console.log(`  ${s.name.padEnd(8)}: ${schedule.join(" ")}`);
+    }
+    console.log("Schedule resolved successfully (no UNSAT diagnosis needed).\n");
+  } else if (status === "Infeasible") {
+    // Step 2: Diagnose the exact same model and constraints with Z3
+    console.log("HiGHS returned Infeasible! Diagnosing conflict with Z3 unsatCore...");
+    const checkRes = await model.check({ solver: "z3" });
+    console.log(`Z3 Check Status: ${checkRes.status}`);
+    console.log("Conflicting Constraint Subset (unsatCore):", model.unsatCore);
+    console.log(
+      "Note: unsatCore returns a conflicting subset (minimality/order not guaranteed). " +
+      "Independent requests like Diana's Wednesday off are excluded.\n"
+    );
+  }
+}
+
+async function main() {
+  // Scenario A: Balanced requests (Solvable)
+  await runScenario(
+    "Scenario A: Balanced Vacation Requests",
+    "FeasibleRoster",
+    [
+      { staff: "Alice", day: "Sun" },
+      { staff: "Bob", day: "Mon" },
+      { staff: "Charlie", day: "Sat" },
+      { staff: "Diana", day: "Wed" },
+    ]
+  );
+
+  // Scenario B: Conflicting Saturday requests (Infeasible)
+  await runScenario(
+    "Scenario B: Conflicting Saturday Requests",
+    "ConflictRoster",
+    [
+      { staff: "Alice", day: "Sat" }, // Senior
+      { staff: "Bob", day: "Sat" },   // Senior
+      { staff: "Charlie", day: "Sat" },
+      { staff: "Diana", day: "Wed" },
+    ]
+  );
+}
+
+main();
+```
+
+</CodeRunner>

package/docs/examples/smt-security.md

@@ -0,0 +1,74 @@
+# SMT Security Policies
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| Propositional Logic & SMT | Z3 (`@ohtaman/washi/solvers/z3`) | `m.bool()`, `m.integer()`, `m.constraint()`, `expr`, `m.check()` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=smt_sat_scheduling">Open in Playground</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/04-smt-security-rules.ts">Source Code</a></li></ul> |
+
+Satisfiability Modulo Theories (SMT) combines propositional logic (Boolean SAT) with first-order theories (linear integer arithmetic, real inequalities).
+
+This example demonstrates how to formally verify and deduce system states in an IoT home security system using WaSHI and the Z3 solver engine.
+
+## The Scenario
+
+We model a security rule system with sensor readings and logic rules:
+1. When ambient light $\le 50$, it implies night time (`isNight`).
+2. When motion is detected at night and the alarm is armed, the siren must sound.
+3. If the alarm is armed, the front door must never be unlocked.
+4. When motion is detected at night, comfort lights should turn on.
+
+## Implementation in WaSHI
+
+<CodeRunner preset="smt_sat_scheduling">
+
+```typescript
+import { Model, not, expr } from "@ohtaman/washi";
+import "@ohtaman/washi/solvers/z3";
+
+async function verifySecurityRules() {
+  const m = new Model({ name: "SmartHomeSecurity", solver: "z3" });
+
+  // 1. Boolean Propositional Variables
+  const isNight = m.bool("isNight");
+  const motionDetected = m.bool("motionDetected");
+  const alarmArmed = m.bool("alarmArmed");
+  const frontDoorUnlocked = m.bool("frontDoorUnlocked");
+  const sirenActive = m.bool("sirenActive");
+  const lightsOn = m.bool("lightsOn");
+
+  // 2. Arithmetic metric (lux sensor)
+  const luxLevel = m.integer("luxLevel", { lb: 0, ub: 1000 });
+
+  // Rule 1: luxLevel <= 50 implies isNight
+  m.constraint(luxLevel.le(50).implies(isNight), "dark_implies_night");
+
+  // Rule 2: (motionDetected AND isNight AND alarmArmed) => sirenActive
+  m.constraint(
+    motionDetected.and(isNight).and(alarmArmed).implies(sirenActive),
+    "intrusion_rule"
+  );
+
+  // Rule 3: alarmArmed => NOT(frontDoorUnlocked)
+  m.constraint(alarmArmed.implies(not(frontDoorUnlocked)), "lock_safety_rule");
+
+  // Rule 4: (motionDetected AND isNight) => lightsOn
+  m.constraint(motionDetected.and(isNight).implies(lightsOn), "comfort_lights");
+
+  // 3. Observed Context
+  m.constraint(expr`${luxLevel} <= 20`, "sensor_reading_dark");
+  m.constraint(alarmArmed, "user_armed_alarm");
+  m.constraint(motionDetected, "sensor_motion_triggered");
+
+  // Check satisfiability and deduce state
+  const res = await m.check({ solver: "z3" });
+
+  console.log(`Status: ${res.status}`);
+  console.log(`Siren Active : ${sirenActive.value}`);
+  console.log(`Lights On    : ${lightsOn.value}`);
+  console.log(`Door Locked  : ${frontDoorUnlocked.value ? "No" : "Yes"}`);
+  console.log(`Is Night     : ${isNight.value}`);
+}
+
+verifySecurityRules();
+```
+
+</CodeRunner>

package/docs/examples/transportation.md

@@ -0,0 +1,90 @@
+# Transportation & Allocation Network (LP)
+
+| Problem Class | Solver | Key APIs | Links |
+| :--- | :--- | :--- | :--- |
+| Linear Programming (LP) | HiGHS (default) | `m.continuous()`, `m.constraint()`, `expr`, `minimize`, `dot` | <ul><li><a href="https://ohtaman.github.io/washi/demo/?preset=transportation">Open in Playground</a></li><li><a href="https://github.com/ohtaman/washi/blob/main/examples/node/09-transportation-problem.ts">Source Code</a></li></ul> |
+
+The transportation problem is one of the most fundamental network optimization models: determine how many units to ship from each supply origin (factory) to each destination (store) to minimize total shipping cost while respecting factory supply limits and meeting store demands.
+
+This example demonstrates how to construct a **2D matrix of decision variables** using `m.continuous(factories, stores)` and write aggregated constraints declaratively via `dot()` and `m.constraint(expr`...`)`.
+
+## Problem Inputs
+
+We have **3 factories** (`Tokyo`, `Nagoya`, `Osaka`) shipping to **4 regional stores** (`North`, `East`, `West`, `South`):
+
+| Factory \ Store | North ($/unit) | East ($/unit) | West ($/unit) | South ($/unit) | Supply Capacity |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **Tokyo** | $4 | $2 | $7 | $8 | **120** units |
+| **Nagoya** | $6 | $4 | $3 | $5 | **100** units |
+| **Osaka** | $9 | $7 | $2 | $3 | **80** units |
+| **Store Demand** | **70** units | **90** units | **60** units | **60** units | Total: 280 / 300 |
+
+## Mathematical Formulation
+
+Let $x_{f, s} \ge 0$ be the quantity shipped from factory $f \in F$ to store $s \in S$, and $c_{f, s}$ be the unit shipping cost.
+
+$$\begin{aligned}
+\text{Minimize} \quad & \sum_{f \in F} \sum_{s \in S} c_{f,s} \, x_{f,s} \\
+\text{Subject to} \quad & \sum_{s \in S} x_{f,s} \le \text{Supply}_f \quad \forall f \in F \quad (\text{Factory capacity}) \\
+& \sum_{f \in F} x_{f,s} \ge \text{Demand}_s \quad \forall s \in S \quad (\text{Store demand}) \\
+& x_{f,s} \ge 0 \quad \forall f \in F, s \in S
+\end{aligned}$$
+
+## Implementation in WaSHI
+
+<CodeRunner preset="transportation">
+
+```typescript
+import { Model, sum, dot, minimize, expr } from "@ohtaman/washi";
+
+const factories = ["Tokyo", "Nagoya", "Osaka"] as const;
+const stores = ["North", "East", "West", "South"] as const;
+
+const shippingCost = {
+  Tokyo:  { North: 4, East: 2, West: 7, South: 8 },
+  Nagoya: { North: 6, East: 4, West: 3, South: 5 },
+  Osaka:  { North: 9, East: 7, West: 2, South: 3 },
+};
+
+const supplies = { Tokyo: 120, Nagoya: 100, Osaka: 80 };
+const demands = { North: 70, East: 90, West: 60, South: 60 };
+
+async function runTransportation() {
+  const m = new Model("TransportationNetwork");
+
+  // 1. Create 2D continuous variables: ship[factory][store] >= 0
+  const ship = m.continuous([...factories], [...stores], { lb: 0 });
+
+  // 2. Objective: Minimize total shipping cost across all routes via 2D dot product
+  m.objective(minimize(dot(shippingCost, ship)));
+
+  // 3. Supply constraints (row sums): outgoing from f <= supplies[f]
+  for (const f of factories) {
+    m.constraint(
+      expr`${sum(stores, (s) => ship[f][s])} <= ${supplies[f]}`,
+      `supply_${f}`
+    );
+  }
+
+  // 4. Demand constraints (column sums): incoming to s >= demands[s]
+  for (const s of stores) {
+    m.constraint(
+      expr`${sum(factories, (f) => ship[f][s])} >= ${demands[s]}`,
+      `demand_${s}`
+    );
+  }
+
+  const status = await m.solve();
+  console.log(`Status: ${status}, Total Shipping Cost: $${m.objectiveValue}`);
+  for (const f of factories) {
+    const routes = stores
+      .map((s) => `${s}:${Math.round(ship[f][s].value ?? 0)}`)
+      .join(", ");
+    console.log(`  ${f.padEnd(7)} -> ${routes}`);
+  }
+}
+
+runTransportation();
+```
+
+</CodeRunner>