All Systems Operational

Intelligence-First Optimization

TO LEAD THE OCEAN
OF COMPLEXITYYOU NEED AN ADMIRAL

Chart the shortest path through impossible problems. Solver racing, AI advisor, natural language builder — real-time convergence at any scale.

AI Advisor

Solver Race

NL Builder

Topology

Impact Explorer

Auto-Detect

Problem Types

Algorithms

Solver Racing

Fastest Solve

<5ms

Uptime

99.9%

What Makes Admiral Different

INTELLIGENCE AT EVERY LAYER

Not just another solver. Admiral understands your problem, picks the best algorithm, and shows you why it works.

Solver Racing

Launch multiple algorithms simultaneously. First to converge wins. Up to 8 solvers compete on your problem in parallel.

AI Advisor

Analyzes your problem structure — sparsity, coupling strength, variable domains — then recommends the optimal solver with confidence scores.

NL Builder

Describe your problem in plain English. Admiral converts it to the right formulation — QUBO, CQM, or MAX-SAT — automatically.

Topology Insight

Visualize the variable interaction graph. See clusters, bottlenecks, and community structure in real-time as the solver runs.

Impact Explorer

Flip any variable and see the energy change instantly. Understand which decisions matter most to your objective function.

Auto-Detect

Submit any JSON matrix. Admiral identifies the problem type, validates the structure, and routes to the right solver pipeline.

Why Admiral

BUILT FOR RESEARCHERS AND ENGINEERS

No fragmented toolchains. No cluster setup. One API that handles everything from formulation to solution.

One API, 9 Problem Types

Submit QUBO, Ising, MAX-SAT, or any of 9 types through a single endpoint. No switching between tools or learning new interfaces.

8x Solver Racing

Race up to 8 solvers in parallel on every problem. The first to converge wins. No manual tuning needed — the best algorithm is selected automatically.

AI-Powered Analysis

The AI Advisor examines your problem structure — density, connectivity, coefficients — and recommends the optimal solver with confidence scores.

No Infrastructure Required

One pip install. One API call. Results in milliseconds. No clusters to manage, no containers to orchestrate, no hardware to provision.

Get Started

PIP INSTALL. SOLVE. DONE.

The admiral-solver package wraps the entire platform into one clean Python API.

solve.py

# pip install admiral-solver
from admiral import Client

client = Client("adm_sk_...")

Q = [[-5, 2, 4],
     [0, -3, 1],
     [0, 0, -8]]

result = client.solve(
    problem_type="qubo",
    data={"Q": Q},
    strategy="race"
)

print(result.solution)    # [1, 0, 1]
print(result.energy)      # -13.0

response.json

{
  "job_id": "ADM-00847",
  "status": "completed",
  "solution": [1, 0, 1],
  "energy": -13.0,
  "solve_time_ms": 82,
  "solvers_raced": 8,
  "ai_confidence": 0.97,
  "convergence": {
    "iterations": 1240,
    "improvement_rate": 0.94
  }
}

client.solve()

Submit any of the 9 problem types. Auto-selects the best algorithm. Returns solution, energy, convergence data, and timing.

client.analyze()

Pre-solve structural analysis. Returns density, difficulty, recommended approach, and variable interaction insights.

client.race()

Launch up to 8 solvers in parallel. First to converge wins. Real-time progress callbacks and convergence traces.

NLBuilder

Describe problems in plain English. Admiral converts to the correct mathematical formulation automatically.

result.impact(i)

Flip any variable and see the energy change. Per-variable sensitivity map of your objective function.

result.topology()

Variable interaction graph. Adjacency data, community clusters, degree distribution, bottleneck identification.

REST API v2.0DOCS →

POST/v1/solveSubmit & race solvers

POST/v1/analyzeAI Advisor

POST/v1/formulateNL Builder

POST/v1/detectAuto-detect type

POST/v1/benchmarkRace all solvers

POST/v1/explainSolution explainer

GET/v1/jobs/{id}Get result

GET/v1/metricsPlatform metrics

11 Problem Types, One Endpoint

UNIVERSAL SOLVER API

Every formulation, one unified interface. Learn how to formulate each type →

QUBO

min xᵀQx

ISING

min ∑hᵢsᵢ+∑Jᵢˇsᵢsˇ

HUBO

min ∑cₛ∏xᵢ

DQM

min ∑aᵢ(xᵢ)+∑bᵢˇ

CQM

min xᵀQx+cᵀx s.t. Ax≤b

MAX-SAT

max ∑wˇ·sat(Cˇ)

PBO

min ∑cˇ∏lᵢ

