InfOCF Solver: Quantum Conic Optimization

• InfOCF solver is an interior‐point method for quantum-information conic programs, leveraging quantum relative entropy and noncommutative operator perspectives.
• It employs a modular Python architecture with specialized barrier oracles and homogeneous self-dual embedding to ensure rapid convergence.
• The solver achieves high precision in handling both symmetric and nonsymmetric cones, integrating seamlessly with Python modeling tools like PICOS.

The InfOCF solver is an interior-point method specialized for quantum-information-theoretic conic programs, notably those involving quantum relative entropy (QRE) and noncommutative perspectives of operator convex functions. Implemented within the QICS (Quantum Information Conic Solver) package, InfOCF provides a modular, high-precision open-source tool for tackling both symmetric (e.g., semidefinite programs) and non-symmetric conic optimization problems central to quantum information theory (He et al., 2024).

1. Mathematical Structure of Conic Programs

The core computational object is a Cartesian product cone $\mathcal{K}$ comprised of:

• The positive semidefinite cone $(\mathbb{H}_+)$,
• Quantum relative-entropy cones,
• Cones defined by noncommutative operator perspectives.

For Hermitian matrices of size $n$, $$\mathbb{H}^n = \{X \in \mathbb{C}^{n\times n} : X^\dagger = X\}$$ and $\mathbb{H}^n_{++} = \{X \succ 0\}$. The QRE cone is

$$\mathcal{K}_{\mathrm{QRE}}^n = \left\{ (t, X, Y) \in \mathbb{R} \times \mathbb{H}^n_{++} \times \mathbb{H}^n_{++}: t \geq \mathrm{Tr}[X(\log X - \log Y)] \right\}.$$

The barrier function is

$$F_{\mathrm{QRE}}(t, X, Y) = -\log(t - \mathrm{Tr}[X(\log X - \log Y)]) - \log\det X - \log\det Y,$$

and is self-concordant with complexity parameter $\nu = 1 + 2n$. More generally, for operator-convex $f$, the noncommutative perspective $P_f(X, Y) = Y^{1/2} f(Y^{-1/2} X Y^{-1/2}) Y^{1/2}$ defines analogous cones and barriers (He et al., 2024).

2. Primal–Dual and Homogeneous Self-Dual Embedding

The solver targets problems of the form

$$\min_x \langle c, x \rangle \quad \mathrm{s.t.}\quad A x = b, \quad x \in \mathcal{K}$$

with dual

$$\max_{y, z} -\langle b, y\rangle\quad \mathrm{s.t.}\quad A^T y + z = c,\, z \in \mathcal{K}^*.$$

The homogeneous self-dual embedding introduces variables $(x, y, z, s, \tau, \kappa)$ and linear embedding equations $L(\omega) = 0$ coupling primal and dual feasibility and strict conic interiority. Central-path conditions enforce $z + \mu \nabla F(s) = 0$, $\tau\kappa = \mu$ for a scaling parameter $\mu >0$, leading as $\mu\to 0$ to optimality or certificate of infeasibility (He et al., 2024).

3. Cone Barrier Oracles

Each cone block in $\mathcal{K}$ must implement oracles supporting:

• Membership tests (including interior checks),
• Evaluation of the barrier gradient $\nabla F$ and Hessian $\nabla^2 F$,
• Hessian–vector and (optionally) inverse Hessian–vector products.

For the QRE cone, $F(t,X,Y)$ as above has

$$\nabla_t F = -\frac{1}{z},\qquad \mathsf{D}_X F = \frac{1}{z}(\log X - \log Y + I) - X^{-1}$$

with $z = t - \mathrm{Tr}[X(\log X - \log Y)]$. $\mathsf{D}_Y F$ and the Hessian are implemented via equivariant spectral calculus and divided differences. For noncommutative perspectives, differentiation exploits spectral mapping and blockwise Hessians of dimension $2n$ (He et al., 2024).

4. Interior-Point Algorithm and Complexity

A Newton system (linearization of the KKT/central-path conditions) is solved at each IPM iteration. This typically reduces to a Schur complement system in the dual variables: $$S \Delta y = \hat{r},\qquad S = A (G^T H G)^{-1} A^T$$ where $H$ is a block-diagonal barrier Hessian. Per-iteration complexity is dominated by forming/factoring the Schur complement, $O(m^3)$ for $m$ equality constraints. The overall iteration complexity is

$O\left(\sqrt{\nu}\,\log\frac{1}{\epsilon}\right)$

with total barrier parameter $\nu$ and target accuracy $\epsilon$. Sparsity and Hermitian structure are exploited to accelerate large-scale instances (He et al., 2024).

5. Software Architecture and Implementation

The Python implementation is modular: a Model class encapsulates coefficients, constraints, and cones; the Solver class manages initialization, iteration, and step selection. Each cone block is a Python module with barrier([x](https://www.emergentmind.com/topics/stability-index-x)), grad(x), hess(x,v), and, where needed, hess_inv(x,v) interfaces. Linear algebra uses NumPy for dense, SciPy for sparse ops, and Numba for JIT-accelerated spectral routines. PSD cones leverage the Fujisawa–Kojima–Nakata approach for sparse $A H^{-1} A^T$ assembly. Hermitian variables are stored in real-valued or complex format, vectorized internally (He et al., 2024).

QICS integrates with PICOS, a general Python modeling language. Users can construct quantum-entropy-constrained problems in PICOS and solve them via QICS:

import picos P = picos.Problem() X = picos.SymmetricVariable('X', n) Y = picos.SymmetricVariable('Y', n) P.set_objective('min', picos.quantrelentr(X, Y)) P.add_constraint(picos.maindiag(X) == 1) P.solve(solver='qics')

This allows seamless model definition and invocation of the InfOCF solver as a backend.

6. Illustrative Use Case and Performance

A canonical example is the $2 \times 2$ QRE-closeness problem: $$\min_{Y \in \mathbb{S}^2}\;S_\parallel\Bigl( \begin{pmatrix}2 & 1 \ 1 & 2\end{pmatrix} \,\|\, Y \Bigr) \quad \text{s.t.}\; Y_{11} = Y_{22} = 1,\, Y \succeq 0.$$ Modeling and solving this within QICS proceeds via the outlined Python API, using the QRE cone. On this task, InfOCF converges in 7 iterations (barrier parameter=5), reporting primal and dual objective values agreeing to at least $5$ significant digits and reporting an optimal $Y$ with off-diagonal $0.5$. This demonstrates the solver's precision and the suitability of its barrier oracles for nonsymmetric cones (He et al., 2024).

7. Applications, Scope, and Extensions

The InfOCF solver enables high-accuracy solutions of structured conic programs arising in quantum information theory, e.g.,

• Semidefinite programming (SDP) with quantum-entropy constraints,
• Optimization involving noncommutative perspectives,
• Problems requiring exact handling of the quantum relative entropy.

Its design permits extension to novel cones with operator-convex function barriers, and it is architected for efficient sparse instances and large-scale Hermitian matrix variables. Integration with Python modeling frameworks encourages broader adoption in quantum information, mathematical optimization, and operator algebra applications (He et al., 2024).