Approaching Collateral Optimization for NISQ and Quantum-Inspired Computing (May 2023)

Collateral optimization refers to the systematic allocation of financial assets to satisfy obligations or secure transactions while simultaneously minimizing costs and optimizing the usage of available resources. This involves assessing the number of characteristics, such as the cost of funding and quality of the underlying assets to ascertain the optimal collateral quantity to be posted to cover exposure arising from a given transaction or a set of transactions. One of the common objectives is to minimize the cost of collateral required to mitigate the risk associated with a particular transaction or a portfolio of transactions while ensuring sufficient protection for the involved parties. Often, this results in a large-scale combinatorial optimization problem. In this study, we initially present a mixed-integer linear programming formulation for the collateral optimization problem, followed by a quadratic unconstrained binary optimization (QUBO) formulation in order to pave the way toward approaching the problem in a hybrid-quantum and noisy intermediate-scale quantum-ready way. We conduct local computational small-scale tests using various software development kits and discuss the behavior of our formulations as well as the potential for performance enhancements. We find that while the QUBO-based approaches fail to find the global optima in the small-scale experiments, they are reasonably close suggesting their potential for large instances. We further survey the recent literature that proposes alternative ways to attack combinatorial optimization problems suitable for collateral optimization.


I. INTRODUCTION
I N In the context of a financial transaction, wherein one party lends assets to another, the lender assumes a credit risk arising from the possibility that the counterparty may default on their obligations.This risk also arises in derivatives transactions where the party "in-the-money" is exposed to the party "out-of-the-money".To mitigate this risk, the borrower is required to provide low-risk securities (such as cash, bonds, or equities) to the lender for the duration of the transaction.This practice, known as collateralization [1], serves as a form of security against loan defaults as the lender can seize these assets to offset any losses resulting from default.The value of the collateral received is expected to be commensurate with the outstanding exposure, in order to effectively counterbalance the associated risk.
Often, a bilateral contract (or schedule) is formed to agree on the terms under which securities can be considered collateral, the process of evaluating the value of these assets, and other regulations.The relevant party may then accordingly select the assets they post to the counter-party.For large financial institutions, such as banks, this can involve a pool of numerous assets to choose from which need to be distributed amongst a portfolio of various counterparties (other banks, hedge funds, central banks, etc.).Each asset has an associated opportunity cost, which is a measure of how valuable the asset would be if it were used for another purpose.As well as a cost related to the risk of posting to a particular counterparty amongst other administrative costs.The bank must therefore carefully consider their choice of transactions to reduce these costs.However, the magnitude of the possible combinations of allocations for large institutions makes this a time-consuming process.In addition, poor collateral management can have significant consequences.The 2008 financial crisis was partly due to collateralization of high-risk securities and led to the bankruptcy of some of the largest financial institutions, among other consequences [2].
This crisis has led to the reformation of many financial processes through the implementation of regulations such as Basel III [3], Dodd-Frank Act [4], EMIR [5] as well as motivating academic research with regards to how collateral can be better managed [6], [7].These studies relating to collateral management are generally centered on financial theories such as risk aversion and its global financial impact.A crucial aspect of collateral management is the development of an automated process that selects the optimal allocations.Despite the importance of collateral optimization (ColOpt), the literature surrounding this topic is sparse due to the competitive advantage these strategies offer to financial institutions.
Naturally, linear programming algorithms can provide a framework for tackling such problems [8].Specifically, ColOpt is suitable to be implemented using mixed-integer linear program (MILP) solvers such as the ones available with IBM CPLEX [9], Gurobi [10], or Mosek [11].The success of a given ColOpt instance, or the quality of its solution, is dependent on a clear mapping between the business problem and the mathematical formulation as well as the choice of the precise implementing algorithm.The benefit of using numerical optimization is that we attain the allocation selections in a single process, which is in contrast to other proposed models such as "ranking-based", "economic-cost" and "waterfall" models which are sequential in nature, rather than automated [12].However, there are several limitations of MILP solvers when applied to problems such as ColOpt, which potentially involve complex nonlinearities and large-scale datasets.For example, MILP solvers have exponential worst-case complexity and can take a significant amount of time to solve large-scale complex optimization problems.While having convergence certificates is very desirable, the exponential complexity is often a problem for many ColOpt instances that involve a large number of decision variables and constraints and it is not uncommon to either have long solution times or even infeasibility.That said, MILP solvers are the standard in both industrial and academic applications but the community is very keen on exploring alternative approaches.
Different avenues to (approximately) solve such computationally challenging problems could be provided through alternative computational models.For example, in Ref. [13], IBM's True Spike neuromorphic computer [14] was utilized to find approximate solutions for the graph partitioning problem.More interest is directed towards quantum computing [15].These computers rely on quantum-mechanical effects for storing and processing information.However, because of the fragile environment required for these effects to occur, the realization of fault-tolerant quantum computers is still a difficult task.
Very often, in this context, the prototypical optimization use-case is that of (Markowitz) portfolio optimization.While this use-case shares a few similarities with ColOpt, there are a few fundamental differences as well.The constraints of ColOpt, seem to be more involved even within the simplifications we present in Sec.III.An important difference is also the fact that our objective function is inherently linear, at first glance.However, several "tricks" can be performed in order to end up with a well-behaved formulation suitable for a variety of Ising NISQ or hybrid solvers.
Quantumly, there are many approaches to follow in order to approximate better solutions for a variety of NP-Hard problem instances encountered in finance.The main three approaches (listed below) have a common theme: conversion of the original mathematical formulation of the problem from a linear program (LP) formulation to a quadratic unconstrained binary optimization problem (QUBO).The reason lies in the inherent ability of quantum or hybrid approaches by modeling the Ising model type of systems (see App. B).There, an optimization problem is mapped to the classical Hamiltonian of the Ising model, where its ground state encodes the optimum.As a matter of fact, many NP-Hard problems, including Karp's list of 21 NP-Hard problems, are known to admit at least one formulation of the Ising model [33].The QUBO or Ising approach can be used and problems can be mainly tackled as follows: • Using variational quantum algorithms (VQAs) [34] such as the Quantum Approximate Optimization Algorithm (QAOA) [35] on gate-based quantum computers (e.g., IBM's superconducting quantum computer).A variety of tests have been performed in this context with significant (qubit) resource improvements recently [36].• Using quantum annealing (QA) [37]- [41] on adiabatic quantum computers (quantum annealers) such as the D-Wave hardware [42] (see [43] for an application to portfolio optimization).• Using quantum-inspired methods which can be understood as using the QUBO formulation of the problem of interest with any approach that ranges from simulated annealing [44] on high-performance clusters or digital annealing [45] such as Fujitsu's FPGA-based "quantuminspired" classical hardware DAU [46].These approaches are very promising and it is widely expected that near-term quantum computers, as well as the dedicated quantum inspired hardware, may have a good chance to provide computational or business advantage 1 [47], [48] in the near term.Note that the formulation we will present below in Sec.III, are hardware agnostic and in that sense any of the above approaches would be suitable in principle.
Additionally, there exists evidence that the class of problems that NISQ computers can solve is not a subset 2 of BPP [49].However, we realize that their heuristic nature can conceal their applicability, especially when considering problem instances with sizes suitable for high-quality MILP solvers.Such a result was reported in Ref. [50] wherein the authors discuss how D-Wave's 2000Q machine (as well as classical simulated annealing) failed to even come close to the branch and bound approaches [51], [52] for solving certain instances of the Knapsack Problem (KnapsackProb) (see Sec. II).One can potentially try to use the VQA approach instead [19], [34], [53], [54, for example].In this context, Nannicini [55] reported that there seems to be a lack of transparent computational advantage in introducing entanglement when VQAs are used.This lack of computational advantage is expected to some extent due to the well-known local minima problem that VQAs exhibit [56] (see [57] for the proposed way to avoid this problem).In addition, bias in the noise of circuits that implement VQAs can unfavourably affect the convergence ratios [58].Other limitations are discussed in [59].
However, performance advantages have been showcased in a variety of applications within the context of digital and quantum annealing solutions, tensor networks, and analog and digital (gate-based) quantum computing.For example, Ref. [60] studied the maximal independent set (MaxIndSet) problem and found a superlinear quantum speedup, as opposed to classical solutions, when considering very hard graphs.From the point of view of computational complexity, the MaxIndSet problem is not particularly different from other NP-Hard problems such as the KnapsackProb (which actually is weakly NP-Complete) or other NP-Hard problems that admit a MILP formulation, and as such the results of [60] are encouraging for other problems as well.An interesting benchmark test [61] using the D-Wave machine showed very promising results.It is worth mentioning that D-Wave recently announced [62] the largest quantum simulation done, in different context (spin glasses) to what is of interest here.
In this paper, we study the ColOpt problem in detail and provide a MILP formulation that we use as a testbed for: (i) formulating a QUBO version of ColOpt which makes it suitable for feeding into quantum and quantum-inspired solvers and (ii) performing small scale simulations of such solvers and comparing to MILP.Specifically, in our MILP 1 By the term "business advantage" we mean enough computational resource savings or improvement in performance enough to justify the adoption of the underlying technology. 2 Ref. [49] defines NISQ as the class that contains all problems that can be solved by a polynomial-time probabilistic classical algorithm with access to a noisy quantum device and where BPP⊆NISQ⊆BQP.
formulation we choose our objective to be minimization of the cost of posting collateral (different approaches to the objective of ColOpt have been proposed, for example, see [12]).We survey and try numerous QUBO encodings and find that, modulo emulator limitations, in such small instances the quantum-inspired formulations perform well enough to be promising for implementation on real quantum or quantum-inspired hardware for very large instances.The structure of the paper is as follows.In Sec.II we provide an overview of some of the different QUBO formulations for the KnapsackProb problem.This section serves both as an introduction to the concepts used throughout the paper and to inform the ColOpt problem that follows.In Sec.III we provide the MILP formulation of the ColOpt problem as well as a few QUBO proposals.In Sec.IV we provide a few numerical results using the formulation of the previous section.Finally, we summarize and conclude in Sec.V.
We want to clarify that while our paper investigates various QUBO formulations for the KnapsackProb problem, our ultimate goal is to apply this information to the ColOpt problem.Specifically, we plan to use the best-performing QUBO formulations from our KnapsackProb study to formulate and solve the collateral optimization problem using QUBO.However, we would like to note that our paper does not aim to provide an empirical comparison between quantum and classical approaches for solving MILPs, given the limited computational resources available to us (see [63] for work on the comparison of classical and quantum (adiabatic) optimization, wherein the authors discovered "surprising" results favoring the D-Wave machine).Additionally, we focus on small problem instances only, and we acknowledge that all the results presented in our study are heuristic in nature.Nevertheless, based on the literature results on the potential of QUBO formulations (quantumly and not only), we believe that the formulations we propose may have value in tackling larger instances of the collateral optimization problem and therefore may warrant further investigation.
In summary, the main objective of our paper is to present a case study on the formulation and approach of the ColOpt problem using quantum computing techniques, with the overarching aim of advancing the ongoing effort towards achieving "quantum advantage" in practical applications.