WCSP

min ∑f(x)

POTTS

min −∑Jδ(sᵢ,sˇ)

Use Cases

FROM RESEARCH TO PRODUCTION

Admiral handles optimization problems across industries — from finance to logistics to life sciences.

Portfolio Optimization

Minimize risk while maximizing returns. Formulate as QUBO or CQM and race solvers to find the optimal asset allocation.

Vehicle Routing

Optimize delivery routes across thousands of stops. Solve TSP and VRP variants with QUBO formulations at scale.

Drug Discovery

Molecular conformation search and protein folding subproblems. Map to Ising models and solve with Admiral's multi-replica optimizer.

Feature Selection

Find the optimal subset of features for ML models. Formulate as QUBO — minimize prediction error with a sparsity penalty.

Scheduling

Job-shop, nurse rostering, exam timetabling. Model constraints with CQM and let the solver handle the combinatorics.

Network Design

Optimize network topology, graph partitioning, and max-cut problems. Native support for Potts models and graph coloring.

Problem Formulation Guide

LEARN EVERY PROBLEM TYPE

Each of the 9 problem types explained — what it is, when to use it, the math behind it, and a working code example you can paste directly into the API.

QUBO

Quadratic Unconstrained Binary Optimization

min xᵀQx where x ∈ {0, 1}ⁿ

What it is

The foundation of combinatorial optimization. You have n binary variables (each is 0 or 1) and a matrix Q that defines how they interact. Diagonal entries Q[i][i] are the linear biases — the cost of turning variable i ON. Off-diagonal entries Q[i][j] encode pairwise interactions — the cost of both i and j being ON simultaneously.

When to use

Any problem that can be expressed as choosing a subset from a set of items to minimize a quadratic cost. Feature selection, graph partitioning, portfolio optimization (binary assets), max-cut, community detection, scheduling with binary assignments.

Key concepts

Diagonal dominance means variables are mostly independent. High off-diagonal coupling means strong interactions — harder to solve. Sparsity (% non-zero entries) determines which solver works best. Dense problems benefit from multi-replica methods; sparse problems converge faster with single-trajectory methods.

Variables

Binary — each xᵢ ∈ {0, 1}

Example

# 3 binary variables, Q is a 3×3 matrix
# Diagonal: cost of each variable being ON
# Off-diagonal: pairwise interaction cost
{
  "Q": [
    [-5,  2,  4],    # x₀ bias=-5, x₀·x₁ cost=2, x₀·x₂ cost=4
    [ 0, -3,  1],    # x₁ bias=-3, x₁·x₂ cost=1
    [ 0,  0, -8]     # x₂ bias=-8 (strongest pull to ON)
  ]
}
# Solution: [1, 0, 1] → energy = -13.0

graph partitioning

feature selection

max-cut

portfolio

scheduling

ISING

Ising Model — Spin Glass Optimization

min ∑hᵢsᵢ + ∑Jᵢⱼsᵢsⱼ where s ∈ {-1, +1}ⁿ

What it is

Originated in statistical physics. Each variable is a "spin" that points up (+1) or down (-1). The field h pushes each spin toward one direction. The coupling matrix J defines how neighboring spins interact. Positive J (ferromagnetic) means neighbors want to align. Negative J (antiferromagnetic) means they want to oppose. Frustration occurs when both types coexist — creating a complex energy landscape.

When to use

Physics simulations, spin glass ground states, network clustering with positive and negative edges, balanced graph partitioning, Boltzmann machines, combinatorial problems that are naturally bipolar (yes/no, up/down, buy/sell).

Relation to QUBO

Mathematically equivalent via s = 2x - 1. Any QUBO can be converted to Ising and vice versa. Admiral does this automatically. Use Ising when the problem naturally has bipolar variables; use QUBO when variables are naturally binary selections.

Variables

Spin — each sᵢ ∈ {-1, +1}

Example

{
  "h": [-0.5, 0.3, -0.2, 0.8],   # External field on each spin
  "J": {
    "0,1": -1.0,   # Ferromagnetic: s₀ and s₁ want to align
    "0,2":  0.5,   # Antiferromagnetic: s₀ and s₂ want to oppose
    "1,3": -0.7,   # Ferromagnetic
    "2,3":  0.3    # Antiferromagnetic — creates frustration
  }
}

spin glass

physics simulation

balanced partition

Boltzmann machine

HUBO

Higher-Order Unconstrained Binary Optimization

min ∑ cₛ ∏ xᵢ where x ∈ {0, 1}ⁿ, |S| ≥ 1

What it is

