{"id":3347,"date":"2025-04-16T05:23:52","date_gmt":"2025-04-16T09:23:52","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=3347"},"modified":"2025-09-23T05:23:58","modified_gmt":"2025-09-23T09:23:58","slug":"solving-practical-problems-on-quantum-computers-and-quantum-inspired-hardware-with-quadratic-unconstrained-binary-optimization-qubo","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2025\/04\/16\/solving-practical-problems-on-quantum-computers-and-quantum-inspired-hardware-with-quadratic-unconstrained-binary-optimization-qubo\/","title":{"rendered":"Solving practical problems on quantum computers and quantum-inspired hardware with Quadratic Unconstrained Binary Optimization (QUBO)"},"content":{"rendered":"
In my <\/span>first article on quantum computing<\/span><\/a> I took a look at gate based quantum computing using the <\/span>MATLAB Support Package for quantum computing<\/span><\/a>. This is when we program a quantum computer by constructing quantum circuits such as this:<\/span><\/div>
% Optimized 7 qubit GHZ state taken from https:\/\/www.ibm.com\/quantum\/blog\/whole-device-entanglement<\/span><\/span><\/div><\/div>
gates = [hGate(1);cxGate(1,4); cxGate(1,2);cxGate(4,6);cxGate(2,3);cxGate(4,5);cxGate(6,7)];<\/span><\/span><\/div><\/div>
ghz_state = quantumCircuit(gates);<\/span><\/span><\/div><\/div>
p = plot(ghz_state);<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
My article showed how to use MATLAB to simulate such quantum circuits on your desktop or laptop and also how to run them on real quantum hardware in the cloud. MATLAB's documentation includes several examples of how to use gate based quantum computing to solve real world problems such as <\/span>Graph Coloring<\/span><\/a> and <\/span>Ground-State Protein Folding<\/span><\/a>. <\/span><\/div>
Although important, gate based quantum computers aren't the only type of quantum computer in town.<\/span><\/div>
There is another!<\/span><\/div>

Quadratic Unconstrained Binary Optimization (QUBO) - The key to programming quantum annealers<\/span><\/h2>
A QUBO<\/span> problem<\/span><\/a> is a type of optimisation problem. We'll get to the details later. What you need to know right now is that it turns out that a huge variety of important optimization problems that arise in industry, science and government [1] can be transformed into <\/span>qubo<\/span> problems. In turn, QUBO problems can be efficiently solved using a class of quantum hardware called <\/span>quantum annealers<\/span><\/a>. So, programming a quantum annealer can be reduced to 'How do I transform my problem into a QUBO problem?<\/span><\/div>

A veritable zoo of hardware and software can solve QUBO problems<\/span><\/h4>
Quantum annealers aren't the only hardware type that can solve QUBO problems. There's also a fascinating set of <\/span>quantum-inspired<\/span> hardware devices that can do the job such as Complementary Metal Oxide Semiconductor (CMOS) annealers. Other groups have developed a set of powerful metaheuristic algorithms that work on classical hardware including both CPUs and GPUs. One of these algorithms, <\/span>tabu search<\/span><\/a>, is built into MATLAB's Quantum Computing support package. Finally, you can also solve QUBO problems on gate-based quantum hardware which is something I'll explore in a future article.<\/span><\/div>
In short, if you can pose your problem as a QUBO problem, you can run it on a whole zoo of devices with very little additional effort.<\/span> Which hardware or software combination is best is very much problem dependent.<\/span><\/div>

What is a QUBO problem and how do I solve one in MATLAB?<\/span><\/h4>
The QUBO optimization problem is:<\/span><\/div>
QUBO: minimize\/maximize <\/span>$ y = x^t Q x $<\/span><\/div>
where x is a vector of binary decision variables (0 or 1) and Q is a square matrix of constants<\/span><\/div>
An example of a QUBO problem that first helped me make sense of what this means is given in the paper <\/span>Quantum Bridge Analytics I: A Tutorial on Formulating and Using QUBO Models<\/span><\/a> [1] so I'll reproduce it here.<\/span><\/div>
Minimize <\/span>$ y = -5x_1 - 3x_2 - 8x_3 -6x_4 + 4x_1x_2 + 8x_1x_3 + 2x_2x_3 + 10x_3x_4 $<\/span> where the variables <\/span>$ x_j $<\/span> are binary. <\/span><\/div>
This has a linear part, <\/span>$ y = -5x_1 - 3x_2 - 8x_3 -6x_4 $<\/span> and a quadratic part <\/span>$ y = 4x_1x_2 + 8x_1x_3 + 2x_2x_3 + 10x_3x_4 $<\/span>. We can input this into MATLAB using the <\/span>qubo<\/span><\/a> function which is part of the <\/span>MATLAB Support Package for Quantum Computing<\/span><\/a>.<\/span><\/div>
Q = [0 2 4 0; 2 0 1 0; 4 1 0 5; 0 0 5 0]; <\/span>% Quadratic part<\/span><\/span><\/div><\/div>
c = [-5; -3; -8; -6]; <\/span>% Linear part<\/span><\/span><\/div><\/div>
problem = qubo(Q, c)<\/span><\/span><\/div>
problem = <\/span><\/div>
qubo with properties:\r\n\r\n QuadraticTerm: [4\u00d74 double]\r\n LinearTerm: [4\u00d71 double]\r\n ConstantTerm: 0\r\n NumVariables: 4\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Since binary variables satisfy <\/span>x<\/mi><\/mrow>j<\/mi><\/mrow><\/msub>=<\/mo>x<\/mi><\/mrow>j<\/mi><\/mrow>2<\/mn><\/mrow><\/msubsup><\/mrow><\/math><\/span> , the linear part can be written as <\/span>$ y = -5x_1^2 - 3x_2^2 - 8x_3^2 -6x_4^2 $<\/span> and so our problem can be also be written as<\/span><\/div>
Minimize <\/span>[<\/mo>x<\/mi><\/mrow>1<\/mn><\/mrow><\/msub><\/mrow><\/mtd>x<\/mi><\/mrow>2<\/mn><\/mrow><\/msub><\/mrow><\/mtd>x<\/mi><\/mrow>3<\/mn><\/mrow><\/msub><\/mrow><\/mtd>x<\/mi><\/mrow>4<\/mn><\/mrow><\/msub><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>[<\/mo>-<\/mo>5<\/mn><\/mrow><\/mtd>2<\/mn><\/mrow><\/mtd>4<\/mn><\/mrow><\/mtd>0<\/mn><\/mrow><\/mtd><\/mtr>2<\/mn><\/mrow><\/mtd>-<\/mo>3<\/mn><\/mrow><\/mtd>1<\/mn><\/mrow><\/mtd>0<\/mn><\/mrow><\/mtd><\/mtr>4<\/mn><\/mrow><\/mtd>1<\/mn><\/mrow><\/mtd>-<\/mo>8<\/mn><\/mrow><\/mtd>5<\/mn><\/mrow><\/mtd><\/mtr>0<\/mn><\/mrow><\/mtd>0<\/mn><\/mrow><\/mtd>5<\/mn><\/mrow><\/mtd>-<\/mo>6<\/mn><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>[<\/mo>x<\/mi><\/mrow>1<\/mn><\/mrow><\/msub><\/mrow><\/mtd><\/mtr>x<\/mi><\/mrow>2<\/mn><\/mrow><\/msub><\/mrow><\/mtd><\/mtr>x<\/mi><\/mrow>3<\/mn><\/mrow><\/msub><\/mrow><\/mtd><\/mtr>x<\/mi><\/mrow>4<\/mn><\/mrow><\/msub><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mrow><\/math><\/span><\/div>
This is exactly the form used in the definition of a QUBO problem above. If I prefer, I can also construct the QUBO problem in MATLAB using this matrix directly<\/span><\/div>
Q = [-5 2 4 0; 2 -3 1 0; 4 1 -8 5; 0 0 5 -6];<\/span><\/span><\/div><\/div>
problem = qubo(Q)<\/span><\/span><\/div>
problem = <\/span><\/div>
qubo with properties:\r\n\r\n QuadraticTerm: [4\u00d74 double]\r\n LinearTerm: [4\u00d71 double]\r\n ConstantTerm: 0\r\n NumVariables: 4\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Both formulations are equivalent so we can use whatever we prefer. Let's request the solution<\/span><\/div>
solution = solve(problem)<\/span><\/span><\/div>
solution = <\/span><\/div>
quboResult with properties:\r\n\r\n BestX: [4\u00d71 double]\r\n BestFunctionValue: -11\r\n AlgorithmResult: [1\u00d71 tabuSearchResult]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
So, the minimum of our function is -11 and the set of <\/span>x<\/mi><\/mrow>j<\/mi><\/mrow><\/msub><\/mrow><\/mi><\/mrow><\/msub><\/mrow><\/math><\/span>that gives this is<\/span><\/div>
solution.BestX<\/span><\/span><\/div>
ans = <\/span>4\u00d71<\/span><\/div><\/div>
1\r\n 0\r\n 0\r\n 1\r\n<\/div>
<\/mw-icon><\/div>
<\/mw-icon><\/div><\/div><\/div>
<\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>
MATLAB currently makes use of the <\/span>Tabu search algorithm<\/span><\/a> to solve QUBO problems on your local machine. Tabu search is a stochastic algorithm, so each time you run the algorithm, you might get a different result and there is no guarantee that it finds the global minimum. In this case, however, we are OK. This is the global minimum and you could even check by exhaustive evaluation without much difficulty. <\/span><\/div>
Finally, for the sake of illustration, let's explicitly evaluate the function we've minimized with the vector <\/span>BestX<\/span> found above.<\/span><\/div>
(solution.BestX)' * Q * solution.BestX<\/span><\/span><\/div>
ans = <\/span>-11<\/div><\/div><\/div><\/div><\/div><\/div>
This matches what MATLAB reported in the QUBO <\/span>solution<\/span> and so now I have some confidence that I understand what's going on:<\/span><\/div>
solution.BestFunctionValue<\/span><\/span><\/div>
ans = <\/span>-11<\/div><\/div><\/div><\/div><\/div><\/div>
This might not look like much but it turns out that a vast array of important problems that arise in real applications can be turned into QUBO problems<\/span><\/div>

What problems can be solved using QUBO?<\/span><\/h4>
Initially, QUBO seemed quite unassuming to me It's such a simple problem statement that I couldn't imagine that you could do much with it. I could not be more wrong! Examples from MATLAB's documentation include <\/span>Traveling Salesperson Problem<\/span><\/a>, <\/span>Capacitated Vehicle Routing Problem<\/span><\/a> and <\/span>Feature Selection<\/span><\/a> for Machine Learning but these are just the tip of the iceberg. A quick scan of the literature reveals dozens of important problems that can be reposed as QUBO problems : <\/span>Maximum cut<\/span><\/a> problems, Capital Budgeting problems, Task Allocation Problems, <\/span>Quadratic Knapsack<\/span><\/a>, Warehouse location problems, portfolio optimisation and much much more. An active area of research is to uncover more problems that can be tackled by QUBO, I guess because this means that the problem in question can then be tackled by quantum annealing computers and other quantum-inspired hardware.<\/span><\/div>
Although the U in QUBO stands for unconstrained, it is possible to tackle constrained problems by making use of penalty functions. This is discussed in the MATLAB documentation <\/span>Constraints in QUBO Problems<\/span><\/a> and also in Glover et al [1]. <\/span><\/div>
Many interesting problems can be formulated as QUBOs and the number of problems that can be solved in this way is expanding all the time. A colleague sent me a <\/span>great list that's being maintained by blogger Daniel Ratke<\/span><\/a> that has over 110 problems at the time of writing.<\/span><\/div>
One of these is the <\/span>traveling salesperson problem.<\/span> Here is an abridged version of the <\/span>demo in the MATLAB documentation<\/span><\/a>. Let's make up a bunch of randomly distributed cities.<\/span><\/div>
N = 9; <\/span>% Number of cities<\/span><\/span><\/div><\/div>
rng <\/span>default <\/span>% For <\/span>reproducibility<\/span><\/span><\/div><\/div>
stopsLon = 1.5*rand(N,1);<\/span><\/span><\/div><\/div>
stopsLat = rand(N,1);<\/span><\/span><\/div><\/div>
plot(stopsLon,stopsLat,<\/span>\"ko\"<\/span>)<\/span><\/span><\/div><\/div><\/div>
Calculate the distances between the cities using the <\/span>hypot<\/span> function.<\/span><\/div>
[X,Y] = meshgrid(1:N);<\/span><\/span><\/div><\/div>
dist = hypot(stopsLon(X) - stopsLon(Y),stopsLat(X) - stopsLat(Y));<\/span><\/span><\/div><\/div><\/div>
We convert this to a QUBO problem using the custom function <\/span>described in the MATLAB documentation<\/span><\/a>. <\/span><\/div>
Qtsp = tsp2qubo(dist)<\/span><\/span><\/div>
Qtsp = <\/span><\/div>
qubo with properties:\r\n\r\n QuadraticTerm: [81\u00d781 double]\r\n LinearTerm: [81\u00d71 double]\r\n ConstantTerm: 2.0751e+03\r\n NumVariables: 81\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
We've already seen how to solve QUBO problems in MATLAB so we just have to plug this problem into the same framework.<\/span><\/div>
% Solve the QUBO problem using MATLAB<\/span><\/span><\/div><\/div>
MATLABresult = solve(Qtsp)<\/span><\/span><\/div>
MATLABresult = <\/span><\/div>
quboResult with properties:\r\n\r\n BestX: [81\u00d71 double]\r\n BestFunctionValue: 4.0665\r\n AlgorithmResult: [1\u00d71 tabuSearchResult]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Finally, we need to interpret the result showing the optimal way to visit these cities<\/span><\/div>
binx = MATLABresult.BestX;<\/span><\/span><\/div><\/div>
binx = reshape(binx,N,[]);<\/span><\/span><\/div><\/div>
ordr = zeros(1,N);<\/span><\/span><\/div><\/div>
for <\/span>i = 1:N<\/span><\/span><\/div><\/div>
ordr(i) = find(binx(i,:)); <\/span>% Find order of cities in route<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
 <\/div><\/div>
hold <\/span>on<\/span><\/span><\/div><\/div>
plot(stopsLon(ordr),stopsLat(ordr),<\/span>\"ko\"<\/span>)<\/span><\/span><\/div><\/div>
plot(stopsLon(ordr),stopsLat(ordr),<\/span>\"b-\"<\/span>)<\/span><\/span><\/div><\/div>
plot(stopsLon(ordr([N 1])),stopsLat(ordr([N,1])),<\/span>\"b-\"<\/span>)<\/span><\/span><\/div><\/div>
for <\/span>i = 1:length(stopsLon)<\/span><\/span><\/div><\/div>
text(stopsLon(i)+0.02,stopsLat(i),num2str(i))<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
title(<\/span>\"Solution to traveling salesperson problem using QUBO\"<\/span>)<\/span><\/span><\/div><\/div>
hold <\/span>off<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
<\/div><\/div><\/div><\/div><\/div>

Solving QUBO problems on real quantum annealing hardware (and other devices) using Strangeworks<\/span><\/h4>
One of the reasons why there has been so much excitement around QUBO problems recently is that they can be directly solved on <\/span>Quantum Annealers<\/span><\/a> such as those developed by D-Wave along with several other specialized hardware and software platforms such as <\/span>Hitachi CMOS Annealers<\/span><\/a> and <\/span>Simulated Quantum Bifurcation Machines (SQBM)<\/span><\/a> by Toshiba.<\/span><\/div>
To do this on MATLAB as of R2024b, we can make use of the Strangeworks platform. If you are wondering who Strangeworks are, you can head over to their website and ask their ChatAI cat called Schr\u00f6dy (get it?)<\/span><\/div>
\"\"<\/img><\/a> <\/span><\/div>
Me<\/span>: Tell me who Strangeworks are in three sentences<\/span><\/div>
Schr\u00f6dy:<\/span> Strangeworks is a company that specializes in quantum computing, aiming to make quantum computing accessible to a broad audience. They provide a platform that allows researchers, developers, and enthusiasts to collaborate on quantum computing projects, offering tools to write, test, and run quantum code. Strangeworks collaborates with industry leaders in quantum computing to integrate various quantum technologies into their platform, making it a hub for quantum computing resources.<\/span><\/div>

A demo using Strangeworks<\/span><\/h4>
Install and configure the Strangeworks<\/span> SDK<\/span><\/a> that's available on the MathWorks File Exchange, have a chat with their sales team to hook you up with access to the hardware (<\/span>https:\/\/strangeworks.com\/#contact<\/span><\/a>)<\/span> and you are good to go. <\/span><\/div>
First we connect to the Strangeworks platform's optimization service. You get your <\/span>apiKey<\/span> and <\/span>resource_slug<\/span> from their website once you have an account.<\/span><\/div>
% This won't work unless you use your correct apiKey and resource_slug<\/span><\/span><\/div><\/div>
apiKey = <\/span>\"\"<\/span>;<\/span><\/span><\/div><\/div>
resource_slug = <\/span>\"\"<\/span>; <\/span>% This must be the resource slug related to their optimization service<\/span><\/span><\/div><\/div>
 <\/div><\/div>
sw = strangeworks().authenticate(apiKey);<\/span><\/span><\/div><\/div>
sw = sw.get_resource(resource_slug);<\/span><\/span><\/div><\/div>
fprintf(<\/span>\"Connected to SW service : %s \\n\"<\/span>, sw.product_slug)<\/span><\/span><\/div>
Connected to SW service : optimization <\/div><\/div><\/div><\/div><\/div>
The great thing about this service is that it makes it trivial to submit our QUBO problem to a range of very different hardware platforms via Strangeworks. <\/span><\/div>
Let's solve our traveling salesperson QUBO problem using Toshiba's Simulated Bifurcation Machine (SBM).<\/span><\/div>
solver = <\/span>\"toshiba.qubo\"<\/span>;<\/span><\/span><\/div><\/div>
solver_options = struct();<\/span><\/span><\/div><\/div>
job = sw.run(solver, Qtsp, solver_options)<\/span><\/span><\/div>
Submitting job<\/div><\/div>
job = struct with fields:<\/span><\/span><\/div>
job_slug: 'floral-eagle-0186'\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
The Strangeworks platform assigns a unique name to the job called a <\/span>job_slug<\/span> which we use to query if the job has completed or not and also to fetch results.<\/span><\/div>
job_slug = <\/span>\"floral-eagle-0186\"<\/span><\/span><\/div>
job_slug = <\/span>\"floral-eagle-0186\"<\/div><\/div><\/div><\/div><\/div>
sw.status(job_slug)<\/span><\/span><\/div>
ans = <\/span>'COMPLETED'<\/div><\/div><\/div><\/div><\/div><\/div>
Now we can get the result.<\/span><\/div>
QuantumResult = sw.result(job_slug)<\/span><\/span><\/div>
QuantumResult = struct with fields:<\/span><\/span><\/div>
result: [81\u00d71 double]\r\n energy: 4.0665\r\n variables: [81\u00d71 double]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Extract the order we should visit each city from this result.<\/span><\/div>
QuantumMinimum = QuantumResult.energy;<\/span><\/span><\/div><\/div>
QuantumBinx = QuantumResult.result;<\/span><\/span><\/div><\/div>
QuantumBinx = reshape(QuantumBinx,N,[]);<\/span><\/span><\/div><\/div>
QuantumOrdr = zeros(1,N);<\/span><\/span><\/div><\/div>
for <\/span>i = 1:N<\/span><\/span><\/div><\/div>
QuantumOrdr(i) = find(QuantumBinx(i,:)); <\/span>% Find order of cities in route<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div><\/div>
Comparing this to the MATLAB result, we can see that it's just as good but there is a different starting position for the optimal tour. There are minor differences in the naming convention between the result from Strangeworks and the native MATLAB result but it's straightforward to see how they compare to each other. <\/span><\/div>
MATLABresult<\/span><\/span><\/div>
MATLABresult = <\/span><\/div>
quboResult with properties:\r\n\r\n BestX: [81\u00d71 double]\r\n BestFunctionValue: 4.0665\r\n AlgorithmResult: [1\u00d71 tabuSearchResult]\r\n<\/div><\/div><\/div><\/div><\/div>
MATLABMinimum = MATLABresult.BestFunctionValue;<\/span><\/span><\/div><\/div>
MATLABBinx = MATLABresult.BestX;<\/span><\/span><\/div><\/div>
MATLABBinx = reshape(MATLABBinx,N,[]);<\/span><\/span><\/div><\/div>
MATLABOrdr = zeros(1,N);<\/span><\/span><\/div><\/div>
for <\/span>i = 1:N<\/span><\/span><\/div><\/div>
MATLABOrdr(i) = find(MATLABBinx(i,:)); <\/span>% Find order of cities in route<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
disp(table([QuantumMinimum;MATLABMinimum],[QuantumOrdr;MATLABOrdr], <\/span>...<\/span><\/span><\/div><\/div>
RowNames=[<\/span>\"MATLAB Tabu\"<\/span>,<\/span>\"Strangeworks (Toshiba)\"<\/span>],VariableNames=[<\/span>\"BestFunctionValue\"<\/span>,<\/span>\"Visits\"<\/span>]))<\/span><\/span><\/div>
BestFunctionValue<\/strong> Visits<\/strong> \r\n _________________<\/strong> _________________________________________<\/strong>\r\n\r\n MATLAB Tabu <\/strong> 4.0665 9 2 5 8 7 6 3 1 4\r\n Strangeworks (Toshiba)<\/strong> 4.0665 2 5 8 7 6 3 1 4 9<\/div><\/div><\/div><\/div><\/div>
The two solution methods have essentially come up with the same result. In practice, it doesn't matter which city you start from within this problem.<\/span><\/div>
One of the nice things with using MATLAB and the Strangeworks platform is that I've now done all of the programming I need to do in order to run this problem on many different hardware and software platforms. Once I have access to the required resources on the StangeWorks platform, all I do is change the solver. I could try Gurobi's QUBO optimisation service, for example.<\/span><\/div>
solver = <\/span>\"gurobi.qubo\"<\/span>;<\/span><\/span><\/div><\/div>
solver_options = struct();<\/span><\/span><\/div><\/div>
job = sw.run(solver, Qtsp, solver_options)<\/span><\/span><\/div>
Submitting job<\/div><\/div>
job = struct with fields:<\/span><\/span><\/div>
job_slug: 'winter-dust-0907'\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
gurobiResult = sw.result(<\/span>\"winter-dust-0907\"<\/span>)<\/span><\/span><\/div>
gurobiResult = struct with fields:<\/span><\/span><\/div>
result: [81\u00d71 double]\r\n energy: 4.0665\r\n variables: [81\u00d71 double]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
If you have access to them on your Strangeworks account, It would be just as easy to switch to using quantum computers from D-Wave, CMOS Annealing machines from Hitachi or a range of other systems but I didn't have access to them as part of this trial. <\/span><\/div>
In this case, all of the solvers I tried returned the same result other than having different starting cities. For such a small problem, this is what you'd expect but you could imagine that for much larger problems differences between solution quality, cost and execution time will emerge. <\/span><\/div>
The combination of MATLAB and Strangeworks is a great way to explore this solution space.<\/span><\/div>

To QUBO, or not to QUBO, that is the question:<\/span><\/h2>
The Quadratic Unconstrained Binary Optimization (QUBO) formulation is attractive due to its compatibility with emerging hardware paradigms such as quantum annealers and other quantum-inspired hardware. However, as with any modeling approach, the decision to frame a problem as a QUBO or not is not always straightforward. <\/span><\/div>
The combination of MATLAB's support for Quantum Computing and Strangeworks' straightforward access to a range of hardware and software solvers helps you make this decision in practice. <\/span><\/div>
References and further study<\/span><\/div>
[1] Fred Glover, Gary Kochenberger, Yu Du (2022), <\/span>A Tutorial on Formulating and Using QUBO Models<\/span><\/a>, Annals of OR<\/span><\/div>
[2] Abraham Punnen (ed) (2022), <\/span>The QUBO Problem: Theory, Algorithms and Applications<\/span><\/a>, Springer <\/span><\/div>
[3] Andrew Lucas.<\/span> <\/span>Ising formulations of many NP problems<\/span>. Available at<\/span> <\/span>https:\/\/arxiv.org\/pdf\/1302.5843.pdf<\/span><\/a>.<\/span><\/div>
[4] Gary Kochenberger, Jin-Kao Hao, Fred Glover, Mark Lewis, Zhipeng L\u00fc, Haibo Wang & Yang Wang (2014), \"The Unconstrained Binary Quadratic Programming Problem: A Survey\". Journal of Combinatorial Optimization, Vol. 28, Issue 1, pp. 58-81.<\/span><\/div>
[5] <\/span>Advances for Quantum-Inspired Optimization<\/span><\/a> (2022), YouTube video from the authors of [1]<\/span><\/div>
[6] <\/span>List of QUBO formulations:<\/span><\/a> A blog post containing a list of over 100 optimization problems with references to their QUBO formulation, <\/span><\/div>\r\n<\/div>