ライブデモ

ブラウザ内のインタラクティブなデモ — ベンチマーク構造とソルバー結果を可視化し、WebAssembly Python でソルバーをライブ実行。インストール不要、サーバー不要。

これらのデモは完全にブラウザ内で実行されます。Visualize タブは公開安全なプレビューエビデンス — ソルバーのリーダーボード、収束および探索-活用のアニメーションチャート、スケーラビリティ・シード安定性・ロバスト性の分析チャート、そして任意のベンチマークインスタンスの構造的特性評価 — をチャート化します。Run live タブは WebAssembly サンドボックス（Pyodide）で実際の Python を実行します: ソルバーを編集し、何もインストールせずに再実行できます。Analyze タブは、シードを固定した完全な実験を実行し、効果量とブートストラップ信頼区間を用いて 2 つのソルバーを比較します。これは完全なツールキットが用いるのと同じ証拠の規律です。

ここにあるすべては説明的で公開安全なプレビュー素材です。完全なツールキットは、同じ種類のベンチマーキング・求解・分析を研究スケールで実行します — クイックスタートから始めるか、ベンチマークカタログを閲覧してください。

Solver leaderboard

Best makespan per solver on the smoke benchmark set (lower is better). Bundled demo evidence — not a comparative ranking.

Convergence trajectory

How each iterative solver’s best-so-far objective improves over iterations — the anytime curve.

Per-iteration best-so-far objective for a native iterative cohort on a smoke instance (lower is better) — hover, or focus the chart and use the arrow keys, to read each solver’s incumbent. Public-safe preview from a real seeded run; the full platform traces convergence at research scale.

Exploration–exploitation balance

Population diversity over iterations — high while the search explores, falling as it exploits and converges.

Mean population diversity by iteration for the native population solver on a smoke instance — high while the search explores, falling as it exploits and converges. Hover, or focus the chart and use the arrow keys, to read the diversity. Public-safe preview from a real seeded run.

Scalability (size response)

Makespan across a doubling task-count ladder — how each solver scales as the problem grows.

Makespan across a doubling task-count ladder (16–96 tasks) for a dispatching baseline and a native metaheuristic on one Edge–Fog–Cloud family — reading the size response is the scalability curve a results section reports. Hover, or focus the chart and use the arrow keys, to read each solver’s makespan; the native search holds a slim edge that widens with size. Public-safe preview from real seeded solves.

Seed stability

Coefficient of variation across the seed set — how consistently each solver reaches its result.

Each solver’s seed coefficient of variation (makespan standard deviation over the seed set, divided by the mean) — lower is more stable. A deterministic solver reads zero. Hover or focus a bar to read it. Public-safe aggregate from a seed-replicated smoke campaign.

Robustness (tail risk)

CVaR of the worst per-problem makespan-ratio tail — ranking solvers by deployment-relevant risk, not the mean.

Each solver’s conditional value-at-risk (CVaR) of the worst tail of its makespan ratios (each run’s makespan over the problem’s best across the field) over the seed set — lower is more robust, ranking by deployment-relevant tail risk rather than the mean. Hover or focus a bar to read it. Public-safe aggregate from the same seed-replicated smoke campaign.

Benchmark characterization

Pick an instance to see its structural fingerprint.

Benchmark instance

heterogeneity

1.00

objective conflict

1.00

load skew

0.83

uncertainty

0.67

compatibility sparsity

0.67

opportunity density

0.50

solver sensitivity

0.45

dynamism

0.10

overload

0.04

contention

0.04

communication pressure

0.00

dependency depth

0.00

setup intensity

0.00

Each benchmark is characterized by quantitative metrics in [0, 1]. These structural features are what make the catalog construct-based rather than tag-based.

This runs real Python in your browser via WebAssembly (Pyodide) — no server, no install. It is a light illustrative solver; the full toolkit runs the same kinds of computation at research scale.

solver.py

# A self-contained scheduling scenario that mirrors the toolkit's
# benchmark -> solve -> analyze workflow: generate a heterogeneous instance,
# run three dispatching heuristics, and compare their makespans.
# Edit anything and re-run — it executes in your browser.
import random

random.seed(20260527)  # deterministic, like the toolkit's recorded seeds
n_tasks, n_machines = 9, 3

# Heterogeneous benchmark instance: task i has a different duration per machine.
exec_time = {
    (i, m): random.randint(2, 9)
    for i in range(n_tasks)
    for m in range(n_machines)
}

def makespan(order, pick):
    loads = [0] * n_machines
    for i in order:
        m = pick(i, loads)
        loads[m] += exec_time[(i, m)]
    return max(loads)