Like QUBO but with interactions beyond pairs. A 3-body term c·x₁·x₂·x₃ means the cost only applies when all three variables are ON simultaneously. A 4-body term involves four variables, and so on. Standard approach is "quadratization" — introducing auxiliary variables to reduce higher-order terms to quadratic. Admiral's native SA solver handles HUBO directly, avoiding the variable overhead.

When to use

Problems with multi-way constraints that are awkward to encode as pairwise: manufacturing where 3+ components must all be present, logical AND/OR over multiple variables, higher-order Markov random fields, pseudo-Boolean optimization.

Variables

Binary — each xᵢ ∈ {0, 1}. Terms can involve any number of variables.

Example

{
  "num_variables": 5,
  "terms": [
    {"vars": [0],       "coeff": -3.0},    # 1-body: bias on x₀
    {"vars": [1, 2],    "coeff":  2.0},    # 2-body: x₁·x₂
    {"vars": [0, 2, 3], "coeff": -4.5},    # 3-body: x₀·x₂·x₃
    {"vars": [1,2,3,4], "coeff":  1.5}     # 4-body: all four must be ON
  ]
}

multi-way constraints

pseudo-Boolean

higher-order MRF

DQM

Discrete Quadratic Model

min ∑ aᵢ(xᵢ) + ∑ bᵢⱼ(xᵢ, xⱼ) where xᵢ ∈ {0, 1, ..., dᵢ-1}

What it is

Each variable can take one of several discrete values (not just 0/1). Variable i has dᵢ possible states. The linear term aᵢ(k) gives the cost of variable i being in state k. The quadratic term bᵢⱼ(k, l) gives the cost when variable i is in state k AND variable j is in state l. This is much more natural than one-hot encoding binary variables.

When to use

Graph coloring (each node picks a color), vehicle routing (each stop picks a time slot), map coloring, resource allocation where each task picks from a menu of options, job shop scheduling with multiple machines per job.

Variables

Discrete — xᵢ ∈ {0, 1, ..., dᵢ-1}. Each variable has its own domain size.

Example

{
  "domains": [3, 3, 4],   # x₀ has 3 states, x₁ has 3, x₂ has 4
  "linear": {
    "0": [1.0, 2.0, 0.5],          # Cost of x₀ being in state 0, 1, 2
    "1": [0.3, 1.5, 0.8],          # Cost of x₁ being in state 0, 1, 2
    "2": [2.0, 0.1, 1.0, 0.5]     # Cost of x₂ in state 0, 1, 2, 3
  },
  "quadratic": [
    {"i":0, "j":1, "si":0, "sj":0, "v":5.0}  # Penalty if both pick state 0
  ]
}

graph coloring

timetabling

resource allocation

map coloring

CQM

Constrained Quadratic Model

min xᵀQx + cᵀx subject to Ax ≤ b

What it is

A QUBO with explicit constraints. Instead of encoding constraints as penalty terms in the objective (which requires tuning penalty weights), you specify them separately. Admiral's solver handles feasibility enforcement automatically. The objective can be quadratic (Q matrix) plus linear (c vector), and constraints can be equality or inequality.

When to use

Any constrained binary/integer problem: nurse scheduling (each shift must be covered), assignment problems (each task assigned to exactly one worker), bin packing with capacity limits, constrained portfolio optimization with budget constraints.

Variables

Mixed — binary, integer, or real-valued variables with explicit constraints.

Example

{
  "Q": [[-5,2],[0,-3]],        # Quadratic objective
  "c": [1.0, -0.5],              # Linear objective
  "constraints": [
    {"lhs":[1,1], "sense":"==", "rhs":1}  # x₀ + x₁ = 1 (pick exactly one)
  ]
}

nurse scheduling

assignment

bin packing

constrained portfolio

MAX-SAT

Maximum Satisfiability

max ∑ wⱼ · sat(Cⱼ) where each Cⱼ is a clause over Boolean literals

What it is

Given a set of Boolean clauses (OR of literals), find a truth assignment that satisfies the maximum total weight. Each clause is a disjunction like (x₁ ∨ ¬x₃ ∨ x₅). Hard clauses must be satisfied; soft clauses have weights representing how much you want them satisfied. This is the optimization version of the classic SAT problem.

When to use

Configuration problems, verification, planning with soft preferences, debugging (find minimum set of assumptions that cause a conflict), automated reasoning, product configuration where some requirements are hard and others are preferences.

Variables

Boolean — each variable is true or false. Clauses reference literals (variable or its negation).

Example

