Postprocessing

​

Haiqu.solve_qubo(problem, p=10, initial_state=None, alphas=None, betas=None, delta=0.5, shots=1000, device=None, device_id=None, options=None, use_packing=False, pack_size=None, compression=False, compression_options=None, postprocess_iterations=5, seed=None, cvar_alpha=0.1)

1. Builds LR-QAOA circuit with custom parameter schedules
2. Optionally compresses the circuit
3. Executes on specified backend
4. Post-processes results using Haiqu API
5. Calculates CVaR expectation

​

Deprecated

• Parameters:
  • problem (OptimizationProblem | QUBO) — Unconstrained binary OptimizationProblem (or deprecated QUBO).
  • p (int) — Number of QAOA layers. Defaults to 10.
  • initial_state (Optional *[*QuantumCircuit ]) — Custom initial state. Defaults to None (uniform superposition).
  • alphas (Optional *[*list *[*float ] ]) — Cost operator parameters. Defaults to None (linear ramp).
  • betas (Optional *[*list *[*float ] ]) — Mixer operator parameters. Defaults to None (linear ramp).
  • delta (float) — Ramp parameter when alphas/betas not specified. Defaults to 0.5.
  • shots (int) — Number of measurement shots. Defaults to 1000.
  • device (DeviceModel) — Device to execute on. Defaults to None.
  • device_id (str) — Id of the device to execute on. Defaults to None.
  • options (Optional *[*dict ]) — Additional device options.
  • use_packing (bool) — Whether to use circuit packing for efficient device utilization. Defaults to False. Warning: Experimental — packing replicates circuits on unused device qubits to run multiple copies in parallel, which may increase errors for deeper input circuits. For example, a 4-qubit circuit with pack_size=2 and 1000 shots runs two copies in parallel with 500 shots each, yielding 1000 shots of results while only paying for 500 shot executions on the QPU — a 2x cost saving.
  • pack_size (Optional *[*int ]) — Number of circuit copies to pack onto the device. Must be >= 2. Only valid when use_packing=True. If None (default), the backend will pack into at most 2/3 of the device qubits.
  • compression (bool) — Whether to compress the circuit. Defaults to False.
  • compression_options (Optional *[*dict ]) — Compression options dictionary. See method state_compression for details.
  • postprocess_iterations (int) — Maximum number of post-processing passes. Defaults to 5. Controls the number of complete passes through all bits. Higher values may find better local minima but increase runtime. Default of 5 provides good balance between speed and solution quality.
  • seed (Optional *[*int ]) — Random seed for reproducible post-processing results. Defaults to None.
  • cvar_alpha (Optional *[*float ]) — CVaR alpha parameter. None to disable CVaR. Defaults to 0.1.
• Returns: Complete solution with raw/processed results, costs, and metadata.
• Return type: SolverResult

​

NOTE

​

Examples

>>> result = haiqu.solve_qubo(problem)

>>> result = haiqu.solve_qubo(
...     problem,
...     postprocess_iterations=10,
... )

>>> result = haiqu.solve_qubo(
...     problem,
...     p=100,
...     alphas=my_alphas,
...     betas=my_betas,
...     compression=True,
... )

>>> result = haiqu.solve_qubo(problem, cvar_alpha=None)

​

Haiqu.postprocess(counts, problem, postprocess_iterations=5, seed=None)

• Parameters:
  • counts (dict *[*str , int | float ]) — Dictionary mapping bitstrings to their measurement counts or probabilities. Bitstrings must be in Qiskit’s little-endian convention (rightmost bit = qubit 0).
  • problem (OptimizationProblem | QUBO) — Unconstrained binary OptimizationProblem (or deprecated QUBO).
  • postprocess_iterations (int) — Maximum number of optimization passes. Defaults to 5.
  • seed (int | None) — Random seed for reproducible results. Defaults to None.
• Returns:
  • optimized_costs: Dict mapping bitstrings to their costs
  • optimized_counts: Dict mapping bitstrings to aggregated counts
• Return type: Tuple of (optimized_costs, optimized_counts)

​

NOTE

​

Examples

>>> counts = {"0101": 100, "1010": 50}
>>> costs, opt_counts = haiqu.postprocess(
...     counts=counts,
...     problem=problem
... )

>>> costs, opt_counts = haiqu.postprocess(
...     counts=counts,
...     problem=problem,
...     postprocess_iterations=10,
...     seed=42
... )

• Raises: ValidationError — If parameters have incorrect types.

• Parameters:
  • counts (dict *[*str , int | float ])
  • problem (OptimizationProblem | QUBO)
  • postprocess_iterations (int)
  • seed (int | None)
• Return type: tuple[dict[str, float], dict[str, int | float]]

​

optimization.cvar_expectation(problem=None, alpha=1.0, cost_function=None)

• Parameters:
  • counts (Dict *[*str , Union *[*int , float ] ]) — Dictionary mapping bitstrings to counts/probabilities. Bitstrings in Qiskit convention (little-endian).
  • problem (Union [ ‘OptimizationProblem’ , ‘QUBO’ , None ]) — Unconstrained binary OptimizationProblem or deprecated QUBO. Required if cost_function is not provided.
  • alpha (float) — CVaR parameter (0 < alpha <= 1). Defaults to 1.0 (full expectation).
  • cost_function (Optional *[*Callable [ *[*str ] , float ] ]) — Custom cost function. If None, uses problem.cost(). Required if problem is not provided.
• Returns: CVaR expectation value.

• Raises: ValueError — If both problem and cost_function are None.

• Return type: float

​

NOTE

​

Examples

>>> cvar = cvar_expectation(counts, problem=problem, alpha=0.1)

>>> def my_cost(bitstring):
...     return sum(int(b) for b in bitstring)
>>> cvar = cvar_expectation(counts, cost_function=my_cost, alpha=0.1)