솔버 시스템

dispatchatlas.solve는 솔버 메타데이터, 선택, 스케줄 구성, 수리, 성능 보호장치, 베이스라인 패밀리, 선택적 어댑터, 그리고 NDSO 패밀리를 소유합니다.

이 패키지는 dispatchatlas.core만 임포트합니다. 벤치마크 스모크 통합 테스트는 tests/solve/에 있으므로 런타임 패키지는 구체적인 벤치마크 생성기에 의존하지 않습니다.

실행 가능한 예제: examples/compare_solvers.py는 솔버 코호트를 병렬로 스케줄링하고 증명된 정확한 최적값으로 그것을 고정합니다.

레지스트리

SolverRegistry는 풍부한 메타데이터를 가진 무상태 솔버 팩토리를 저장합니다:

capacity-aware, precedence-aware, repair, local-search, 그리고 ndso 같은 능력 태그
makespan, energy, 그리고 cost 같은 지원 목적
능력 태그를 통해 표현된 선언된 제약
기본 정지 기준
결정론적 또는 시드된 확률적 재생 동작
해 인코딩 (permutation, mapping, assignment, 또는 native)
선택적 의존성 선언과 상용-백엔드 공개
단계적 익스포트를 위한 증거-등급 가시성
정준 인용, 또는 명시적 인용-비해당 근거

각 명명된 솔버 패밀리는 닫혀 실패하는 인용을 지닙니다: 정준적 효시 기원을 가지면서 그 참조를 생략하는 패밀리는 구성될 수 없고, 단일 정준 기원이 없는 패밀리는 하나를 날조하는 대신 이유를 기록합니다.

from dispatchatlas.solve import SolverCapability, default_solver_registry
 
registry = default_solver_registry()
metaheuristics = registry.select(
    required_capabilities=(SolverCapability.METAHEURISTIC,),
    objective="makespan",
)

레지스트리 카탈로그

레지스트리의 모든 솔버를, 정렬 가능하고 검색 가능한 하나의 표에. 표와 그 합계는 default_solver_registry()에서 생성되므로 아래 카운트는 행 자체에서 셀 수 있습니다. 표 위의 능력-커버리지 차트는 몇 개의 레지스트리 솔버가 각 선언된 능력을 표방하는지 요약합니다.

Generated from the solver registry: 87 solvers across 6 groups — constructive (5), dispatching (14), exact (7), learning (11), metaheuristic (47), ndso (3).

How many of the 87 registry solvers advertise each declared capability — a metadata-only view of the registry’s breadth (a constructive baseline through to many-objective and native solvers). Hover or focus a bar to read its count.

Search solversGroupGroup by

Showing 87 of 87 solvers.

Solver registry — 87 rows, build-inlined from the public registry bundle.
		Supported objectives	Notes
