Quantum Optimization

Quantum Optimization

Solve combinatorial optimization problems with modified QAOA, GPU-based Hamiltonian dynamics and classical refinement.

Explore the methods

THE HILVARIAN ENGINE

One optimization problem
Two computational approaches

Start with the decisions your application needs to make. Hilvarian connects the problem model to quantum circuits or quantum-inspired dynamics, supported by classical orchestration and refinement.

Choose an approach around your workload, execution budget and evaluation criteria.

QUANTUM COMPUTING

Modified QAOA

Multilevel decomposition, adaptive state preparation and parameterized circuits search for candidate solutions with quantum measurement feedback.

Execution
Quantum processors with classical orchestration
Explore the quantum method
QUANTUM-INSPIRED COMPUTING

Hamiltonian dynamics on GPUs

Coupled parametric oscillators encode the problem. Parallel numerical evolution explores candidate configurations on classical GPUs.

Execution
GPU computation with classical solution evaluation
Explore the GPU method

Problem formulation

Define the answer
before choosing the algorithm

For combinatorial optimization, the input is a mathematical problem: a set of decisions, a cost to minimise and conditions that determine which answers are allowed.

Model the application before choosing a computational approach. QUBO, Ising and graph representations connect discrete decisions to the search. Domain-specific constraints, encoding costs and feasibility checks remain part of the complete solution.

Decision variables

Specify what an assignment means in the application, rather than treating a measured bitstring as an answer without interpretation.

Objective and feasibility

State which costs matter and which assignments are valid. Encoding constraints affects model size and the resources needed to search it.

Evaluation budget

Set the time, compute cost and execution frequency your application can support. Include model preparation and refinement.

A binary optimisation problem

x⋆∈argmin⁡x∈F  C(x),F⊆{0,1}nx^\star\in\underset{x\in\mathcal F}{\operatorname{argmin}}\;C(x),\qquad\mathcal F\subseteq\{0,1\}^n

Here x is a candidate assignment, C is its cost and the feasible set contains the allowed assignments. The objective defines how solutions are ranked, while the feasible set expresses the conditions an assignment must satisfy.

Problem formulation / Weighted Max-Cut

C(x)=−∑(i,j)∈Ewij(xi⊕xj)C(x)=-\sum_{(i,j)\in E}w_{ij}(x_i\oplus x_j)
HC=−12∑(i,j)∈Ewij(I−ZiZj),HC∣x⟩=C(x)∣x⟩H_C=-\frac12\sum_{(i,j)\in E}w_{ij}(I-Z_iZ_j),\qquad H_C|x\rangle=C(x)|x\rangle

Each bit assigns a vertex to one of two groups. The XOR operation is one when an edge’s endpoints differ. Minimising the negative cut is equivalent to maximising the weight between the groups. The corresponding diagonal Hamiltonian gives each basis state the same cost.

QUBO and Ising representations

E(x)=xTQx+λP(x),x∈{0,1}nE(x)=x^\mathsf{T}Qx+\lambda P(x),\qquad x\in\{0,1\}^n
E(s)=c+∑ihisi+∑i<jJijsisj,si=1−2xiE(s)=c+\sum_i h_i s_i+\sum_{i<j}J_{ij}s_i s_j,\qquad s_i=1-2x_i

Q stores quadratic objective coefficients. P(x) penalizes constraint violations and lambda controls its weight; for a QUBO, P must be quadratic or reduced to a quadratic form with additional variables. With s = 1 - 2x, the model can be expressed through local fields h and couplings J, up to a constant c.

Constraint penalties and model reduction are application-specific. Always decode candidates and check feasibility against the original problem. The mathematical representation alone does not establish that a particular application is supported without additional modelling.

Quantum computing

Modified QAOA
with multilevel decomposition

In QAOA, alternating cost and mixing operations define a parameterised distribution over candidate bitstrings. A classical procedure evaluates the measured outcomes and proposes new circuit parameters. The angles are controls for the search, not the application’s answer.