{
  "num_variables": 4,
  "clauses": [
    {"literals": [1, -3],     "weight": 5},  # (x₁ ∨ ¬x₃) weight=5
    {"literals": [-1, 2, 4], "weight": 3},  # (¬x₁ ∨ x₂ ∨ x₄) weight=3
    {"literals": [3, -4],     "weight": 2},  # (x₃ ∨ ¬x₄) weight=2
    {"literals": [1, 2],       "weight": -1}  # Hard clause (neg weight)
  ]
}

configuration

verification

planning

automated reasoning

PBO

Pseudo-Boolean Optimization

min ∑ cⱼ ∏ lᵢ where lᵢ is a literal (xᵢ or 1-xᵢ)

What it is

A generalization that bridges QUBO and MAX-SAT. The objective is a sum of weighted products of literals (a literal is either xᵢ or its complement 1-xᵢ). This means you can directly express "cost when variable i is OFF" without negating the whole formulation. Constraints are pseudo-Boolean inequalities: weighted sums of literals ≤ threshold.

When to use

Problems that mix QUBO-style optimization with SAT-style constraints. Logic synthesis, circuit optimization, weighted constraint satisfaction where the constraints are Boolean formulas with weights.

Variables

Binary — but uses literals (positive or negative form of each variable).

Example

{
  "num_variables": 4,
  "terms": [
    {"literals": [1, 2],    "coeff": 3.0},  # 3·x₁·x₂
    {"literals": [-1, 3],   "coeff": 2.0},  # 2·(1-x₁)·x₃ — cost when x₁=OFF and x₃=ON
    {"literals": [2,-3,4],  "coeff": 1.5}   # 1.5·x₂·(1-x₃)·x₄
  ]
}

logic synthesis

circuit optimization

weighted CSP

WCSP

Weighted Constraint Satisfaction Problem

min ∑ fₛ(xₛ) where each fₛ is a cost function over a scope of variables

What it is

The most general discrete optimization framework. You define cost functions over subsets of variables. Each cost function maps a combination of variable assignments to a cost. The goal is to find the assignment that minimizes the total cost across all functions. Generalizes DQM (which only has unary and binary costs) to arbitrary arity.

When to use

Protein design (amino acid sequence optimization), computational photography (image labeling), probabilistic graphical models (MAP inference), natural language parsing, any problem where costs are defined over arbitrary subsets of discrete variables.

Variables

Discrete — each variable has a finite domain. Cost functions can involve any subset.

Example

{
  "domains": [3, 2, 3],       # x₀∈{0,1,2}, x₁∈{0,1}, x₂∈{0,1,2}
  "functions": [
    {"scope": [0],     "costs": [1,0,3]},     # Unary cost on x₀
    {"scope": [0,1],   "costs": [0,5,2,1,4,0]}, # Binary cost: 3×2 table
    {"scope": [1,2],   "costs": [3,0,1,1,2,0]}  # Binary cost: 2×3 table
  ]
}

protein design

image labeling

MAP inference

graphical model

POTTS

Potts Model — Multi-State Spin System

min −∑ Jᵢⱼ δ(sᵢ, sⱼ) where δ(a,b) = 1 if a=b, 0 otherwise

What it is

A generalization of the Ising model to multiple states. Instead of two spin directions, each variable can be in one of q states. The Kronecker delta δ(sᵢ, sⱼ) is 1 when neighbors have the same state and 0 otherwise. Positive J (ferromagnetic Potts) rewards same-state neighbors — drives clustering. Negative J (antiferromagnetic) penalizes same-state neighbors — drives coloring/partitioning.

When to use

Community detection, image segmentation (pixels cluster into regions), graph coloring (antiferromagnetic), alloy structure prediction, social network analysis, any problem where you want neighboring nodes to agree (or disagree) on a multi-class label.

Variables

Discrete — sᵢ ∈ {0, 1, ..., q-1}. All variables share the same domain size q.

Example

{
  "num_states": 4,             # q=4 possible states per node
  "num_nodes": 6,
  "edges": [
    {"i":0, "j":1, "J": -1.0},  # Antiferro: penalize same color
    {"i":0, "j":2, "J": -1.0},
    {"i":1, "j":3, "J": -1.0},
    {"i":2, "j":4, "J":  2.0},  # Ferro: reward same state (clustering)
    {"i":3, "j":5, "J":  2.0}
  ]
}
# Antiferro edges → graph coloring
# Ferro edges → community detection

community detection

image segmentation

graph coloring

alloy prediction

TO LEAD THE OCEANOF COMPLEXITYYOU NEED AN ADMIRAL

TO LEAD THE OCEAN
OF COMPLEXITYYOU NEED AN ADMIRAL