II. INTERLUDE WITH THE KNAPSACK PROBLEM
To inform and ensure that our formulations and the subsequent computations, we perform a simple test using a small KnapsackProb instance.In essence, KnapsackProb involves determining the optimal approach to filling a knapsack of capacity W with the highest possible value from a set of n items that have specific sizes and corresponding values (see Table I).This problem is of interest due to its simplicity to formulate, and its simple constraints.For us, it is further interesting since we view the ColOpt problem as a (somewhat complicated) generalization.
Given the large number of "hard" constraints of the ColOpt problem, see Sec.III, we aim to compare formula-  tion for small instances of the Knapsack Problem with the hope to inform our approach for collateral optimization.The "standard route" to encode constraints to a QUBO model is by using (balanced) slack variables for penalization [64] (see App. B).A different approach is using "unbalanced" penalization [65] which turns out to be particularly useful for QAOA solutions as it reduces the resources required by a gate-based machine.
The MILP formulation of the KnapsackProb is a wellknown and straightforward approach.In the problem instance we consider, we are given a set of weights w ∈ Z n ≥0 and their corresponding values v ∈ Z n ≥0 , and the objective is to maximize the total value of the items that can be packed into a knapsack subject to a given weight limit.The problem can be mathematically defined as follows: where W is the maximum weight limit (threshold) of the knapsack and x i is the binary variable representing whether the i-th item is to be placed in the knapsack.The best running-time algorithm for solving the KnapsackProb is based on dynamic programming with pseudo-polynomial complexity O(d n W ) [66], where d n is the number of distinct weights available while near-linear running times algorithms (in d n , W ) were documented in [67].
The specific problem instance we consider in our study, as outlined in [68], comprises ten items and possesses a known optimal solution.We leverage this knowledge to heuristically evaluate the effectiveness of our approach and guide our efforts towards tackling the larger ColOpt problem discussed in Section III.The relevant (toy) data pertaining to the items in this problem instance can be found in Table I.
Although the KnapsackProb is known to be (weakly) NPcomplete, simple instances such as the one we consider in this study can be efficiently solved by a range of classical solvers.For our experimental analysis, we used the HiGHS [69] and GLPK [70] solvers, both of which yielded solutions that were in agreement with the known optimal solution of the problem instance, as expected, while for the QUBO-formulated problem, we tested the open-source Julia libraries ToQUBO.jl[71], Qiskit's optimization module [72], the open-source Python library PyQubo [73] (in both cases operating under simulated annealing) and the emulation of the proprietary Digital Annealer of Fujitsu [46].