Hilvarian combines an adaptive initial state with this variational loop. Measured solutions inform a bias between optimisation stages, while the cost and mixer angles are optimised within each stage.

Read the QAOA formulation
Graph decomposition followed by parameterized quantum circuit layers and measurement feedback.CostγMixerβDECOMPOSEQUANTUM CIRCUIT LAYERSMeasurement feedback & parameter updates

Connect a large graph to smaller quantum searches

For large-scale MaxCut, Hilvarian combines multilevel problem decomposition with modified QAOA. Coarsening produces smaller graph representations; candidate assignments are lifted back through the hierarchy and refined against the original objective.

Quantum subproblem size is chosen around the execution target. The total graph size, subproblem size and resources spent across the hierarchy are separate quantities to record.

  1. problem

    Formulate

    Specify variables, an objective and any feasibility conditions. Preserve the original instance.

  2. model

    Encode

    Construct a problem Hamiltonian and the circuit family used to explore candidate solutions.

  3. circuit

    Prepare

    Choose parameters and, for hardware execution, compile the circuit for a defined target.

  4. execution

    Sample

    Repeat circuit execution to collect bitstrings. Evaluate the original objective on observed outcomes.

  5. feedback

    Update

    Use a classical score to update parameters and preserve the best candidate solutions found.

  6. evidence

    Evaluate

    Assess solution quality and resources. Report classical refinement separately from raw sampling.

Sampling and classical updates repeat within a resource budget. Weylattice compiles the circuits for the selected target, while Spinorio Workflow records the associated execution.

Multi-layer adaptive QAOA / Algorithmic example

∣ψp(θ,γ,β)⟩=[∏ℓ=1p←e−iβℓHMe−iγℓHC][⨂j=1nRy(θj)]∣0⟩⊗n|\psi_p(\boldsymbol{\theta},\boldsymbol{\gamma},\boldsymbol{\beta})\rangle=\left[\overleftarrow{\prod_{\ell=1}^{p}}e^{-i\beta_\ell H_M}e^{-i\gamma_\ell H_C}\right]\left[\bigotimes_{j=1}^{n}R_y(\theta_j)\right]|0\rangle^{\otimes n}
θj=π2−(−1)(bT)jδ\theta_j=\frac{\pi}{2}-(-1)^{(b_T)_j}\delta

A biased initial state is followed by p alternating cost and mixer layers, each with its own parameters. Classical optimisation adjusts these parameters, while measurement feedback updates the initial-state bias between optimisation stages.

The left-pointing product orders the layers so that layer 1 acts first, on the right. State preparation is applied once, before the p layers. Each layer has its own gamma and beta, giving 2p cost-and-mixer angles. The mixer HM is the sum of single-qubit X operators.

The preparation angles theta are set by the target bitstring bT and bias delta, then held fixed within each optimisation stage. Zero bias recovers the uniform initial state. Circuit depth p and the number of classical optimisation stages are separate choices.

Two kinds of feedback

A circuit score guides the angle optimiser. Separately, the best measured bitstring updates the search record and can inform the next stage’s preparation. A good circuit score and a newly discovered solution are not the same event.

CVaR scores a selected low-cost fraction of the outcomes. Its tail fraction and tie-handling policy must be recorded because different output distributions can receive the same score.

CVaR and variational optimisation
Quantum work
Prepare circuits and sample their measurement outcomes.
Classical work
Score candidates, update parameters, retain solutions and optionally refine them.
Execution work
Compile and schedule circuits for a target, then assess hardware errors separately from algorithm design.

Quantum-inspired computing

Parametric Hamiltonian
dynamics on GPUs

Hilvarian encodes optimization problems in a network of coupled parametric oscillators. Problem coefficients determine the interactions; numerical evolution explores configurations that can be decoded into discrete candidate solutions.

The computation runs on classical GPUs. Parallel arithmetic supports the coupled dynamics and candidate search, with classical evaluation and refinement connecting results to the original problem.