`adpso`	metaheuristic	makespan, energy, cost	Inspect caveats success-rate feedback is noisy on small swarms competitor adpso currency anchor Sensors (MDPI), 2022 encoding adapter random-key evidence class runnable-baseline mechanism swarm search with success-adaptive descending inertia strengths inertia tracks search progress instead of a fixed ramp venue tier indexed-peer-reviewed
`age-moea-ii`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats geometry estimate is noisy on tiny first fronts competitor age-moea-ii evidence class runnable-baseline geometry Newton-Raphson curvature fit of the sum(x^p)=1 surface mechanism adaptive front-geometry estimation with geodesic survival strengths spread faithful to convex, linear, and concave fronts
`ant-colony`	metaheuristic	makespan, energy, cost	Inspect mechanism rate-gated adjacent swaps of the incumbent order metaheuristic ant-colony realization no pheromone trail matrix or cooperating colony is implemented; the citation marks lineage, not mechanism fidelity scheduling contract permutation-decode-to-schedule
`apparent-tardiness-cost`	dispatching	makespan, lateness, energy, cost	Inspect dispatch rule apparent-tardiness-cost priority basis highest apparent-tardiness-cost index first (unweighted, k=2)
`arithmetic-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats every member is regenerated around the best vector each iteration, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Abualigah, L., Diabat, A., & Abd Elaziz, M. (2021). Intelligent workflow scheduling for Big Data applications in IoT cloud computing environments. Cluster Computing, 24, 2957-2976. doi:10.1007/s10586-021-03291-7 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search whose accelerator schedule shifts from wide-scatter division and multiplication moves to tight addition and subtraction moves around the best vector as the budget elapses strengths the two operator pairs give a clean exploration-to-exploitation handover governed only by the iteration ratio
`artificial-bee-colony`	metaheuristic	makespan, energy, cost	Inspect caveats the per-component neighbor move explores slowly on long priority vectors, so many iterations may be needed at large task counts discrete adaptation Pan, Q.-K., Tasgetiren, M. F., Suganthan, P. N., & Chua, T. J. (2011). A discrete artificial bee colony algorithm for the lot-streaming flow shop scheduling problem. Information Sciences, 181(12), 2455-2468. doi:10.1016/j.ins.2009.12.025 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search with three phases per iteration: a greedy neighbor perturbation of every member toward a random peer, a fitness-weighted resample that perturbs promising members again, and a re-initialization of any member that fails to improve for a set number of trials strengths the fitness-weighted resample concentrates effort on promising members while the trial-limit re-initialization sustains diversity
`artificial-fish-swarm`	metaheuristic	makespan, energy, cost	Inspect caveats each behaviour re-scores candidate positions, so an iteration costs several schedule evaluations per member discrete adaptation Ibadi, A. M., & Rahman, R. A. (2024). Modified artificial fish swarm algorithm to solve unrelated parallel machine scheduling problem under fuzzy environment. AIMS Mathematics, 9(1), 1679-1705. doi:10.3934/math.20241679 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search where each member adopts the better of a swarm move toward nearby members' centre and a follow move toward the best nearby member, each falling back to a local random probe when its move condition fails strengths the crowding test spreads members across several basins rather than collapsing them onto one centre
`beam-search`	constructive	makespan, energy, cost	Inspect beam width 3 mechanism breadth-bounded constructive search priority basis best topological completion score
`branch-and-bound`	exact	makespan, energy, cost	Inspect commercial false dependency ortools dependency extra exact dependency purpose branch-and-bound / branch-and-cut adapter dependency requirement optional exact method branch-and-bound license note OR-Tools is Apache-2.0 licensed; no commercial terms. optimality verification solves-to-optimal-verified
`ccgp`	metaheuristic	makespan, energy, cost	Inspect caveats rule evaluation cost grows with population and graph size competitor ccgp currency anchor Computers & Operations Research (Elsevier), 2024 evidence class runnable-baseline mechanism cooperative coevolution of priority-rule trees strengths learns instance-feature priority rules instead of orders venue tier top-tier-operations-research
`clpso`	metaheuristic	makespan, energy, cost	Inspect decode rule random-key encoded solver clpso encoding adapter random-key repair policy topological-normalize transfer identity
`cma-es`	metaheuristic	makespan, energy, cost	Inspect caveats the random-key encoding is a documented adaptation of the continuous method to the discrete order space encoding tasks sequenced by ascending random key, repaired to precedence feasibility evidence class runnable-baseline mechanism covariance-matrix-adaptation evolution strategy over a random-key encoding of the task order recombination weighted mean of the best mu offspring with rank-one and rank-mu covariance updates step size control cumulative step-size adaptation with the h_sigma stall guard strengths adapts an anisotropic search distribution to the objective landscape without hand-tuned scaling
`cpop`	dispatching	makespan, energy, cost	Inspect mechanism combined upward-and-downward rank list scheduling priority basis upward plus downward rank; critical tasks first rank basis combined-rank realization rank-ordered dispatch; resource and mode binding by the serial constructor's earliest-finish rule, a documented variant of the published critical-path-processor pinning
`critical-path-tabu`	metaheuristic	makespan, energy, cost	Inspect caveats path relinking between elite solutions is not realized; a documented reduction of the published method competitor critical-path-tabu evidence class runnable-baseline mechanism critical-path block-boundary tabu search relates to tabu-search: the mechanism-diversified competitor realization strengths moves concentrate on the makespan-defining chain
`cuckoo-search`	metaheuristic	makespan, energy, cost	Inspect caveats the Levy move is greedy per member, so progress depends on the incumbent and the step scale rather than a monotone population discrete adaptation Marichelvam, M. K., Prabaharan, T., & Yang, X.-S. (2014). Improved cuckoo search algorithm for hybrid flow shop scheduling problems to minimize makespan. Applied Soft Computing, 19, 93-101. doi:10.1016/j.asoc.2014.02.005 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search that steps every member toward the best-so-far solution by a heavy-tailed Levy displacement, keeps the step only when it improves, and re-initializes a fixed fraction of the worst members each iteration strengths the heavy-tailed step occasionally makes a large jump that escapes local optima while the discovery step sustains diversity
`d-clpso`	metaheuristic	makespan, energy, cost	Inspect decode rule spv encoded solver d-clpso encoding adapter spv repair policy topological-normalize search domain [-1.0, 1.0] transfer identity
`d-depso`	metaheuristic	makespan, energy, cost	Inspect hybrid of differential-evolution + particle-swarm scheduling contract permutation-decode-to-schedule scheduling variant d-depso
`d-lshade`	metaheuristic	makespan, energy, cost	Inspect decode rule rounding encoded solver d-lshade encoding adapter rounding repair policy topological-normalize transfer identity
`dan-dual-attention`	learning	makespan, energy, cost	Inspect documented adaptation faithful dual-attention architecture -- the operation message attention block over the precedence window and the machine message attention block over the machine-competition graph -- adapting the published amortized PPO-clip training to single-instance REINFORCE over seeded rollouts, greedy order decode, and the platform's uniform per-machine durations that collapse the (operation, machine) action to the operation order the serial decoder scores evidence class runnable-baseline learned paradigm policy-gradient dual-attention construction mechanism dual-attention network + policy-gradient PDR scheduler optional extra learning policy basis dual-attention network with an operation message attention block over the precedence window and a machine message attention block over the machine-competition graph, scoring compatible operation-machine pairs for a size-agnostic dispatching policy training single-instance REINFORCE over seeded rollouts with a terminal normalized-improvement reward and a mean-return baseline
`decima-dag-rl`	learning	makespan, energy, cost	Inspect documented adaptation faithful Decima two-level DAG message passing and REINFORCE policy gradient; the composite (node, parallelism-limit) action collapses to node selection because the platform exposes no parallelism-limit control, per-node critical-path features replace the reference executor and job-level features that have no platform counterpart, and single-instance training with a greedy decode and a terminal normalized schedule-score reward adapt the published cross-instance training and time-in-system reward to the platform's per-instance solve contract evidence class runnable-baseline learned paradigm policy-gradient GNN construction (REINFORCE) mechanism Decima two-level DAG-GNN + REINFORCE construction scheduler optional extra learning policy basis two-level DAG message passing with per-node, per-DAG, and global summaries training single-instance REINFORCE over seeded rollouts with a running-mean baseline and a terminal normalized-improvement reward
`decision-diagram-sequencing`	exact	makespan, energy, cost	Inspect commercial false exact method decision-diagram license note Native pure-Python decision-diagram branch and bound; no third-party backend and no licensing constraints. native task cap 12 optimality verification solves-to-optimal-verified
`differential-evolution`	metaheuristic	makespan, energy, cost	Inspect mechanism positional nudge toward a uniformly drawn donor order metaheuristic differential-evolution realization a discrete recombination, not the cited difference-vector arithmetic; the citation marks lineage, not mechanism fidelity scheduling contract permutation-decode-to-schedule
`earliest-deadline`	dispatching	makespan, energy, cost	Inspect dispatch rule earliest-deadline priority basis earliest declared deadline first (EDD / deadline-aware)
`earliest-finish-time`	dispatching	makespan, energy, cost	Inspect dispatch rule earliest-finish-time priority basis earliest reachable finish first (release + duration)
`earliest-start`	dispatching	makespan, energy, cost	Inspect dispatch rule input-order priority basis input order
`epso`	metaheuristic	makespan, energy, cost	Inspect caveats path gathering can over-constrain loosely coupled graphs competitor epso currency anchor Electronics (MDPI), 2023 encoding adapter random-key evidence class runnable-baseline mechanism workload-biased-initialization swarm with path gathering strengths quality-seeded swarm over a reduced particle dimension venue tier indexed-peer-reviewed
`exhaustive-enumeration`	exact	makespan, energy, cost	Inspect commercial false exact method exhaustive-enumeration license note Native pure-Python exact enumeration; no third-party backend and no licensing constraints. native task cap 8 optimality verification solves-to-optimal-verified
`firefly-algorithm`	metaheuristic	makespan, energy, cost	Inspect caveats the pairwise attraction is quadratic in the population size, and positions move unconditionally so the returned order is the best observed rather than a monotone incumbent discrete adaptation Sayadi, M. K., Hafezalkotob, A., & Naini, S. G. J. (2013). Firefly-inspired algorithm for discrete optimization problems: An application to manufacturing cell formation. Journal of Manufacturing Systems, 32(1), 78-84. doi:10.1016/j.jmsy.2012.06.004 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search attracting every priority vector toward every brighter member by a distance-decaying step plus a randomization term that shrinks over the budget strengths distance-decaying attraction lets subgroups converge on several basins before the randomization term fades
`fjsp-hgnn-drl`	learning	makespan, energy, cost	Inspect documented adaptation faithful HGNN architecture; single-instance training, greedy order decode, and uniform per-machine durations adapt the published amortized FJSP scheduler to the platform's per-instance task-order model evidence class runnable-baseline learned paradigm policy-gradient GNN construction (PPO) mechanism heterogeneous-GNN + PPO construction scheduler optional extra learning policy basis heterogeneous graph attention over operations and machines training single-instance proximal policy optimization over seeded rollouts with a terminal normalized-improvement reward
`genetic-algorithm`	metaheuristic	makespan, energy, cost	Inspect mechanism elite-pair order crossover with adjacent-swap mutation metaheuristic genetic-algorithm realization selection-crossover-mutation loop over a permutation population; faithful in kind to the cited scheme at baseline scale scheduling contract permutation-decode-to-schedule
`grasshopper-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats the pairwise social forces are quadratic in the population size, and positions move unconditionally each iteration; on a Largest Order Value decode the published update adds little beyond its initial population, because it replaces each position with the target plus the force sum rather than perturbing it, and the resulting displacement peaks near a tenth of the gap between adjacent priorities -- short of the separation a rank swap needs. The shortfall is scale-free in the priority span and does not close with population size, so it is a property of the method on this encoding rather than a tuning choice discrete adaptation Naveen Durai, S. K., & Duraisamy, B. (2022). Hybrid Invasive Weed Improved Grasshopper Optimization Algorithm for Cloud Load Balancing. Intelligent Automation & Soft Computing, 34(1), 467-483. doi:10.32604/iasc.2022.026020 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search displacing every member by the sum of pairwise attraction/repulsion forces from all others, scaled toward the best-so-far target by a comfort coefficient that decays over the budget strengths the decaying comfort coefficient shrinks the repulsion zone so the swarm settles from exploration onto the target
`gravitational-search`	metaheuristic	makespan, energy, cost	Inspect caveats the pairwise forces are quadratic in the population size, and the velocity carries momentum that can overshoot on a coarse budget discrete adaptation Choudhary, A., Gupta, I., Singh, V., & Jana, P. K. (2018). A GSA based hybrid algorithm for bi-objective workflow scheduling in cloud computing. Future Generation Computer Systems, 83, 14-26. doi:10.1016/j.future.2018.01.005 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search that gives every member a mass from its fitness, accelerates each member by the summed pairwise attractive forces of the others (each force scaling with the product of masses and decaying with separation), and integrates a velocity and position under a coefficient that shrinks over the budget strengths heavier better-scoring members exert more pull, so the population is drawn toward high-quality regions as the coefficient decay sharpens the search
`greedy-completion`	dispatching	makespan, energy, cost	Inspect dispatch rule greedy-completion priority basis state-aware earliest completion next
`grey-wolf-optimizer`	metaheuristic	makespan, energy, cost	Inspect caveats positions move unconditionally each iteration, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Hosseini Shirvani, M. (2022). A Novel Discrete Grey Wolf Optimizer for Scientific Workflow Scheduling in Heterogeneous Cloud Computing Platforms. Scientia Iranica. doi:10.24200/sci.2022.57262.5144 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search drawing every priority vector toward the three best-ranked members with an encircling coefficient that descends linearly over the budget strengths the descending coefficient shifts the search from exploration to exploitation with no per-instance tuning
`guided-local-search`	metaheuristic	makespan, energy, cost	Inspect caveats the (position, task) feature and duration cost are a documented adaptation of the paper's routing-edge feature model evidence class runnable-baseline feature a (position, task) placement whose cost is the task duration mechanism penalty-guided local search that augments the objective with penalties on overused placement features neighborhood best-improvement pairwise swaps on the augmented objective penalty update the maximum-utility placement (cost over one-plus-penalty) is penalized at each local optimum strengths escapes local optima by discouraging the features a stuck optimum keeps reusing, without restarts
`gurobi-exact`	exact	makespan, energy, cost	Inspect commercial true dependency gurobipy dependency extra exact-commercial dependency purpose commercial mixed-integer programming wrapper dependency requirement optional exact method milp license note Gurobi requires a commercial license; a free academic license is available. Never bundled. optimality verification solves-to-optimal-verified
`harris-hawks-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats the besiege moves replace positions unconditionally, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Ali, A., Shah, S. A. A., Al Shloul, T., Assam, M., Ghadi, Y. Y., Lim, S., & Zia, A. (2024). Multiobjective Harris Hawks Optimization-Based Task Scheduling in Cloud-Fog Computing. IEEE Internet of Things Journal. doi:10.1109/JIOT.2024.3391024 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search whose decaying escaping-energy value switches between an exploration phase and four besiege moves around the best member, two of which compare a direct move against a Levy-flight move strengths the energy schedule interleaves exploration and several exploitation intensities without per-instance tuning
`heft`	dispatching	makespan, energy, cost	Inspect mechanism upward-rank list scheduling priority basis nonincreasing upward rank rank basis upward-rank realization rank-ordered dispatch; resource and mode binding by the serial constructor's earliest-finish rule, the non-insertion variant of the published insertion-based earliest-finish-time selection
`ibea`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats the pairwise indicator matrix is quadratic in the pool competitor ibea discrete adaptation Frutos, M., Mendez, M., Tohme, F., & Broz, D. (2013). Comparison of multiobjective evolutionary algorithms for operations scheduling under machine availability constraints. The Scientific World Journal, 2013, 418396. doi:10.1155/2013/418396 evidence class runnable-baseline indicator additive epsilon indicator on normalized objectives mechanism binary quality-indicator fitness with the additive epsilon indicator; the least-fit member is removed and the survivors are incrementally credited with its indicator contribution strengths a single tunable indicator drives convergence without reference points, weights, or nondominated sorting
`iterated-greedy-rs`	metaheuristic	makespan, energy, cost	Inspect acceptance fixed-temperature probabilistic acceptance of non-improving sequences caveats acceptance pressure tracks the problem's duration scale evidence class runnable-baseline mechanism destruction-reconstruction search from a best-insertion seed relates to iterated-greedy: the mechanism-diversified competitor realization strengths the canonical published iterated-greedy configuration for permutation scheduling temperature basis temperature_factor times mean task duration over ten, a documented adaptation of the published constant to the scalar-duration task model
`jaya-algorithm`	metaheuristic	makespan, energy, cost	Inspect caveats greedy replacement keeps only improving updates, so progress tracks the population's best and worst spread discrete adaptation Mishra, A. K., & Shrivastava, D. (2020). A discrete Jaya algorithm for permutation flow-shop scheduling problem. International Journal of Industrial Engineering Computations, 11(3), 415-428. doi:10.5267/j.ijiec.2019.12.001 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism parameter-less population search moving each priority vector toward the best and away from the worst member strengths carries no algorithm-specific parameters beyond population size and iteration budget
`l2d-disjunctive-gnn`	learning	makespan, energy, cost	Inspect documented adaptation faithful Graph Isomorphism Network over the disjunctive graph under the adding-arc strategy with the scheduled-indicator and completion-lower-bound raw features; single-instance training, a one-shot initial-state embedding with a greedy order decode instead of the reference per-step re-embedding, and a terminal normalized schedule-score reward adapt the published amortized size-agnostic dispatcher to the platform's per-instance task-order model evidence class runnable-baseline learned paradigm policy-gradient GNN construction (PPO) mechanism GIN disjunctive-graph + PPO dispatching rule optional extra learning policy basis graph-isomorphism network over the disjunctive graph with an average-pooled size-agnostic graph embedding training single-instance proximal policy optimization over seeded rollouts with a terminal normalized-improvement reward
`l2s-improvement`	learning	makespan, energy, cost	Inspect documented adaptation faithful DRL-guided improvement heuristic that starts from a complete feasible schedule, embeds its disjunctive graph with the topological and context-aware modules over the (p, est, lst) node features, and learns N5 critical-block moves by REINFORCE with the incumbent-improvement reward; the N5 neighborhood is realized over the platform's precedence-feasible task order as makespan-binding adjacent same-machine transpositions, and single-instance REINFORCE over a bounded improvement horizon adapts the published amortized training to the platform's per-instance task-order model evidence class runnable-baseline learned paradigm policy-gradient GNN improvement (REINFORCE) mechanism DRL-guided N5 improvement heuristic optional extra learning policy basis graph-neural network with a topological (GIN) module and a context-aware dual-context module over the complete-solution disjunctive graph, scoring N5 critical-block local-search moves training single-instance REINFORCE over the improvement rollout with the incumbent-improvement reward, keeping the best order found
`learned-priority-policy`	learning	makespan, energy, cost	Inspect learned tier disclosure two distinct learned representatives -- this policy-gradient priority rule and the value-based tabular Q-learning agent (rl-dispatching); no post-Decima DRL scheduler has consensus-baseline adoption mechanism policy-gradient learned priority dispatching rule policy basis linear priority over task features training REINFORCE over seeded precedence-feasible rollouts
`logic-based-benders-decomposition`	exact	makespan, energy, cost	Inspect commercial false dependency pulp dependency extra exact dependency purpose logic-based Benders assignment-master ILP adapter dependency requirement optional exact method logic-based-benders license note PuLP is BSD-licensed and ships the CBC open backend; the assignment master is solved through it and the per-facility scheduling subproblem is native pure Python. optimality verification solves-to-optimal-verified
`longest-processing-time`	dispatching	makespan, energy, cost	Inspect dispatch rule longest-processing-time priority basis longest duration first
`lshade`	metaheuristic	makespan, energy, cost	Inspect decode rule random-key encoded solver lshade encoding adapter random-key repair policy topological-normalize transfer identity
`marine-predators`	metaheuristic	makespan, energy, cost	Inspect caveats each iteration costs two schedule evaluations per member (the forage move and the FADs escape) discrete adaptation Chen, D., & Zhang, Y. (2023). Diversity-Aware Marine Predators Algorithm for Task Scheduling in Cloud Computing. Entropy, 25(2), 285. doi:10.3390/e25020285 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search that forages toward the best member by a Brownian phase early, a mixed Brownian/Levy phase in the middle, and a Levy phase late, escaping local optima with a fish-aggregating-device perturbation and keeping only improving moves strengths the phased Brownian-to-Levy schedule plus memory saving gives a monotone incumbent with a strong late-run local search
`matheuristic-restricted-neighbourhood`	metaheuristic	makespan	Inspect activity selection network-dependent: rank by the progressive/regressive-level body rule and select 50% of the activities for intense search envelope classical RCPSP only: finish-start precedence with no lag, renewable resources, single minimise-makespan objective; fails closed on generalized precedence, non-makespan or maximize objectives, and moldable, gang, or partial-execution tasks evidence class runnable-baseline exact neighbourhood the selected subproblem is solved by the native immediate-selection branch-and-bound (Brucker et al. 1998) over the pinned sub-instance future work the paper's higher-performance decomposition genetic-algorithm variant (Section 3.2.3) is not implemented; the faithful greedy-search form is realised instead mechanism greedy-search matheuristic: random-key sampling generates start schedules and an exact branch-and-bound re-optimises a selected activity body as a restricted neighbourhood search never worse the neighbourhood search accepts only improvements over the start schedule, so the result never regresses below the best sampled start schedule; near-optimal, not exact restriction full forward: the non-selected activities are pinned at their current start times as a latest-start bound and the selected subproblem is searched exactly without further truncation
`max-min`	dispatching	makespan, energy, cost	Inspect degenerate when tasks pin all resources through demands mechanism ready-set batch mapping by largest best completion priority basis largest minimum completion next realization the precedence-ready set stands in for the published independent-task batch; candidate and committed bindings follow the serial constructor's earliest-finish rule
`min-min`	dispatching	makespan, energy, cost	Inspect degenerate when tasks pin all resources through demands mechanism ready-set batch mapping by smallest best completion priority basis earliest minimum completion next realization the precedence-ready set stands in for the published independent-task batch; candidate and committed bindings follow the serial constructor's earliest-finish rule
`minimum-slack`	dispatching	makespan, energy, cost	Inspect dispatch rule minimum-slack priority basis least slack first
`moead`	metaheuristic	makespan, lateness, fairness, energy, cost	Inspect caveats weight-grid resolution bounds attainable spread evidence class runnable-baseline mechanism weighted-decomposition subproblems with neighborhood replacement strengths decomposition-based counterweight to dominance-based selection
`monte-carlo-tree-search`	metaheuristic	makespan, energy, cost	Inspect caveats the running best/worst reward normalization is a documented adaptation of UCB1's bounded-reward assumption evidence class runnable-baseline mechanism upper-confidence-bounds-for-trees search that builds a schedule by appending precedence-ready tasks reward the constructed order's score is normalized to [0, 1] against the running best and worst scores for UCB1 rollout partial orders are completed by appending uniformly random precedence-ready tasks selection UCB1 balances the best mean reward against the least-visited child by the exploration constant strengths concentrates simulations on the construction prefixes that have yielded the best schedules
`moth-flame-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats the flame memory guarantees monotone best positions, but each member's spiral is unconditional discrete adaptation Abd Elaziz, M., Abualigah, L., & Attiya, I. (2021). Advanced optimization technique for scheduling IoT tasks in cloud-fog computing environments. Future Generation Computer Systems, 124, 142-154. doi:10.1016/j.future.2021.05.026 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search spiralling every member around one of the best positions in a sorted memory whose size shrinks over the budget, keeping the best positions after each spiral strengths the shrinking flame memory retains several elite positions early and converges onto the best late, with no tuning
`ndso-core`	ndso	makespan, energy, cost	Inspect anytime convergence false coupled rate temperature true decayed cell reinjection true encoding natively-discrete method variant ndso-core peer guidance true positional preference model true preference weighted plurality true source selection schedule true three source guidance true update magnitude schedule true
`ndso-fast`	ndso	makespan, energy, cost	Inspect anytime convergence true coupled rate temperature true decayed cell reinjection false encoding natively-discrete method variant ndso-fast peer guidance true positional preference model true preference weighted plurality false source selection schedule true three source guidance false update magnitude schedule true
`ndso-summit`	ndso	makespan, energy, cost	Inspect coordination inter-swarm-council cross swarm confidence weighted voting true encoding natively-discrete method variant ndso-summit overarching elite synthesis true
`neh`	constructive	makespan, energy, cost	Inspect mechanism nonincreasing-duration best-insertion construction priority basis nonincreasing-duration insertion
`nsga2`	metaheuristic	makespan, lateness, fairness, energy, cost	Inspect caveats diversity pressure weakens beyond three objectives evidence class runnable-baseline mechanism nondominated sorting with crowding-distance elitism strengths the default bi/tri-objective baseline in scheduling comparisons
`nsga3`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats reference-point count grows with objective dimension competitor nsga3 evidence class runnable-baseline mechanism reference-point niching over nondominated fronts reference point design Das-Dennis structured simplex strengths diversity preservation in many-objective spaces
`ortools-cp-sat`	exact	makespan, energy, cost	Inspect commercial false dependency ortools dependency extra exact dependency purpose exact constraint-programming adapter dependency requirement optional exact method cp-sat license note OR-Tools is Apache-2.0 licensed; no commercial terms. optimality verification solves-to-optimal-verified
`particle-swarm`	metaheuristic	makespan, energy, cost	Inspect mechanism single-task attraction toward the global-best order metaheuristic particle-swarm realization no velocity state or personal-best memory is implemented; the citation marks lineage, not mechanism fidelity scheduling contract permutation-decode-to-schedule
`peft`	dispatching	makespan, energy, cost	Inspect mechanism optimistic-cost-table rank list scheduling priority basis nonincreasing mean optimistic cost rank basis oct-rank realization rank-ordered dispatch; resource and mode binding by the serial constructor's earliest-finish rule, a documented variant of the published O_EFT selection
`pulp-milp`	exact	makespan, energy, cost	Inspect commercial false dependency pulp dependency extra exact dependency purpose mixed-integer linear programming adapter dependency requirement optional exact method milp license note PuLP is BSD-licensed and ships the CBC open backend. optimality verification solves-to-optimal-verified
`residual-scheduling`	learning	makespan, energy, cost	Inspect documented adaptation faithful residual (shrinking, re-embedded) HGIN over unfinished operations; single-instance training, greedy order decode, terminal-objective reward with a running-mean baseline, hidden width reduced 256->128, and uniform per-machine durations adapt the published amortized job-shop scheduler to the platform's per-instance task-order model evidence class runnable-baseline learned paradigm policy-gradient GNN construction (REINFORCE, residual state) mechanism residual heterogeneous-GIN + REINFORCE construction scheduler optional extra learning policy basis residual heterogeneous-GIN over unfinished operations training single-instance REINFORCE over seeded rollouts with a terminal normalized-improvement reward and a running-mean baseline
`rl-dispatching`	learning	makespan, energy, cost	Inspect evidence class runnable-baseline learned paradigm value-based (tabular Q-learning) mechanism tabular Q-learning over dispatching-rule actions policy basis tabular action-value over dispatch rules relates to learned-priority-policy: the policy-gradient learned representative; this is the value-based Q-learning representative state abstraction coarse (scheduling-stage, ready-set-breadth) discretization, a documented adaptation of the published shop-state features training one-step Q-learning with a terminal normalized-improvement reward over seeded epsilon-greedy episodes
`rollout`	constructive	makespan, energy, cost	Inspect base policy shortest-processing-time static-priority completion budget a wall-clock budget degrades the lookahead to the bare base-policy completion of the committed prefix caveats cost grows with the base-policy completions scored, quadratic in the task count evidence class runnable-baseline guarantee the sequentially-consistent base policy makes the rollout order score no worse than the base policy it improves mechanism one-step base-policy lookahead sequential construction relates to shortest-processing-time: the base policy this rollout improves strengths recovers order quality a one-pass dispatch rule leaves on the table by scoring a full completion per ready candidate
`rvea`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats reference-vector count grows with objective dimension competitor rvea evidence class runnable-baseline mechanism angle-penalized-distance selection over reference vectors reference vector design unit-normalized Das-Dennis simplex strengths convergence-diversity balance that sharpens over the run
`salp-swarm`	metaheuristic	makespan, energy, cost	Inspect caveats positions move unconditionally each iteration, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Jain, R., & Sharma, N. (2022). A Deadline-Constrained Time-Cost-Effective Salp Swarm Algorithm for Resource Optimization in Cloud Computing. International Journal of Applied Metaheuristic Computing, 13(1). doi:10.4018/IJAMC.292509 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous chain search whose leader is drawn toward the best-so-far food source by a coefficient that decays over the budget, and whose followers each move to the mean of their own and their predecessor's position strengths the follower averaging smooths the chain toward the leader while the decaying coefficient sharpens the leader's search
`sarsa-dispatching`	learning	makespan, energy, cost	Inspect discrete adaptation Aissani, N., Beldjilali, B., & Trentesaux, D. (2009). Dynamic scheduling of maintenance tasks in the petroleum industry: a reinforcement approach. Engineering Applications of Artificial Intelligence, 22(7), 1089-1103. doi:10.1016/j.engappai.2009.01.014; Zhang, Z., Zheng, L., Hou, F., & Li, N. (2011). Semiconductor final test scheduling with Sarsa(lambda, k) algorithm. European Journal of Operational Research, 215(2), 446-458. doi:10.1016/j.ejor.2011.05.052 evidence class runnable-baseline learned paradigm value-based on-policy TD control (SARSA) mechanism tabular on-policy SARSA over dispatching-rule actions policy basis tabular action-value over dispatch rules relates to rl-dispatching: the off-policy Q-learning representative; this is the on-policy SARSA representative training on-policy SARSA that bootstraps toward the next selected action-value, with a terminal normalized-improvement reward over seeded epsilon-greedy episodes
`scatter-search`	metaheuristic	makespan, energy, cost	Inspect caveats path relinking is precedence-repaired over the order space, a documented adaptation of the published combination method combination path relinking between the two reference orders of each subset competitor scatter-search evidence class runnable-baseline mechanism reference-set path-relinking search over precedence-safe orders realizes the elite-solution path relinking left unrealized in critical-path-tabu reference set a best-scoring quality subset plus a max-min positional-distance diversity subset strengths systematic recombination of diverse high-quality task orders
`selection-hyper-heuristic`	metaheuristic	makespan, energy, cost	Inspect acceptance late-acceptance hill-climbing against the cost recorded a fixed number of steps earlier evidence class runnable-baseline low level heuristics adjacent-swap, insertion-shift, relink-to-incumbent, bounded-local-search mechanism two-layer selection hyper-heuristic: adaptive heuristic selection over a fixed low-level heuristic set with a separate move-acceptance criterion relates to distinct from ccgp, a generation hyper-heuristic that evolves priority-rule trees rather than selecting among fixed low-level heuristics scheduling contract permutation-decode-to-schedule selection reinforcement-style adaptive credit; improving moves reward the applied heuristic, non-improving moves penalize it, with roulette-wheel proportional selection
`serial-sgs-justification`	constructive	makespan, energy, cost	Inspect caveats single-pass constructor; no search beyond the justification re-decodes; on unit-capacity (or demand-equals-capacity) problems the cumulative decode reduces to the scalar exclusive timeline citation doi pending verified publisher landing link recorded as the uri; the DOI digits are unverified and await operator confirmation evidence class runnable-baseline mechanism latest-finish-time serial construction with double justification, decoded through the cumulative capacity-profile placement so a resource packs concurrent activities up to its capacity realization double justification realized as finish- and start-sorted re-decodes through the serial constructor, a documented order-space adaptation of the published schedule-space shifts strengths justification improves serial-decoder schedules at the cost of only two extra decodes; the cumulative decode honors the capacity-aware capability on resources carrying demand below capacity
`shifting-bottleneck`	constructive	makespan, energy, cost	Inspect caveats heads and tails are longest-path bounds treating dependency lags as finish-to-start offsets; the serial constructor honors the exact timing evidence class runnable-baseline machine identity a distinct resource-demand set; demand-free tasks share a pool machine mechanism machine decomposition sequencing the bottleneck machine first reoptimization committed machines re-sequenced while later commitments tighten their release dates and tails strengths critical-path decomposition that resolves the most constraining resource before the rest subproblem single-machine release-date relaxation solved by Schrage's rule
`shortest-processing-time`	dispatching	makespan, energy, cost	Inspect dispatch rule shortest-processing-time priority basis shortest duration first
`simulated-annealing`	metaheuristic	makespan, energy, cost	Inspect mechanism adjacent-swap neighborhood under Metropolis acceptance metaheuristic simulated-annealing realization single-chain anneal, temperature cooling linearly to a 0.01 floor; faithful in kind to the cited scheme scheduling contract permutation-decode-to-schedule
`sine-cosine-algorithm`	metaheuristic	makespan, energy, cost	Inspect caveats positions move unconditionally each iteration, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Jouhari, H., Lei, D., Al-qaness, M. A. A., Abd Elaziz, M., Ewees, A. A., & Farouk, O. (2019). Sine-Cosine Algorithm to Enhance Simulated Annealing for Unrelated Parallel Machine Scheduling with Setup Times. Mathematics, 7(11), 1120. doi:10.3390/math7111120 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search nudging every priority vector toward the best-so-far destination by a sine- or cosine-weighted step whose amplitude descends linearly over the budget strengths the oscillating step spans a wide region early and collapses onto the destination late with no per-instance tuning
`slim-self-labeling`	learning	makespan, energy, cost	Inspect documented adaptation faithful Pointer-Network-style encoder-decoder generative model trained by the self-labeling cross-entropy over the best sampled pseudo-label with neither an MDP nor reinforcement learning; the fifteen graph-node and eleven job-context features collapse to the platform-derivable subset, and single-instance self-labeling over a bounded step budget with a greedy decode adapts the published dataset-scale amortized training to the platform's per-instance task-order model evidence class runnable-baseline learned paradigm self-supervised generative construction mechanism pointer-network generative model + self-labeling optional extra learning policy basis pointer-network-style encoder-decoder generative model over the disjunctive graph with a multi-head-attention memory network training single-instance self-labeling: sample solutions, adopt the minimum-makespan sample as a pseudo-label, and minimize the cross-entropy toward it, using no reward or Markov Decision Process
`sms-emoa`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats hypervolume cost grows with the objective count competitor sms-emoa evidence class runnable-baseline indicator exact dominated hypervolume via objective slicing mechanism dominated-hypervolume (S-metric) survival selection strengths reference-free spread and convergence balance
`spea2`	metaheuristic	makespan, lateness, fairness, energy, cost, carbon	Inspect caveats the pairwise distance matrix is quadratic in the pool competitor spea2 density k-th nearest neighbour with k = floor(sqrt N) discrete adaptation Wei, Feng, Tan, and Hagiwara. Flexible job shop scheduling multi-objective optimization based on an improved strength Pareto evolutionary algorithm. Advanced Materials Research, 186, 546-551, 2011. doi:10.4028/www.scientific.net/AMR.186.546 evidence class runnable-baseline mechanism strength-and-raw-fitness ranking with a k-th nearest-neighbour density estimator and distance-based archive truncation strengths the density estimator preserves a well-spread archive without reference points or scalarizing weights
`squeaky-wheel`	metaheuristic	makespan, energy, cost	Inspect analyzer blame equals the task completion time read from the constructed schedule assignments caveats the completion-time blame is a documented adaptation of the paper's domain-specific trouble measure evidence class runnable-baseline initialization duration-normalized prior with a seeded uniform perturbation of the starting priority ordering mechanism construct/analyze/prioritize search over a per-task priority vector that induces the construction sequence prioritizer blamed tasks' priorities rise by bump_strength times their makespan-normalized blame, pulling late tasks earlier strengths reprioritizes around the tasks that finish latest rather than searching the order space blindly
`sufferage`	dispatching	makespan, energy, cost	Inspect degenerate when tasks pin all resources through demands mechanism ready-set batch mapping by completion-loss gap priority basis largest second-best-minus-best completion gap next realization the precedence-ready set stands in for the published independent-task batch; candidate and committed bindings follow the serial constructor's earliest-finish rule
`surrogate-assisted-gp-hh`	learning	makespan, energy, cost	Inspect documented adaptation single static instance -> derived related tasks (makespan, lateness-weighted, flow-weighted scorings); 1-NN phenotypic-characterisation surrogate over ready-set reference situations; bounded population and generations for single-instance latency evidence class runnable-baseline extends ccgp learned paradigm genetic-programming hyper-heuristic (surrogate multitask) mechanism surrogate-assisted multitask GP hyper-heuristic policy basis evolved priority-rule trees decoded by precedence-safe list scheduling relates to ccgp: the cooperative-coevolution GP hyper-heuristic this surrogate multitask method extends training each generation a per-task 1-NN phenotypic-characterisation surrogate screens the merged offspring pool; only the reallocated survivors are really evaluated
`tabu-mrcpsp-mode-search`	metaheuristic	makespan, energy, cost	Inspect adaptation operates on the renewable-only, finish-start projection: the paper's generalized precedence relations (max lags, SF/FF), non-renewable and doubly constrained resources, and its inefficient-mode preprocessing are outside the core model and are projected away, not fabricated aspiration asymmetric: global and regional aspiration by objective override tabu status; influence always tilts move selection evidence class runnable-baseline inner scheduler a fixed mode assignment is projected onto the problem (each activity pinned to one mode) and decoded by the shared serial constructor, standing in for the paper's truncated RCPSP-GPR branch-and-bound long term memory frequency-based diversification and intensification phase switching after an initial data-collection phase mechanism tabu search over the mode-assignment neighborhood: each move reassigns one activity to another execution mode neighborhood single-activity re-mode -- all assignments differing from the incumbent in exactly one activity's mode tabu list dynamic random tenure in [sqrt(n), 3*sqrt(n)] on the reversing (activity, mode) attribute
`teaching-learning-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats greedy replacement keeps only improving updates, so progress tracks the population's best member and mean discrete adaptation Xie, Z., Zhang, C., Shao, X., Lin, W., & Zhu, H. (2014). An effective hybrid teaching-learning-based optimization algorithm for permutation flow shop scheduling problem. Advances in Engineering Software, 77, 35-47. doi:10.1016/j.advengsoft.2014.07.006 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism parameter-less two-phase population search: a teacher phase draws every learner toward the best member and away from the population mean, and a learner phase draws it toward or away from a random peer by which is better strengths carries no algorithm-specific parameters beyond population size and iteration budget
`whale-optimization`	metaheuristic	makespan, energy, cost	Inspect caveats positions move unconditionally each iteration, so the returned order is the best observed rather than a monotone incumbent discrete adaptation Zhang, S., & Gu, X. (2023). A discrete whale optimization algorithm for the no-wait flow shop scheduling problem. Measurement and Control. doi:10.1177/00202940231180622 encoding continuous priority vector decoded to a permutation by the Largest Order Value rule, then precedence-repaired evidence class runnable-baseline mechanism continuous population search choosing per iteration a spiral move around the best member, an encircling move toward it, or a search move toward a random member, under a control value that descends linearly over the budget strengths the spiral and search moves preserve exploration while the descending control value sharpens exploitation, with no per-instance tuning

All objective support is declared registry metadata, not a performance claim. The solver recommender ranks these solvers by declared fit.

솔버 적용 가능성

어떤 솔버가 어떤 벤치마크 계열에 적용되는지를 적용 가능성 행렬에서 읽어옵니다. 각 셀은 선언된 적용 가능성이며 성능 주장이 아닙니다. 검증된 셀은 명명된 공개 캠페인, 인용 또는 테스트를 인용하고, 근사 셀은 선언된 솔버 역량과 벤치마크 계열 특성에서 도출됩니다. 아래 표는 공개 적용 가능성 번들에서 생성되므로 상태 합계는 행 자체에서 셀 수 있습니다.

Generated from the applicability matrix: 69 benchmark families by 87 public solvers. 10 verified · 5835 approximate · 158 not applicable.

Cell status is declared applicability, never a performance claim. Verified cells cite a named public campaign artifact, citation source, or test; approximate cells are derived from declared solver capabilities and benchmark-family traits and are labeled as such.

SearchBenchmark familySolverStatus

Showing 6003 of 6003 cells.

Benchmark-family by solver applicability — 6003 matching rows, showing page 1 of 121; build-inlined from the public applicability bundle.
			Basis
`accelerator-coscheduling`distributed-computing	`adpso`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the random-key-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`age-moea-ii`	Approximate	family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`ant-colony`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`apparent-tardiness-cost`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`arithmetic-optimization`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`artificial-bee-colony`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`artificial-fish-swarm`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`beam-search`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`branch-and-bound`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`ccgp`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`clpso`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the random-key-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`cma-es`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`cpop`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`critical-path-tabu`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`cuckoo-search`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`d-clpso`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the spv-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`d-depso`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`d-lshade`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the rounding-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`dan-dual-attention`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`decima-dag-rl`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`decision-diagram-sequencing`	Not applicable	native exact search caps at 12 tasks; family instances carry 96; optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`differential-evolution`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`earliest-deadline`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`earliest-finish-time`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`earliest-start`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`epso`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the random-key-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`exhaustive-enumeration`	Not applicable	native exact search caps at 8 tasks; family instances carry 96; optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`firefly-algorithm`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`fjsp-hgnn-drl`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`genetic-algorithm`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`grasshopper-optimization`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`gravitational-search`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`greedy-completion`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`grey-wolf-optimizer`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`guided-local-search`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`gurobi-exact`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`harris-hawks-optimization`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`heft`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`ibea`	Approximate	family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`iterated-greedy-rs`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`jaya-algorithm`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`l2d-disjunctive-gnn`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`l2s-improvement`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`learned-priority-policy`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`logic-based-benders-decomposition`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`longest-processing-time`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.
`accelerator-coscheduling`distributed-computing	`lshade`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; searches a continuous space decoded via the random-key-adapter with topological repair.
`accelerator-coscheduling`distributed-computing	`marine-predators`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling.
`accelerator-coscheduling`distributed-computing	`matheuristic-restricted-neighbourhood`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity; produces a static schedule for a family with dynamic arrivals/rescheduling; no repair or dispatching mechanism for the family's declared uncertainty.
`accelerator-coscheduling`distributed-computing	`max-min`	Approximate	optimizes one objective axis of a multi-objective family; family declares constraint features with no capability-tag counterpart: affinity.

Cell status is declared applicability, never a performance claim. Verified cells cite a named public campaign, citation, or test; approximate cells are derived from declared solver capabilities and benchmark-family traits. The solver recommender scores solvers against this matrix by scheduling family.

디스패칭 베이스라인

번들된 결정론적 베이스라인은 구성적 리스트-스케줄링 솔버입니다. 각각이 태스크 순서를 제어합니다; 직렬 생성자는 각 태스크의 선언된 자원 수요를 존중하고 각 태스크를 그 가장-일찍-가용한 수요 자원에 배정합니다. 각 패밀리는 그 정준적 효시 참조를 명명합니다.

Solver	우선순위 기준	정준 참조
`earliest-start`	위상 입력 순서	비해당 (항등 베이스라인)
`shortest-processing-time`	최단 태스크 시간 우선	Smith (1956)
`longest-processing-time`	최장 태스크 시간 우선	Graham (1969)
`earliest-deadline`	가장 이른 deadline 우선 (deadline-인지)	Jackson (1955)
`earliest-finish-time`	가장 이른 도달가능 완료 우선	Topcuoglu et al. (2002)
`minimum-slack`	최소 스케줄 여유 우선	Conway, Maxwell & Miller (1967)
`greedy-completion`	가장 이른 상태-인지 완료 우선	Graham (1966)
`apparent-tardiness-cost`	최고 겉보기-지연-비용 지수 우선 (deadline-인지)	Vepsalainen & Morton (1987)

퇴역한 디스패칭 패밀리

자원-매핑 패밀리는 일반 종으로 조용히 접히는 대신 명시적으로 기록됩니다. 그것들은 자원 배정을 제어하며, 태스크 순서가 아니고, 수요-존중 직렬 생성자는 현재 코어 문제 모델 하에서 어떤 자유 매핑 결정도 노출하지 않습니다:

자원 매핑 (olb, met, mct, round-robin, load-balanced): 생성자는 각 태스크를 그 선언된 자원에 배정하므로, 이 휴리스틱들은 실현 가능한 자유도가 없습니다; 실행-시간-인지 매핑은 이 기반이 아니라 목적과 제약 작업의 소유입니다.
타입 태그 부재 (type-aware, domain-aware): 현재 코어 문제 모델이 지니지 않는 태스크-타입과 자원-타입 태그를 요합니다.

retired_dispatching_families()는 패밀리-별 근거와 인용을 가진 완전한 원장을 반환합니다.

순위-기반 리스트 스케줄러

세 이질성-인지 리스트 스케줄러는 이-단계 형태를 공유합니다: 정적 우선순위화 단계는 평균 실행 시간과 통신 비용으로부터 선행 DAG 위 모든 태스크를 순위화하고, 프로세서-선택 단계는 직렬 생성자의 가장-이른-완료 규칙을 통해 각 태스크를 우선순위 순으로 결속합니다. 자원-별 실행 시간은 가변형 태스크의 선언된 실행 모드에서 오며, 고정형 태스크는 문서화된 동질 특수화로 퇴화합니다.

Solver	우선순위 기준	정준 참조
`heft`	상향 순위	Topcuoglu, Hariri & Wu (2002)
`cpop`	결합 상향-더하기-하향 순위, 임계-경로 태스크 우선	Topcuoglu, Hariri & Wu (2002)
`peft`	낙관적-비용-표 순위	Arabnejad & Barbosa (2014)

준비-집합 매핑 규칙

세 배치 매핑 규칙은 모든 선행-준비 태스크를 그 후보 결속에 걸친 가장 이른 완료로 채점한 다음, 단계당 하나의 태스크를 매핑합니다. 발표된 규칙은 독립 태스크의 배치를 매핑합니다; 여기서 배치는 선행-준비 집합이므로, 규칙은 의존 작업부하로 확장되고 독립-태스크 인스턴스에서 발표된 동작으로 환원됩니다. 이 패밀리들은 가변형 TaskSpec.modes가 그 기계-별 기대-완료 행렬을 표현 가능하게 만들자 일급 등록을 위해 퇴역 원장을 떠났습니다.

Solver	우선순위 기준	정준 참조
`min-min`	가장 작은 최선 완료 우선	Ibarra & Kim (1977); Braun et al. (2001)
`max-min`	가장 큰 최선 완료 우선	Ibarra & Kim (1977); Braun et al. (2001)
`sufferage`	가장 큰 차선-빼기-최선 완료 격차 우선	Maheswaran et al. (1999)

반복-탐욕, 타부, 그리고 RCPSP 베이스라인

세 발표된 단일-해 방법은 선행-안전한 태스크-순서 공간을 탐색하며, 각각 그 정준 메커니즘을 공유된 순서-실행 이음매에 투영합니다. serial-sgs-justification은 플랫폼의 첫 자원-제약 프로젝트-스케줄링(RCPSP) 솔버입니다.

Solver	메커니즘	정준 참조
`iterated-greedy-rs`	파괴-재구성 루프와 고정-온도 수용을 동반한 NEH 시드	Ruiz & Stutzle (2007)
`critical-path-tabu`	임계-경로 블록 이동 위의 고급 타부 탐색	Nowicki & Smutnicki (2005)
`serial-sgs-justification`	이중 우측-그다음-좌측 정렬을 동반한 직렬 스케줄-생성-스킴 디코드	Valls, Ballestin & Quintanilla (2005)

메타휴리스틱 베이스라인

대표적인 시드된 메타휴리스틱 베이스라인은 동일한 가능성, 수리, 채점, 그리고 국소-탐색 연산자를, 각각 그 정준 참조와 함께 공유합니다: 유전 알고리즘 (Holland 1975), 시뮬레이티드 어닐링 (Kirkpatrick et al. 1983), 개미 군집 (Dorigo, Maniezzo & Colorni 1996), 입자 군집 (Kennedy & Eberhart 1995), 그리고 차분 진화 (Storn & Price 1997).

인코딩된 어댑터 솔버

포괄 학습 입자 군집 최적화와 성공-이력 적응 차분 진화는 태스크당 하나의 성분을 가진 연속 실-값 벡터를 탐색합니다. 각 코어는 연속 목적에 대해 일반적이므로, 그 수렴 동작은 연속 벤치마크에서 직접 검증되며, 벡터를 선행-가능 태스크 순서로 디코딩하는 인코딩 어댑터를 통해 스케줄링 문제에 결속됩니다.

Solver	영감	적응	인코딩
`clpso`	포괄 학습 입자 군집 (Liang et al. 2006)	선행 순서로 디코딩된 연속 군집	random-key
`d-clpso`	포괄 학습 입자 군집 (Liang et al. 2006)	최소-위치-값 디코드 위의 이산 어댑터	spv
`lshade`	선형 개체군 감소를 동반한 성공-이력 적응 DE (Tanabe & Fukunaga 2014)	선행 순서로 디코딩된 연속 차분 진화	random-key
`d-lshade`	선형 개체군 감소를 동반한 성공-이력 적응 DE (Tanabe & Fukunaga 2014)	정수-순위 반올림 위의 이산 어댑터	rounding

CLPSO는 단일 전역-최선이 아니라 포괄-학습 본보기로부터 각 차원을 학습하므로, 군집의 최선 적합도는 단봉 분지에서 단조롭게 개선됩니다. L-SHADE는 그 성공 이력으로부터 교차와 스케일-인자 기억을 적응시키고 개체군을 최소 네 개체까지 선형으로 축소합니다. 둘 다 수렴 궤적을 보고하며, 수렴-정확성 테스트는 관측된 궤적이 발표된 참조 동작과 모순될 때, 시드-재현성 검사와 별개로 실패합니다.

이 솔버들은 인코딩 다리를 통해 이산 영역에 적응된 연속 최적화기입니다; 그것들은 어떤 선행 코드의 정확한 재구현도 아니며, 비교 캠페인이 돌기 전에는 어떤 성능 주장도 하지 않습니다.

인코딩 어댑터

각 명명된 연속-에서-이산 인코딩은 명시적 수리 정책을 가진 별개의 어댑터이므로, 어떤 인코딩도 일반 디코더로 조용히 접히지 않습니다. 각 어댑터는 그 디코딩된 순서를 선행-가능 순서로 수리하고 수리가 발화했는지 기록합니다.

어댑터	전달	디코드 규칙	인용 상태
`random-key`	항등	클램프된 키로 정렬	정준 (Bean 1994)
`spv`	항등	최소 위치 값	정준 (Tasgetiren et al. 2007)
`rounding`	항등	정수 순위 슬롯	비해당
`sigmoid`	S-형 시그모이드	가중 확률 추출	정준 (Kennedy & Eberhart 1997)
`v-shaped`	V-형 크기	가중 확률 추출	정준 (Mirjalili & Lewis 2013)
`tanh`	이동된 쌍곡 탄젠트	가중 확률 추출	정준 (Mirjalili & Lewis 2013)

결정론적 디코드(random-key, spv, rounding)는 난수 원천을 무시합니다; 전달-함수 디코드는 시드된 원천을 소비하고 고정 시드 하에서 재생합니다. rounding 어댑터는 인용-비해당을 기록합니다. 최근접-정수 순위 반올림은 단일 정준적 효시 기원이 없는 일반 이산화이기 때문입니다.

다양화된 경쟁자 집합

다양화된 경쟁자 집합은 각각 그 전문 참조를 순서-만 결정 공간에 투영한 명명된 솔버인 소수의 최근 강력한 동료로, 대표 베이스라인을 넘어 비교를 넓힙니다. 부피 큰 고전 베이스라인 명단이 아니라. 동료는 장소-강도 바를 넘을 때만 공개 경기장에 머뭅니다: 후-2020 시의성 창 안에서 색인된, 동료-심사 장소에 발표되고, 독자가 명성이 아니라 증거로 그것을 가중하도록 장소 등급이 기록됩니다.

Solver	메커니즘	장소	인용
`epso`	경로 수집을 동반한 작업부하-편향-초기화 군집	Electronics (MDPI), 2023 — 색인됨	Anbarkhan & Rakrouki (2023)
`adpso`	성공-적응 하강 관성을 동반한 군집 탐색	Sensors (MDPI), 2022 — 색인됨	Nabi et al. (2022)
`ccgp`	우선순위-규칙 트리의 협력적 공진화	Computers & Operations Research (Elsevier), 2024 — 최상위 OR	Zaki et al. (2024)

각 동료는 강점, 유의점, 그리고 실행가능-베이스라인 증거 클래스를 그 메타데이터에 지니므로, 추천기는 솔버가 어떤 맥락에 왜 들어맞는지 설명할 수 있습니다. 더 넓은 고전 베이스라인 집합 — 정수-키, 편향-난수-키, 그리고 분포-추정 유전 알고리즘, 그리고 큰-이웃, 반복-탐욕, 타부, 가변-이웃, 그리고 미메틱 탐색 — 은 내부 비교를 위해 등록된 채로 있지만, 대표 휴리스틱이 이미 그 메커니즘 신호를 지니므로 공개 경기장 밖에 유지됩니다. 비교 캠페인이 돌기 전에는 어떤 성능 주장도 하지 않습니다.

시의성 앵커

경쟁자와 관련-작업 집합은 후-2020 시의성 앵커를 통해 현-십년 작업에 대해 위치 지어집니다: Karimi-Mamaghan, Mohammadi, Pasdeloup, 그리고 Meyer (2023, 순열 플로우샵을 위해 반복 탐욕에 통합된 Q-learning을 통해 연산자를 선택하는 것을 학습, European Journal of Operational Research 304(3):1296-1330, doi:10.1016/j.ejor.2022.03.054) 그리고 분산 플로우샵 그룹 스케줄링을 위한 2024 IEEE Transactions on Evolutionary Computation의 지표-구동 협력적 다-목적 진화 알고리즘 (doi:10.1109/TEVC.2023.3339558).

다중-목적 경쟁자

두 파레토 경쟁자는 선행-안전한 태스크 순서의 개체군을 다중-목적 벡터 위에서 진화시키며, 다-목적 nsga3 표면과 구별됩니다. nsga2는 지배-기반 경쟁자 — 혼잡-거리 동점-처리를 동반한 빠른 비지배 정렬 — 이고, moead는 분해-기반 평형추로, 문제를 구조화된 심플렉스 가중 격자를 따라 스칼라 Tchebycheff 부분문제로 분할하고 각 부분문제의 최근접-가중 이웃에 걸쳐 기존해를 교체합니다.

Solver	메커니즘	정준 참조
`nsga2`	지배-기반 파레토: 빠른 비지배 정렬, 혼잡 거리	Deb et al. (2002)
`moead`	분해-기반 파레토: 심플렉스 가중 격자 위의 Tchebycheff 스칼라화	Zhang & Li (2007)

다-목적 경쟁자

nsga3는 명명된 다-목적 경쟁자(Deb & Jain 2014, doi:10.1109/TEVC.2013.2281535)로, 이-목적 경쟁자 표면과 구별됩니다. 선행-안전한 태스크 순서 위에 개체군을 유지하고, 각 순서를 다-목적 벡터(makespan, 지연, 그리고 부하 공정성)에서 평가하며, 단위 심플렉스 위 Das & Dennis 구조화된 참조점에 대한 참조점-니칭 선택으로 각 세대를 생존시킵니다. 참조점 설계, 해를 그 최근접 참조 방향에 연관시키기, 그리고 니치-카운트 선택이 알고리즘 서명입니다; 솔버는 캠페인이 명시적으로 그것을 선택할 수 있도록 multi-objective와 함께 many-objective 능력을 선언합니다.

능력 매칭

SolverRegistry.select는 능력, 제약, 그리고 목적으로 솔버를 매칭합니다. 능력과 제약 요구사항은 둘 다 능력 태그로 표현되고 연언으로 매칭됩니다: deadline-인지도 필요한 다-목적 캠페인은 required_capabilities=(SolverCapability.MANY_OBJECTIVE,)와 required_constraints=(SolverCapability.DEADLINE_AWARE,)를 전달하고, 레지스트리는 둘 다 선언하는 솔버만 반환합니다. objective 필터는 결과를 그 명명된 목적 지원을 선언하는 솔버로 더욱 제한합니다.

NDSO 패밀리

NDSO 패밀리는 레지스트리의 원생-인코딩 솔버 패밀리입니다: 가능한 스케줄 위를 직접 탐색합니다. 그것이 생산하는 각 스케줄은 구성에 의해 가능하며(유효성-설계 생성자가 각 단계에서 선행-존중 순서를 구성), 따라서 패밀리는 native 인코딩을 지니고 인코딩/디코딩 단계나 수리 패스를 결코 돌리지 않습니다. 패밀리는 명명된 메커니즘의 작은 집합을 구성합니다:

신뢰 행렬 — 더 나은 스케줄이 그 셀을 강화함에 따라 갱신되는, (위치, 태스크) 셀별 학습된 신뢰의 희소 저장.
신뢰-가중 투표 — 신뢰 행렬로 가중된 개체군에 걸쳐 투표함으로써 엘리트 스케줄을 합성합니다; 빠른 변형은 대신 비-가중 다수 투표를 사용합니다.
수량-과-품질 스케줄 — 수량 스케줄은 후보가 얼마나 변하는지 설정합니다; 품질 스케줄은 그것이 어느 지침 원천에서 학습하는지 설정합니다.
삼-원천 지침 — 후보는 합성 엘리트(활용), 동료(다양성), 또는 소멸-지식 원천(급진적 탐험) 에서 학습합니다.
통합 적응 계수 — 하나의 비-선형 스케줄이 패밀리를 탐험에서 활용으로 이동시키고 민감도와 학습-초점 둘 다를 구동합니다; 빠른 변형은 그것을 고정 값으로 고정합니다.

변형	구성
`ndso-core`	신뢰-가중 투표, 적응 계수, 삼-원천 지침
`ndso-fast`	다수-투표 합성, 고정 계수, 단일 지침 원천
`ndso-summit`	총괄적 합성을 동반해 여러 군집을 조정하는 군집간-협의회

군집간-협의회

ndso-summit 변형은 품질 구성입니다: 여러 군집을 병렬로 돌리고 하나의 협의회를 통해 그것들을 조정합니다. 각 군집은 그 자신의 개체군 위에 코어 메커니즘을 구성합니다; 군집간-협의회는 그 군집들을 여러 고립된 실행이 아니라 하나의 탐색으로 작동하게 유지하고 그 결과를 단일 총괄적 엘리트 — 정상회의 전체가 지지하는 스케줄 — 로 합성합니다. 협의회는 한눈에 변형을 구별하는 것입니다: ndso-core와 ndso-fast는 각각 하나의 개체군으로 탐색하고, ndso-summit은 조정된 다-군집 탐색을 위해 구축된 구성입니다.

협의회의 조정 동작과 군집-별 진단은 구성 가능하며, 그것이 생산하는 각 스케줄은 구성에 의해 가능한 채로 있습니다.

절제 맵

절제 맵은 다운스트림 분석이 각 메커니즘의 기여를 귀속할 수 있도록, 명명된 메커니즘당 하나의 고립 구성을 열거합니다. 군집내 항목은 각각 하나의 코어 스위치 — 신뢰 행렬, 신뢰-가중 투표, 수량 스케줄, 품질 스케줄, 다-원천 지침 구조, 동료 원천, 소멸-지식 원천, 그리고 적응 계수 — 를 비활성화합니다. 조정 항목은 각각 하나의 협의회 매개변수 — 군집내- 대 군집간-조정, 그리고 총괄적 합성 — 를 비활성화합니다. 각 항목은 분석 계층이 그 비교를 샘플링하는 실행-카운트 하한을 선언하고 그 계층이 적용하는 통계 검정(쌍별 비-모수 유의성 검정, Holm 다중-비교 보정을 동반한 Friedman 평균-순위 사후 검정, 그리고 Cliff-delta 효과 크기)을 명명합니다. 샘플링된 비교는 다운스트림 실험 엔진에 의해 물질화됩니다; 프로세스 내 runner는 각 고립이 가능함을 증명합니다.

단계적 익스포트 필터는 보고 범위가 어느 메커니즘을 노출할 수 있는지 통치합니다: 기반 범위는 기반 메커니즘만 노출하고, fail-closed 게이트는 기반 범위 하에서 더-빠르거나 더 높은-품질 메커니즘을 누출하는 대신 올리므로, 기반 범위와 빠른 범위는 협의회-전용 메커니즘을 노출할 수 없습니다. 수렴 진단 — 개체군 다양성, 신뢰-행렬 엔트로피, 탐험 비율, 자원 부하, 타이밍, 그리고 개선 추적 — 은 선택적이며 비활성화 시 오버헤드를 더하지 않고, 협의회는 분석 계층이 어떤 솔버 타입도 임포트하지 않고 섭취하는 JSON 매니페스트를 익스포트합니다.

정확 어댑터

정확 어댑터는 두 형태 중 하나를 취합니다. 선택적-백엔드 어댑터는 선택적 의존성을 선언하고 런타임에 그 임포트 루트를 검사합니다; 백엔드가 부재하면, 패키지 임포트 중 중량급 의존성을 임포트하는 대신 extra 이름, 목적, 상용 플래그, 그리고 라이선싱 노트를 동반한 MissingOptionalDependencyError를 올립니다. 원생-유계 어댑터는 제3자 의존성을 지니지 않고 자신의 유계 탐색 — 한쪽은 선행-가능 순서의 열거, 다른 쪽은 결정-다이어그램 분기한정 — 으로 작은 인스턴스를 정확히 풀며, 인스턴스가 지원 태스크 카운트를 초과할 때 UnsupportedCapabilityError를 올립니다.

Solver	방법	백엔드	Extra	상용
`ortools-cp-sat`	CP-SAT	`ortools`	`exact`	아니오
`pulp-milp`	MILP / MIP	`pulp`	`exact`	아니오
`branch-and-bound`	branch-and-bound / cut	`ortools`	`exact`	아니오
`logic-based-benders-decomposition`	논리-기반 벤더스 분해	`pulp`	`exact`	아니오
`exhaustive-enumeration`	전수 열거	원생 (백엔드 없음)	—	아니오
`decision-diagram-sequencing`	결정-다이어그램 분기한정	원생 (백엔드 없음)	—	아니오
`gurobi-exact`	MILP / MIP	`gurobipy`	`exact-commercial`	예

공개 정확 한 줌은 대표 개방 집합 — CP-SAT, MILP, branch-and-bound, 그리고 논리-기반 벤더스 분해 — 에 두 원생 유계 솔버와 진정으로 호출하는 Gurobi 래퍼를 더한 것입니다. 상용 Gurobi 래퍼는 exact-commercial extra 뒤에 머물고, 결코 번들되지 않으며, 명시적 라이선싱 노트를 지닙니다; 학술 라이선스가 가용합니다. 더 넓은 선택적 백엔드 풀은 내부 사용을 위해 등록된 채로 있습니다.

선택과 학습 계층

선택 계층은 전역-최선 솔버를 결코 주장하지 않고 문제에 대해 솔버를 순위화합니다. 그것은 SelectionFeatures 레코드 — difficulty, heterogeneity, objective_conflict, uncertainty, dynamism, 그리고 solver_sensitivity — 와 공개 솔버 메타데이터를 소비하고, 순위화된 SolverRecommendation 행을 반환합니다. 각 추천은 RecommendationSource(metadata 또는 learned-model), ConfidenceLabel, 그리고 명시적 제한 노트를 지니므로, 메타데이터 추천이 학습된 것으로 오인되는 일은 결코 없습니다.

FEATURE_ORIGIN은 각 특징을 그것이 읽는 벤치마크 특성화 지표까지 추적합니다; 소비자는 dispatchatlas.bench 특성화 지표를 특징 계약에 매핑하므로, dispatchatlas.solve는 여전히 dispatchatlas.core만 임포트합니다. 두 선택기가 출하됩니다: RuleBasedSelector는 선언된 능력과 특성화만으로 순위화하고(메타데이터 추천), SupervisedSelector는 레이블된 코퍼스로부터 결정론적 거리-가중 최근접-이웃 모델로 순위화합니다(학습-모델 추천).

지도 선택기는 훈련 적합이 아니라 홀드아웃 일반화를 보고합니다. 교차-검증 프로토콜은 레이블된 코퍼스를 어떤 인스턴스도, 어떤 벤치마크 패밀리도, 어떤 특성화 레코드도 훈련과 테스트 분할 둘 다에 나타나지 않도록 분할하고(partition_by_families, leave_one_family_out, leakage_report), 나머지 패밀리에서 훈련하고, 홀드아웃 패밀리를 채점합니다(held_out_generalization, cross_validate). 그 신뢰는 누출-없는 홀드아웃 평가가 그것을 뒷받침할 때만 메타데이터-전용 위로 상승합니다.

learning_interface_catalog()는 일곱 개의 명명된 학습 및 하이브리드 인터페이스 — 지도 알고리즘 선택, 대리-보조 탐색, 강화-학습 훅, 하이퍼-휴리스틱, 정책-유도 수리, 학습된 초기화, 그리고 벤치마크-전용 베이스라인 — 를 등록합니다. 각각은 LearningEvidencePolicy(훈련 데이터, 누출 제어, 재현성, 증거 클래스, 증거-등급 적격성)를 선언합니다. 둘은 여기서 구현됩니다; 다른 다섯은 그 실현이 훈련 데이터를 생산하는 비교 캠페인에 게이트된 등록된 지연 인터페이스입니다. 무거운 추정기 백엔드는 선택적 learning extra 뒤에 머물고 임포트 루트로 탐침되며, 결코 패키지 임포트 중 임포트되지 않습니다; 부재는 MissingOptionalDependencyError를 올리고 결정론적 폴백은 가용한 채로 있습니다.

성능 보호장치

배치 채점은 BatchScoringProfile을 통해 명시적입니다. 현재 커널은 표준-라이브러리 폴백을 사용하고 그 폴백을 진단에 기록합니다. 이는 API를 벡터화 또는 가속 커널에 대해 준비된 채로 유지하면서 테스트되고 이식 가능한 경로를 보존합니다.