A. QUADRATIC UNCONSTRAINED BINARY OPTIMIZATION
The QUBO model can be applied to a wide range of combinatorial optimization problems that are known to be NPhard, such as the maximum cut, minimum vertex cover, multiple knapsack, and graph coloring problems.Its applications span a diverse set of domains, including the automotive industry [74], portfolio optimization [75]- [77], traffic flow optimization [77], job scheduling [78]- [80], railway conflict management [81], bioinformatics [82], and others [83].An extensive list of QUBO formulations for interesting problems can be found in [84].
Due to its one-to-one mapping to the Ising Hamiltonian, QUBOs have become a fundamental element of quantuminspired computing.Both the Digital Annealer developed by Fujitsu and the adiabatic quantum computers manufactured by D-Wave Systems (as well as other vendors such as Qilimanjaro) employ the QUBO model to address complex optimization problems.Additionally, several approaches based on tensor networks seem to be suitable for a variety of QUBO-formulated optimization problems [85]- [88].Although QUBO is particularly well-suited to these technologies, it can also be employed in NISQ devices using algorithms such as the QAOA.As such, the QUBO model is an important tool for quantum optimization with potential applications across a range of quantum computing platforms, and formulating constrained problems as such highly affects the quality of the solutions obtained.
Let us summarise the basics of QUBO via a graph problem.Given an undirected graph G = (V, E) with a vertex set V = {1, 2, ..., N } connected by the edge set E = {(i, j), }, i, j ∈ V , the cost function is defined as: where x ∈ {0, 1} are the binary variables and the elements A ij ∈ R N ×N are the problem instance parameters.
At its most fundamental level, a QUBO can be expressed as: where the decision matrix Q ∈ R N ×N contains the problem instance and b ∈ R is a constant offset term.By using a suitable change of variables x i = 1−σi 2 , Eq.( 2) can be mapped onto the Ising Model Hamiltonian as: where σ ∈ {−1, 1} N are the (classical) spins, h ∈ R N is the magnetic field, and J ∈ R N ×N , diag(J) = 0, the spin-spin interaction symmetric matrix between adjacent spins j and k.See App.B for more details.The problem to be solved then is: For the QUBO formulation of KnapsackProb we can take several slack-based approaches including "off-the-shelf" LPto-QUBO converters such as Qiskit's QuadraticProgramTo-Qubo class and methods as well as the Julia package To-QUBO.jl.Further to that, we can perform a "custom" slack formulation and also use the unbalanced penalization method we mentioned previously.

B. SLACK VARIABLE FORMULATION
In the process of converting MILPs to QUBOs, it is common practice to introduce a slack variable, S ∈ R ≥0 (whose purpose will be discussed shortly), for each linear inequality and transform it into an equivalent linear equality.Subsequently, a penalty term is constructed based on the slack variable, and the term is squared as per the standard approach, as outlined in [64] (see also [89]).
A variety of different slack-based QUBO formulations exist for the KnapsackProb [90].Here, the corresponding penalisation term with weight λ 0 ∈ R + is given by the equality: The purpose of the auxiliary slack variable S is to reduce this term to 0 once the constraint has been satisfied, In practice, S is decomposed into binary representation using variables s k ∈ {0, 1} as follows: The parameter N s corresponds to the number of binary variables required to represent the maximum value that can be assigned to the slack variable, and in the case of KnapsackProb, N s = ⌈log 2 (W )⌉, where ⌈x⌉ is the ceiling function.Formulating the slack variable as in Eq. ( 7) is commonly referred to as the "log-encoding".The full QUBO formulation for the KnapsackProb takes the form of maximizing the objective function: which can be understood as an augmented Lagrangian [91].Alternatively, there are other QUBO formulations of the KnapsackProb that we could decide to use that follow a similar Lagrangian paradigm.For example, we can instead consider maximizing the following objective function: In this formulation, known as "one-hot encoding", the number of slack bits is equal to the capacity of the knapsack, W .
Here, an additional penalty term is required to enforce only one of these slack bits to be assigned a value of 1.A drawback of this formulation is that the binary input length for the slack variables scales linearly with the values of the constraints, hence it can lead to an unreasonably large number of bits for problem instances with large W which can exhaust available resources.This issue becomes quite relevant in Sec.IV.

C. BALANCED SLACK-BASED APPROACHES
In this section, we give an overview of the approaches used to determine solutions for different balanced formulations of the KnapsackProb QUBO.The known optimal solution for our small instance that we consider corresponds to an objective value of 309 and uses the full capacity of the knapsack.
Off-The-Shelf Converters.The first "off-the-shelf" approach we tried is ToQUBO.jl,an open-source Julia package that automatically reformulates a variety of optimization problems, including MI(L)Ps, to a QUBO.The user can use the JuMP [92] package to build the MILP form of KnapsackProb.
ToQUBO.jl provides 6 ways for encoding variables into binary representations.This includes the logarithmic and one-hot approaches mentioned above as well as other less well-known techniques.For continuous decision variables, this can be very useful since the user can provide a tolerance factor to manage the upper bound on the representation error caused by the binarization.Additionally, ToQUBO.jlworks in conjunction with QUBODrives.jl, a companion package that provides common API to use QUBO sampling and annealing machines such as D-Wave's simulated annealer and, with license, the quantum annealer via DWaveNeal.jl.We make use of ToQUBO.jl to employ both of the aforementioned binary encodings, both successfully finding the optimal solution.However, the unbalanced QUBO formulation is a recent development which has not been widely adopted, hence its encoding is not available as part of the ToQUBO.jlpackage.
Another "off-the-shelf" converter is provided by Qiskit's optimization module which includes functionality for automatically transforming quadratic programs into QUBOs (the binary property allows us to use such).This transformation can be accomplished by first initializing a QuadraticProgram and subsequently utilizing the QuadraticProgramTo-Qubo class to convert it into a QUBO via the log-encoding method for slack variables.The module allows the formulated QUBO to feed into several algorithms used by Qiskit to solve optimization problems, such as SamplingVQE or QAOA, however, the user can also extract the coefficient matrix to use with other solvers.We input this coefficient matrix into neal and Fujitsu's Digital Annealer, where we found that both solvers are able to reach optimum, with the caveat that a large number of runs are needed compared to other methods.For larger problem instances, this can become computationally expensive and thus may be an inadequate choice for ColOpt.
There are several variations of the balanced slack-based approach to QUBO formulations, which we summarize now.