Illustrative coupled oscillator trajectories evolving toward candidate binary configurations on GPUs.COUPLED OSCILLATOR DYNAMICSEVOLUTIONCANDIDATE CONFIGURATIONS+1−1
  1. Encode

    Translate the objective and applicable constraints into the fields and couplings of the optimization model.

  2. Initialize

    Prepare oscillator states and choose the evolution schedule and computational budget.

  3. Evolve

    Numerically integrate coupled dynamics on GPUs to explore candidate configurations.

  4. Decode

    Map oscillator configurations to discrete assignments using the selected encoding.

  5. Refine

    Evaluate the original objective and apply classical improvement or feasibility repair as appropriate.

  6. Compare

    Report feasible solution quality, elapsed time and computational cost against the chosen baseline.

Hamiltonian evolution / General computational principle

q˙i=∂H∂pi,p˙i=−∂H∂qi\dot q_i=\frac{\partial\mathcal H}{\partial p_i},\qquad\dot p_i=-\frac{\partial\mathcal H}{\partial q_i}

The variables q and p describe oscillator coordinates and conjugate momenta. A time-dependent Hamiltonian controls their coupled evolution. These general equations explain the computational principle; schedules, numerical integration and decoding determine the implemented search.

READY TO EVALUATE

Bring your workload to the GPU engine

Our GPU-powered quantum-inspired optimization engine is ready for testing and implementation in your workflows.

Evaluation

Measure the complete
optimization workflow

Agree a baseline, representative instances and a resource budget. Compare both computational approaches on the original application objective, including the work required to produce a usable, feasible answer.

Repeat runs to understand variation. Report optimality gaps only when a valid reference optimum or bound is available.

Solution quality and feasibility

Measure objective values and constraint satisfaction after decoding. Preserve the distinction between raw candidates, repaired solutions and classical refinement.

Time and computational cost

Include formulation, transfers, queueing where relevant, execution and refinement. Record GPU resources or quantum circuit evaluations and shots alongside classical work.

Scale and repeatability

Test representative model sizes, graph density and constraint structures across multiple instances and independent runs. Report variability as well as the best result.

Repeated decisions

Assess how often the problem changes, the time available to replan and the cost of repeated runs. Evaluate the workflow under the operational budget it must meet.

Quantum-specific diagnostic: discovery beyond a fixed target

A biased preparation can repeatedly produce a known solution. Compare preparation-only, mixer-only and cost-plus-mixer circuits from the same target and bias to examine improvement. Freeze selected parameters before collecting independent evaluation samples.

Pimprove=Pr⁡X∼Pθ,γ,β[C(X)<C(bT)]P_{\mathrm{improve}}=\Pr_{X\sim P_{\boldsymbol{\theta},\boldsymbol{\gamma},\boldsymbol{\beta}}}[C(X)<C(b_T)]

This diagnostic isolates one part of the quantum search. End-to-end comparisons should also account for decomposition, compilation, hardware effects and classical refinement.

Explore evaluation for OR teams

Solve with Hilvarian™

From problem model
to evaluated solutions

Hilvarian is the Quantum Optimization Engine behind these computational approaches. Connect your model, select the search and evaluate candidate solutions against the requirements of your workload.

Explore applications in finance, healthcare and logistics, or bring an existing optimization model for a focused benchmark.

Explore enterprise solutions

Connected tools

Workspace

Spinorio Lab

Work with Hilvarian through the Solvers workspace, alongside notebooks and scientific Python tools.

Explore the Lab
Quantum execution

Weylattice & Workflow

Compile quantum circuits for the selected target and inspect their execution records. GPU dynamics use a separate numerical computation path.

Explore compilation
Enterprise implementation

Your model, your benchmark

Define the application, compare with your current solver and agree a pilot integration around the outcomes that matter.

See industry applications

HILVARIAN™ / Quantum Optimization Engine

Evaluate your optimization workload

Tell us what you are optimizing, your current baseline and the quality, runtime and cost your application needs.

Selected references