lpt = sorted(range(n_tasks), key=lambda i: -min(exec_time[(i, m)] for m in range(n_machines)))
least_loaded = lambda i, loads: min(range(n_machines), key=lambda m: loads[m] + exec_time[(i, m)])

solvers = {
    "min-load-greedy": (range(n_tasks), least_loaded),
    "LPT + min-load":  (lpt,            least_loaded),
    "fastest-machine": (range(n_tasks), lambda i, loads: min(range(n_machines), key=lambda m: exec_time[(i, m)])),
}

results = {name: makespan(order, pick) for name, (order, pick) in solvers.items()}
best = min(results, key=results.get)

print(f"Instance: {n_tasks} tasks x {n_machines} heterogeneous machines\n")
print(f"{'solver':18} makespan")
print("-" * 30)
for name, mk in sorted(results.items(), key=lambda kv: kv[1]):
    print(f"{name:18} {mk:>5}{'   <- best' if name == best else ''}")
print(f"\nBest here: {best}. Capability, not a universal claim — the full")
print("toolkit runs fair, seeded, statistically-compared campaigns.")

Output

Press Run to execute the solver in your browser.

A complete experiment-then-analysis scenario: it runs two solvers across many seeded instances and compares them the way the toolkit reports evidence — with a Cliff’s-delta effect size and a bootstrap confidence interval, never a bare p-value. Runs live in your browser; edit the budget or the solvers and re-run.

experiment.py

# A complete benchmark -> solve -> ANALYZE scenario, reported the way the
# toolkit reports evidence: run two dispatching heuristics across many seeded
# instances, then compare them with an effect size AND a bootstrap confidence
# interval — never a bare p-value. Edit anything and re-run; it runs in your browser.
import random, statistics

SEEDS = 40                    # independent seeded instances (a real run budget)
N_TASKS, N_MACHINES = 12, 3

def instance(seed):
    rng = random.Random(seed)
    return {(i, m): rng.randint(2, 9)
            for i in range(N_TASKS) for m in range(N_MACHINES)}

def makespan(et, order, pick):
    loads = [0] * N_MACHINES
    for i in order:
        m = pick(i, loads, et)
        loads[m] += et[(i, m)]
    return max(loads)

def least_loaded(i, loads, et):
    return min(range(N_MACHINES), key=lambda m: loads[m] + et[(i, m)])

def lpt_order(et):            # longest-processing-time first
    return sorted(range(N_TASKS),
                  key=lambda i: -min(et[(i, m)] for m in range(N_MACHINES)))

A, B = "LPT + min-load", "arrival-order + min-load"
a, b = [], []
for s in range(SEEDS):
    et = instance(20260000 + s)
    a.append(makespan(et, lpt_order(et), least_loaded))
    b.append(makespan(et, range(N_TASKS), least_loaded))

# Cliff's delta: (#(A>B) - #(A<B)) / (n*m). Negative => A tends to be smaller (better).
gt = sum(x > y for x in a for y in b)
lt = sum(x < y for x in a for y in b)
delta = (gt - lt) / (len(a) * len(b))
mag = next(lbl for thr, lbl in
           [(0.147, "negligible"), (0.33, "small"), (0.474, "medium"), (2.0, "large")]
           if abs(delta) < thr)

# Bootstrap 95% CI on the mean paired difference A - B (percentile method).
diffs = [x - y for x, y in zip(a, b)]
boot_rng = random.Random(7)
boot = sorted(statistics.fmean(boot_rng.choices(diffs, k=len(diffs)))
              for _ in range(2000))
lo, hi = boot[int(0.025 * len(boot))], boot[int(0.975 * len(boot)) - 1]

print(f"{SEEDS} seeded instances - {N_TASKS} tasks x {N_MACHINES} machines\n")
print(f"mean makespan  {A:24} {statistics.fmean(a):6.2f}")
print(f"mean makespan  {B:24} {statistics.fmean(b):6.2f}\n")
print(f"Cliff's delta (A vs B):  {delta:+.3f}  ({mag} effect)")
print(f"95% bootstrap CI of mean(A - B):  [{lo:+.2f}, {hi:+.2f}]")
credible = ("excludes 0 - the advantage is statistically credible"
            if (lo < 0) == (hi < 0) else "spans 0 - no credible difference")
print(f"  the interval {credible}.\n")
print("Reported with an effect size AND a confidence interval, never a bare")
print("p-value. The full platform adds Holm-corrected Wilcoxon / Friedman tests")
print("across the whole catalog.")

Output

Press Run to execute the solver in your browser.