VOLUME 4, 2016
Log-encoding.This approach refers to implementing Eq. ( 8).The number of slack bits required for this approach, for the instance of interest, is N s = 8.Two different regimes for the weight of the penalty term, λ 0 , are checked: (a) where the penalty term and the cost function have equal weighting (λ 0 = 1), and (b) where the penalty term is more important than the cost function (λ 0 = 1 × 10 4 ).We utilized the neal package to implement D-Wave's simulated annealer as our heuristic optimizer in both scenarios.The simulated annealer successfully returned the optimal solution in both cases, which was consistent with the results obtained from the classical solvers.The (emulation of the) Digital Annealer from Fujitsu was employed for both scenarios as well.Similar to the case with neal, it successfully produced optimal solutions in both instances.One-hot encoding.We repeated the previously described process but with a focus on analyzing the solutions of Eq. ( 9).As previously mentioned, this type of formulation requires a large number of bits to encode the slack variables for large knapsack capacities, in this case, 165 bits.In this approach, we once more explored various weight regimes for λ 0 and λ 1 , in relation to the weight of the cost function term.By selecting λ 0 = 10 −1 and λ 1 = 10 3 , we consistently identified the optimal solution for both neal and Fujitsu cases.

D. UNBALANCED PENALIZATION APPROACH
Given that the number of qubits required scales proportionally with the number of variables, we sought to employ the methodology proposed by Montanez-Barrera et.al. [65] in order to eliminate the need for slack variables.To accomplish this, we adopted an approximation technique that creates penalty terms that take on small values when the constraint is fulfilled and large values when it is violated.We rearrange the inequality to define an auxiliary function: Using the exponential function f (x) := e h(x) .the constraint on h(x) is satisfied.However, since only linear and quadratic terms may be encoded into a QUBO, it is necessary to use a 2 nd order Taylor approximation of f (x).For weights λ 0 and λ 1 , the resulting QUBO for the KnapsackProb problem reads: It should be noted that Ref. [65] investigated this type of QUBO formulation for different instances of the Traveling Salesperson Problem (TravSalProb), Bin Packing Problem (BinPackProb), and KnapsackProb and found that the minimum energy eigenvalue of the corresponding Hamiltonian did not necessarily coincide with the optimal solution.However, the optimal solution was always found to be amongst the lowest-energy eigenvalues which enhances the confidence for this approach in large-scale experiments.
To clarify, the advantage of reformulating the problem as an unbalanced QUBO rather than the traditional balanced approaches is that one significantly reduces the number of variables, and hence the bits required to represent the problem, which in effect reduces the resource cost as well as the search space of the optimal solution.However, drawbacks associated with the unbalanced approach are that, because of the use of a heuristic penalisation function our constraints are less strict and the groundstate of the corresponding Ising Hamiltonian is less likely to coincide with the optimal solution of the problem at hand.
Using the weights provided by Ref. [65], as a quick check, we were able to reach optimality for this KnapsackProb instance for both PyQUBO and Fujitsu unbalanced approaches, signifying that the unbalanced formulation exhibits (some) robustness.For larger KnapsackProb instances tested we produced close to optimal results which, however, would periodically softly break the maximum weight limit.

F. SURVEY OF ALTERNATIVE APPROACHES
There exist various alternative approaches that exhibit varying degrees of divergence, in terms of algorithmic implementation, from the aforementioned methods.This section serves solely to provide a survey of some of these approaches without undertaking an experimental analysis.
Quantum Hybrid Frank-Wolfe method.Recently, a hybrid quantum generalization to the Frank-Wolfe method was proposed in [93].This hybrid (Quantum) Frank Wolfe (Q-FW) augmented Lagrangian method is suitable to tackle large QUBO instances due to a tight copositive relaxation of the original QUBO formulation while dealing with the expensive hyper-parameter tuning found in other QUBO heuristics.
The Q-FW method first formulates constrained QUBOs as copositive programs, then employs the Frank-Wolfe method while satisfying linear (in)equality constraints.This is the converted to a set of unconstrained QUBOs suitable to be run on, e.g., quantum annealers.It was found that Q-FW successfully satisfied linear equality and inequality constraints, in the context of QUBOs in computer vision applications and the authors of [93] solved intermediary QUBO problems on actual quantum devices demonstrating that Q-FW offers a promising alternative the validity of Q-FW, to "traditional" quantum QUBO solvers.
In a broader context, Q-FW seems to have the ability to address the costly hyper-parameter tuning associated with other QUBO heuristics.By formulating constrained QUBOs as copositive programs, it adeptly handles linear equality and inequality constraints and transforms them into unconstrained QUBOs compatible with quantum annealers or other Ising machines.The general applicability and comparative efficiency of Q-FW against established quantum QUBO solvers is still unclear and subject to further research.
Grover adapted binary optimization.Moving to Fault-Tolerant architectures, quadratic speed-up for combinatorial optimization problems is achievable with the Grover adapted binary optimization (GABO) [94] when compared to brute force search.However, to achieve this, efficient oracles must be developed to represent problems and identify states that satisfy specific search criteria.Quantum arithmetic is commonly utilized to accomplish this task, but this approach can be expensive in terms of required Toffoli gates and ancilla qubits, which may pose a challenge in the near future.Interestingly [94] provides such an oracle construction which makes GABO a promising approach for future quantum computers.
GABO might be able to offer a significant quantum advantage, a Grover-like quadratic speed-up for combinatorial optimization problems compared to traditional brute force search.However, this speed-up can be only impactful in the realm of Fault-Tolerant quantum architectures, and thus not applicable to NISQ devices.
Graph Neural Networks.Physics-inspired Graph Neural Networks (GNNs) have been used in [95] (see [96] for a survey) where a physics-informed GNN-based scalable generalpurpose QUBO solver is proposed.The approach therein is suitable for encoding any k-local Ising model such as the k = 2 ColOpt problem discussed later.The GNN solver first drops the integrality constraints in order to obtain a differentiable relaxation f ′ of the original objective function f and subsequently proceeds to unsupervised learning on the node representations.The GNN is then trained to generate soft assignments, predicting the likelihood of each vertex in the graph belonging to one of two distinct classes, in conjunction with heuristics that aid in the consistency of the problem.Interestingly, the authors benchmark this approach in demanding problem instances of MAXCUT to find that it competes with the best in class SDP algorithms such as the Goemans-Williamson algorithm [97].
The parallel processing capabilities of modern GPUs are well-suited for GNN operations, making it feasible to handle large-scale graphs and complex optimization problems.Furthermore, the adaptability of GNNs, combined with unsupervised learning, allows for general-purpose solutions that can be applied across a variety of problem instances without the need for extensive retraining.This universality potentially saves computational resources in the long run.However, possible relaxations of integrality constraints for differentiability can sometimes lead to solutions that are not directly applicable or optimal for the original discrete problem.Another remark is that while GNNs can predict soft assignments efficiently, converting these into definitive solutions might lead to suboptimal results.
QUBO continuous relaxations with light sources.Finally, let us mention a recent heuristic quantum-inspired (relaxation) approach for solving QUBOs, introduced in [98].Concretely, the binary variables of the QUBO problem are represented by the relative phases of laser sources, transforming the discrete optimization problem into a continuous one.The lasers interact through a unique optical coupler, which uses programmable diffractive elements and additional optical components to control the interaction between all pairs of lasers, with a dynamic range of up to 8 bits.This design enables a fully connected network between all lasers, facilitating high-resolution pairwise interactions that are crucial in solving QUBO problems.
In [98] a benchmarking was performed for instances of the 3-regular 3-XORSATproblem and it was found that this method achieves significantly better TTS results as the instance size was increased.Despite this, seemingly incredible result, it is quite unclear whether this approach can perform on par for problems that do not have known poly-time solutions (for generic instances of 3-XORSAT there exists an algorithm with O(N 2.736... ) complexity).In fact, it would be interesting to benchmark this approach against specialized SAT and MIP solvers.
Among its advantages, the method's transformation of discrete variables into continuous may offer new avenues for efficient problem-solving.The fully connected network ensures precise pairwise interactions, a fundamental requirement for many combinatorial problems, also one that not all Ising machines can achieve.The aforementioned results of this method are obtained via an emulation architecture, rather than the physical machine which in turn might be able to perform even better.Another benefit of this tech is that it is readily available.However, there are a number of uncertainties.While the method showed promise on specific benchmarks like the 3-XORSATproblem, its general applicability and competitiveness against established solvers remain untested and benchmarking e.g.within the MaxSAT Evaluation challenge would be highly en lightning.Furthermore, its performance on problems lacking known polynomial-time solutions is yet to be determined, raising questions about its versatility.Simulated quantum annealing.Obtaining quantum advantage for certain problem instances may be, in some cases, closer than one would anticipate by utilizing the technique of simulated quantum annealing (SQA) [99].Specifically, in [99] a method to rigorously demonstrate that the Markov chain underlying SQA effectively samples the target distribution and discovers the global minimum of the spike cost function in poly time supporting is developed.While the analysis is limited to a very specific model and cannot be considered conclusive, the authors use interesting techniques such as initiating warm starts (a very popular technique applied in Deep Learning [100] as well as in QAOA [101]), from the adiabatic path and using the quantum ground state probability distribution to comprehend the stationary distribution of SQA.
Interestingly, SQA might be considered effective, as compared to a purely classical algorithm, for optimization problems with spike (deep and narrow) global optima.As such, exploiting hybrid solvers that combine SQA and classical algorithms could offer an alternative approach [102] due to SQA's effectiveness in sampling target distributions.However, to the best of our knowledge, its applicability is currently limited to specific models, and the broader effectiveness remains an open question.

III. COLLATERAL OPTIMIZATION
In Section II, our main objective was to identify the most suitable formulations of the KnapsackProb as a QUBO.However, for smaller-scale problems, MILP solvers are generally expected to perform better than heuristic, hybrid, and near-term quantum solvers.Therefore, in this section, we first formulate the Collateral Optimization problem ColOpt as a MILP and subsequently re-formulate it as a QUBO, similar to the approach taken in Section II.
The objective is to conduct several small-scale problems utilizing hybrid solvers with the purpose of algorithmic reformulation of the problem and its implementation.The ultimate goal is not to demonstrate the potential of hybrid or quantum alternatives for combinatorial optimization, but rather to establish an automated approach to solving the problem once hardware capabilities become more advanced.In Table IV we describe the most common financial terms used in the context of ColOpt, while Table V summarises the mathematical notation that will be utilized in the following.

A. ColOpt MILP FORMULATION
In order to mitigate the risk of a borrower defaulting on a loan, it is necessary for them to furnish collateral in the form of stocks, bonds, cash, or other assets to offset any outstanding exposure.In the present scenario, we consider a financial institution that has a collection (or inventory) of assets, indicated by I, which must be allocated among a set of accounts, indicated by A. We shall use the indices i and j to refer to an asset and an account, respectively.The total number of assets and accounts is given by n and m, respectively.It should be noted that our primary focus in this section is on the algorithmic reformulation of the problem and its implementation, which could be automated once sufficiently powerful hardware becomes available.Consequently, we shall run a set of small-scale problems employing hybrid solver emulators as in Sec.II.Our objective is not to demonstrate the superior performance of hybrid or quantum alternatives for combinatorial optimization but rather to heuristically identify the most appropriate formulation of the problem at hand.Interestingly, ColOpt can be formulated as a bipartite matching problem as in Fig. 1.This bipartite graph is created with two sets of nodes: one set representing the inventory of assets I, and the other set representing accounts A. The edges between these nodes represent potential allocations of assets to accounts, with weights on these edges representing the suitability, cost, or value of the allocation, and the edges are multi-directed and need to respect certain constraints.To model the constraints of ColOpt modifies the graph accordingly, as we will explain below.
Limits.Delving deeper into the problem, consider each asset i k ∈ I, where I = i 1 , i 2 , . . ., i n .Each asset i (momentarily simplifying the indices) is subdivided into a maximum quantity denoted by a i .In more formal terms, there is a constraint on the maximum quantity of asset i that can be assigned.This is useful because, in the context of utilizing stocks as collateral, a financial institution may need or require the enforcement of an upper limit regarding the number of shares that can be allocated.The quantity of asset i k can be converted into a corresponding dollar value by multiplying by the dimensionful term v i , which is the market value (USD) per unit quantity.
Tiers.Every asset is linked to a tier, represented as ω i ∈ [0, 1].This tier acts as a measure of the asset's quality, where distinct tiers correspond to various degrees of quality or attractiveness in the context of the ColOpt problem.The higher the value of ω i , the higher the quality of asset i.
Exposure.When a financial institution borrows from one of its lenders, collateral must be posted to adequately cover capital that could be lost in the event of a default.This capital requirement is known as "exposure".For each account j, there is a required exposure (in USD) that must be met indicated by c j .Additionally, the duration of a transaction to a particular account can either be short term or long term.A binary variable d j ∈ {0, 1} is used to indicate the duration of account j.A value 1 is assigned to short term and 0 for long term transfers.To reduce the risk of losing posted collateral, it is required to minimize the use of high quality assets for long term transactions whilst maximizing their use for short term transactions.We chose our decision variable to be a matrix , where the element Q ij is the fractional amount of asset i that is allocated to account j.That is, the rows of Q correspond to the number of assets and the columns of the partition of each.
To illustrate an objective function that represents our goals consider the simple case of allocating a single asset, i, across two accounts, j and l, which have long and short term requirements, respectively.In this case, the objective function can be formulated as: In the expression above, the coefficient preceding short term allocations is set to 1−ω i .This is so that we favor allocations of higher quality assets for trades with a short duration.
To generalize this for all assets and accounts, we need a mechanism which updates these tiers according to the type of account they are posting collateral towards.This can be done by constructing a coefficients matrix Ω, where each element can be determined using: Just as with the tiers, each element of Ω has a range of [0, 1].The objective function is then just the sum of elementwise multiplications between Ω and Q: To post collateral such that the financial institution meets the exposure for each account, we include a requirement constraint: Here, v i denotes the dollar market value for a single unit of quantity for asset i.Hence, the term on the left-hand side represents the dollar value for the quantity of collateral that is chosen to be allocated, adjusted by a fractional factor H ij which is referred to as the haircut.Since markets are dynamic, the value of a posted collateral can diverge from its market value over time.In the case that the value drops below the required collateral value, the receiver is at risk.To avoid this, each account owner can evaluate the risk and place a haircut factor to reduce the value of an asset.The haircut is defined as the percentage difference between the market value and its value whilst used as collateral.For example, a haircut of 10% corresponds to H ij = 0.9, meaning the collateral value is 90% of the original market value.
We need to ensure that we do not allocate more collateral than we have available in inventory (i.e.we do not allocate more than 100% of the maximum available quantity).In financial terms, this prevents us from short selling the asset.This is done by including a consistency constraint: There is also the trivial constraint to make sure that Q ij does not take negative values: Further constraints that be can be imposed.For example, there may be limits on the amount of a particular asset i to account j, given by B ij .If B ij = 0, the allocation is not eligible.This is a one-to-one constraint and has the following mathematical form: Moreover, there are constraints that restrict the allocation of specific groups of assets to a single account, which exhibits a many-to-one relationship.For instance, certain types of assets, say {i X1 , i X2 , i X3 }, may be subject to restrictions due to their interrelationships (for example there exists a parent company X that posts these assets).To formalize this constraint, we introduce G, which represents the set of all groups of assets.The binary variable T ig is used to indicate whether asset i belongs to the group g, while K gj represents the upper bound on the total amount of assets from group g that can be allocated to account j: The aim of imposing limits on the allocation of assets is to promote diversification and thereby reduce the risk borne by the receiver.In this paper, we concentrate on allocating cash rather than equity and bonds, which allows us to avoid the constraint that Q ij a i must take an integer value.Consequently, we can formulate the problem of collateral optimization as a continuous optimization problem without the need for additional constraints.
The Complete ColOpt Problem.Taking into account the information presented in the previous paragraphs, we can express the ColOpt problem using a MILP formulation: For clarity, we will summarize the constraints presented above.Constraint (21b) ensures that no asset is distributed to the accounts beyond unity.Constraint (21c) amounts to the limit constraints for each asset-account pairing.Constraint (21d) limits the quantity of particular groups of assets to certain accounts but will be ignored in what follows.Constraint (21e) is the requirement constraint that enforces that we allocate a suitable value such that the lender's loan is secured.

B. ColOpt QUBO FORMULATION
Binarization.To formulate the QUBO, we need to make a change of variables so that our decision variable is represented by binaries.This change imposes certain limitations on the allocation of assets, which are discussed in detail below.We make use of an n-bit binary variable, similar to the methods used by Lang [103] and Ottaviani [104].To enable binary encoding of the decision variable Q, we can represent it as a matrix q containing binary elements.This transformation enables us to only allocate assets in a limited number of ways, as detailed below: Here, q ij is an n-bit binary variable expressing the fractional allocation of asset i to account j: where B is the number of bits chosen.Using B = 4 as an example, the largest number which can be represented by four bits is 1111 bin = 15 dec .Thus, we split our allocation into 15 fractions, where if q ij = 0100 bin = 4 dec then 4/15 of asset i is allocated to account j.By increasing B, we increase the precision of our allocations.
By implementing a similar method to Braun et.al. [105], we can discretize our fractional allocation by discretizing the interval (24) M is the maximum value which can be represented by a binary string of length B (M = 2 B − 1).Remark: have been included here for generality, but in our problem ij is always 1.The discretized amount of item i that is allocated to account j is then described by the dot product of the binary vector x ijb = (x ij1 , . . ., x ijB ) T and p ijb = (p ij1 , . . ., p ijB ) T .
where we use the Einstein summation convention (upperlower repeated indices contract) for brevity.By pairing each bit in the bit-string of q ij with a coefficient p ijb allows us to represent more values in the allowed range which improves accuracy.
The cost function is then written as: We then make the same replacement of in the remaining constraints of the problem to construct the binarized collateral optimization problem.Again, a wide number of classical solvers (open-source and commercial) are available which can find the global minimum of the problem in this form.
The total number of variables used to construct this binarized version of the problem is O(nmB).Since we have replaced the continuous variables with discrete binaries, the accuracy of the solution is expected to be reduced.This can be mitigated by increasing B, however, a compromise is needed between accuracy and resource usage.Regardless, the granularity for the fractional allocation is 1/M .Slack-based Formulation.We hereby introduce a QUBO formulation for the collateral optimization problem, incorporating slack variables.The constraints outlined in (21b) -(21e) significantly influence the number of bits necessary to encode these slack variables, potentially leading to an extensive bit requirement.To address this issue, we employ the log-encoding method earlier in Sec.II-C.
For constraints expressed as "less-than-or-equal-to" inequalities, the number of bits required to encode the slack variable can be readily computed using ⌈log 2 u⌉, where u represents the upper bound of the constraint.Nonetheless, addressing the requirement constraint (21e) necessitates a more nuanced approach.As the objective is to minimize the excess value of the collateral posted, employing slack variables might prove inadequate, since their purpose is to diminish the corresponding penalty term to 0 for any values satisfying this constraint.In contrast, within MILP frameworks, the solution to a minimization problem typically aligns closely with the lower bound of such a constraint.In light of this observation, we choose to alter the exposure requirement by transforming it into an equality constraint, thereby relaxing the original formulation: and as a result, the associated penalty term requires no slack variables.
Hence, with the objective of minimizing the associated penalty terms originating from the aforementioned expression, the QUBO should yield a solution conforming to the boundaries of the exposure constraints.A limitation of this strategy is the intrinsic stochastic characteristic of annealing techniques and their propensity to become ensnared in local minima, potentially resulting in marginally exceeding or not quite meeting the mandatory exposure.Furthermore, because the upper bound for each consistency constraint is equal to one, we need to adjust their form so that we can calculate the number of slack bits required.We proceed by rearranging the binarized version of this constraint which then attains a fractional form: ∀i ∈ I.By multiplying both sides by M , it is straightforward to realize that the highest value that can be represented by the bitstring is the one we use as our new upper bound, and this further allows us to easily determine the number of slack bits needed.
The penalty term for each of the n consistency constraints is written as: where S con is the slack variable for each constraint which is encoded by binary variables s k via: Instead of introducing a penalty term for one-to-one constraints (21c), we can ensure that these are satisfied by reducing the number of bits representing each allocation so that these limits cannot be violated.The number of bits representing an allocation, n ij , can be determined by: Note that now in (25) the upper limit of the summation is no longer B but now n ij as this is the number of bits representing the allocation q ij .We choose to floor the result from the logarithmic function, as the alternative would still allow violations.However, a consequence of this is that the one-to-one constraints in the QUBO are more restrictive than their MILP counterpart.
Aside from these nuances above and the additional step of binarization, constructing the balanced formulation for this QUBO follows the same process described above in the discussion of the KnapsackProb instance.For the manyto-one constraints (21d), we introduce log-encoded slack variables S Kij .It is straight-forward to derive the full QUBO objective as: Unbalanced formulation.The previous constraints, set in equations (21b) -(21f), can be converted into penalty terms for the QUBO through unbalanced penalization, as we displayed with the KnapsackProb instance in Sec.II-D.For this approach, auxiliary functions are defined from the constraints, and Taylor approximations of appropriate exponentiations of these functions are used to derive the penalty terms.For instance, consider the consistency constraint equation (21b).We move the upper bound to the LHS of the inequality and set this as our auxiliary function h(x): Since this is a 'less-equal to zero' inequality we use e h(x) to derive a penalty term that takes small values when this constraint is satisfied and large values when violated.As mentioned previously, QUBOs may only contain linear and quadratic terms so, therefore, we need to take a 2 nd order Taylor approximation to obtain: for all i ∈ I. Essentially, the first of these terms favor solutions which satisfy the constraint whilst being as far away from the upper bound as possible.The second term, instead, favors solutions which are as close to this upper bound.Effective tuning of the parameters is therefore necessary to balance the effects of each term.Note, however, in this case we do not need to relax the exposure constraint to an equality as we can better manage how far beyond the solution is from these lower bounds.This equation is valid only for one asset, therefore we can modify equation (34) to consider all assets: Following the same methods and the discussion on the one-to-one constraints used in the previous formulation, we can promote the remaining constraints to penalty terms in the QUBO.
The final QUBO can be written as:

IV. NUMERICAL ILLUSTRATIONS
Utilizing the formulations presented in Sec.III we now define a small instance of the ColOpt problem based on a synthetic (however realistic) small dataset.We perform our tests on an Apple MacBook Pro with M2 Max processor and 16GB of memory.We remark that unlike the KnapsackProb which even with a small instance of a few items has a relatively simple structure with a single constraint, the small ColOpt problem instance we describe below has more complex constraints, and the interdependencies between the accounts and assets lead to a larger QUBO matrix and a much more challenging optimization landscape.In what follows, we utilize simulated annealing (SA), which as a metaheuristic algorithm, [106] is quite sensitive to the problem structure and its performance can vary significantly depending on the problem instance.The increased complexity in the collateral optimization problem may make it harder for the SA to explore the solution space effectively, leading to suboptimal results or longer convergence times.In such cases, it might be beneficial to fine-tune the parameters of SA to improve its performance on more complicated problem instances.An interesting approach towards that direction was followed in [32] which, for our context, we leave for future work.
Concretely, we have a portfolio of ten assets that have an approximate combined value of $8.86M.These assets can be categorized by their tier rating, ω = {0.2,0.5, 0.8}, into low, mid, and high tiered assets, respectively.Furthermore, the number of assets belonging to each category is chosen to be 4, 2 and 4, respectively.These assets are to be distributed in order to meet the requirements of 5 accounts.These requirements are distinguished by their duration, two of which are long-term and have a combined exposure of ∼ $1.49M.The remaining are short-term requirements with a total exposure of ∼ $1.09M.
Due to restrictions, we slightly relax the problem by removing many-to-one constraints (21d).It is clear that in the absence of these constraints, this instance of the ColOpt has a global optimum that can be easily obtained using classical strategies.As mentioned earlier, a compromise was needed between the precision of our results and the run-time performance, along with the limitation of the total number of bits that can be implemented in the solvers.To do this, we set the length of the bitstring representing each allocation, (23), to be 7. Hence, the granularity of our allocations is 1/127 ≈ 0.0079%, (Since M = 127).In other words, the lowest percentage of available asset quantity we may post to any one account is approximately 0.0079%.This becomes important if an asset quantity is significantly large, as the corresponding solution will allocate more than what is necessary to meet the requirements.Also, if very strict limits were considered, many violations could occur if the bitstring length chosen was inadequate.To this effect, we ensure that our sample contains sensible values for the quantity of each asset so that they can be distributed with enough precision to satisfy the exposure requirements efficiently.If no inequality constraints are included in the instance, then a total of 350 qubits are required for both formulations (10 assets, 5 accounts, 7).However, due to the way we introduce the constraints, as discussed in the preceding section, we can reduce this number to 228 qubits in the case of the unbalanced formulation and 298 qubits for the balanced form, as the consistency constraint in this case still requires slack variables.
Solving QUBO equations to obtain results that accurately reflect the goal of the objective function whilst simultaneously satisfying all constraints relies on the fine-tuning of the Lagrange multipliers.A potential solution is to make use of "hybrid solvers" such as D-Wave's Constrained Quadratic Model (CQM) [107] which automatically calculates these, we instead use an intuitive approach.The consistency con-  straint (21b) is a hard constraint, as a solution that violates this constraint does not translate into a sensible business solution.Conversely, we treat the exposure requirement (21e) as a soft constraint and allow for small violations to some margin ϵ.Additionally, for both balanced and unbalanced formulations, it is important to note that there are significant differences between the magnitudes of the coefficients of each term in the QUBO.This can make fine-tuning of the penalty weights a difficult task.To manage this, we normalize each term in the QUBOs by dividing by their largest coefficient and then scale such that the lowest coefficient in each term has an order of magnitude of 1.We chose the weight for the cost function to be a magnitude larger than those of the constraints, so that we achieve high-quality solutions.We then retrospectively increase the weight of the exposure and consistency terms to ensure that the system's constraints are satisfied.Overall, our results were mixed in the sense that none of our runs managed to reach the global optimum nor to produce the globally optimal allocation with each run converging in a different local minimum.We estimate that one reason for this behavior is the limited number of runs performed that do not allow the annealing process to explore sufficient search space.This can be easily redeemed by increasing the number of runs (potentially decreasing the step size) and utilizing more compute power.However due to limited resources and compromising between computational runtime and the accuracy of the solution, we opted to chose a modest number of runs.
Table III displays the values chosen for each of the penalty weights and the resultant objective value that was outputted.Fig. 2 shows the global optimal solution solved using HiGHS.The asset allocations using neal and Fujitu's Digital Annealer are shown in Fig. 3. Additionally, Fig. 4 displays the percentage differences, for each of the solver, between the total values posted and the required exposures for all the accounts.

V. SUMMARY AND CONCLUSIONS
We surveyed the problem of collateral optimization from a business perspective and provided a business-realistic MILP formulation suitable to be mapped to a QUBO.In turn, we provided two QUBO formulations, one based on slack variables and one based on unbalanced penalization, and we implemented a small ColOpt problem instance on small emulations of hybrid solvers.We observed that the unbalanced penalization approach yields objective function values much closer to the global optimum, obtained using the simplex method, while the slack-based (balanced) approaches were further off.To this end, both approaches fail to find the global optimum even for such a relatively small, but non-trivial, problem instance.While we did not run our computations on specialized hardware (quantum annealer or digital annealer), to some extent, we indeed rediscover the expectation that heuristic approaches fail to find globally optimal solutions very often, including when implemented in quantum hardware [108].The "take-home message" from the numerical illustrations clearly showcases the relevance of the formulation chosen for a given problem when one is interested in making it quantum-ready.
Note, however, that the aim of this paper is to show the relevance as well as the technical formulation of the collateral optimization problem for quantum or hybrid solutions rather than to perform a detailed benchmarking and, as a matter of fact, several improvements can be performed in order to obtain higher quality solutions (warm starting techniques, optimizing the annealing schedule, QUBO parameter optimization, utilization of GPU and tensor cores, and explore improved methods for SA [109]).
The question of whether MILPs such as the collateral optimization problem should be cast as QUBOs and approached by heuristic solvers (quantum or not) is tricky.To some extent, classical solvers such as Gurobi, CPLEX, or even HiGHS perform exceptionally well in many large instances.Improving thereof could be less or more beneficial depending  The percentage of the exposure requirements that have been met for each account.The dashed line represents the solution given by HiGHS solver which perfectly meets each requirement.We see greater deviations for the requirement of account 4, which is due to its outstanding exposure being an order of magnitude less than those of the other accounts, hence it has a lower weighting in the QUBO.on the situation or problem instance and its complexity.If a "quantum" solution is preferred, finding the ultimate strategy for this approach is a crucial problem (formulation of the problem, hyperparameter choice, solver choice, etc).
The ColOpt problem, as presented above, can be extended in a variety of ways.The formulations provided above are in no way unique and further investigation might yield better results even for the local solvers.For example, recent research [110] has shown that an alternative formulation based on implicit penalization by restricting the Hamiltonian dynamics, in the context of parallelized QAOA, can be powerful and such an approach can be suitable for the collateral optimization problem as well.A different approach based on a stochastic quantum Monte Carlo algorithm, that mimics quantum annealing, was proposed [111] for such large-scale optimization problems making it another suitable candidate for ColOpt.The benefit of this approach is that it can handle fully connected graphs which can be the case in certain ColOpt instances.that interacts with each site [33].The overall minus sign is just a convention3 and ε refers to a constant energy overhead.
In the quantum version of the Ising Hamiltonian, the sites are represented by a qubit.The spins are then simply given by the Pauli matrix σ z j acting on the j'th site, with eigenvalues ±1 when acting on the computational basis states {|0⟩, |1⟩}.In physics, the interesting problem is typically to find the ground state energy, or lowest energy eigenstate, of the Hamiltonian.
One thing we can immediately notice is that this model is quadratic in the spins and thus resembles the QUBO.By the simple change of variables x j = 1−σj 2 we directly see that the spin variables ±1 are mapped to the binary variables {0, 1}.In the quantum version we map the QUBO variables x j to the operators x j = 1 1 1 ⊗ ... ⊗ 1 2 (1 1 1 − σ z ) ⊗ 1 1 1 ⊗ ..., where the non-trivial operator acts on the j'th site.This operator has eigenvalues 0 or 1 when acting on the states |0⟩ respectively |1⟩.Trough this change of variables, the QUBO problem is thus equivalent to finding the ground state energy of the Ising Hamiltonian.When mapping between the QUBO and the Ising model we might also need to account for the fact that we only minimise over the Ising model, while sometimes, for example in the KnapsackProb, we are seeking a maximum.This is of course easily accounted for by changing the relevant signs.
As an example, the KnapsackProb (8) has an Ising Hamiltonian with:

FIGURE 1 :
FIGURE 1: Schematic representation of the collateral optimization problem.The figure above can be seen as a bipartite graph where one has to make optimal allocation of nonunique and weighted pairings.

FIGURE 2 :
FIGURE 2: The optimal allocations of assets among accounts with short term (red) and long term (blue) requirements, determined through solving the ColOpt instance as a continuous LP with HiGHS.Assets IDs of 1 − 4 are low-tier, 5 − 6 are mid-tier and the final 7 − 10 are the high-tier assets.

FIGURE 3 :
FIGURE 3: The allocation, of different assets amongst accounts with short term (red) and long term (blue) requirements.Results are determined by D-Wave's simulated annealer (top) and Digital annealer (bottom) with balanced (left) and unbalanced (right) formulations.The asset IDs of 1 − 4 are low-tier, 5 − 6 are mid-tier and the final 7 − 10 are the high-tier assets.

FIGURE 4 :
FIGURE 4:  The percentage of the exposure requirements that have been met for each account.The dashed line represents the solution given by HiGHS solver which perfectly meets each requirement.We see greater deviations for the requirement of account 4, which is due to its outstanding exposure being an order of magnitude less than those of the other accounts, hence it has a lower weighting in the QUBO.

TABLE I :
Input data used of the specific KnapsackProb instance considered in this paper.The total capacity of the knapsack is 165.
Table II, we provide a list of MILP and QUBO solvers, using the two aforementioned approaches, slackbased and unbalanced.

TABLE II :
Summary of methods used to solve the provided instance of the KnapsackProb.All methods found the optimal solution.

TABLE III :
Values used for tuning the Lagrangian multipliers for each term in the QUBO for differing implementations.The objective value obtained for running this solution is also documented and for comparison, the value obtained by a continuous solver is displayed.