CA3140980A1  Systems for emulating a quantum computer and methods for use therewith  Google Patents
Systems for emulating a quantum computer and methods for use therewithInfo
 Publication number
 CA3140980A1 CA3140980A1 CA3140980A CA3140980A CA3140980A1 CA 3140980 A1 CA3140980 A1 CA 3140980A1 CA 3140980 A CA3140980 A CA 3140980A CA 3140980 A CA3140980 A CA 3140980A CA 3140980 A1 CA3140980 A1 CA 3140980A1
 Authority
 CA
 Canada
 Prior art keywords
 columns
 column
 weights
 variable assignments
 final
 Prior art date
 Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
 Pending
Links
 238000000034 method Methods 0.000 title claims description 41
 238000005070 sampling Methods 0.000 claims abstract description 37
 238000009826 distribution Methods 0.000 claims description 14
 238000005457 optimization Methods 0.000 claims description 8
 230000001172 regenerating effect Effects 0.000 claims description 4
 238000010586 diagram Methods 0.000 description 20
 230000006870 function Effects 0.000 description 15
 230000008878 coupling Effects 0.000 description 10
 238000010168 coupling process Methods 0.000 description 10
 238000005859 coupling reaction Methods 0.000 description 10
 238000000354 decomposition reaction Methods 0.000 description 4
 230000000694 effects Effects 0.000 description 3
 238000003491 array Methods 0.000 description 2
 238000004519 manufacturing process Methods 0.000 description 2
 239000011159 matrix material Substances 0.000 description 2
 230000003068 static effect Effects 0.000 description 2
 241001640034 Heteropterys Species 0.000 description 1
 108010076504 Protein Sorting Signals Proteins 0.000 description 1
 238000013473 artificial intelligence Methods 0.000 description 1
 238000010276 construction Methods 0.000 description 1
 238000005516 engineering process Methods 0.000 description 1
 230000003203 everyday effect Effects 0.000 description 1
 230000002349 favourable effect Effects 0.000 description 1
 239000000463 material Substances 0.000 description 1
 239000000203 mixture Substances 0.000 description 1
 238000000302 molecular modelling Methods 0.000 description 1
 230000005433 particle physics related processes and functions Effects 0.000 description 1
 238000003909 pattern recognition Methods 0.000 description 1
 230000002093 peripheral effect Effects 0.000 description 1
 230000005233 quantum mechanics related processes and functions Effects 0.000 description 1
 230000011664 signaling Effects 0.000 description 1
 238000004088 simulation Methods 0.000 description 1
 238000003860 storage Methods 0.000 description 1
 210000003813 thumb Anatomy 0.000 description 1
 VLCQZHSMCYCDJLUHFFFAOYSAN tribenuron methyl Chemical compound COC(=O)C1=CC=CC=C1S(=O)(=O)NC(=O)N(C)C1=NC(C)=NC(OC)=N1 VLCQZHSMCYCDJLUHFFFAOYSAN 0.000 description 1
Classifications

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06F—ELECTRIC DIGITAL DATA PROCESSING
 G06F9/00—Arrangements for program control, e.g. control units
 G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
 G06F9/44—Arrangements for executing specific programs
 G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06F—ELECTRIC DIGITAL DATA PROCESSING
 G06F15/00—Digital computers in general; Data processing equipment in general
 G06F15/76—Architectures of general purpose stored program computers
 G06F15/80—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06F—ELECTRIC DIGITAL DATA PROCESSING
 G06F15/00—Digital computers in general; Data processing equipment in general
 G06F15/76—Architectures of general purpose stored program computers
 G06F15/82—Architectures of general purpose stored program computers data or demand driven

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06F—ELECTRIC DIGITAL DATA PROCESSING
 G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
 G06F17/10—Complex mathematical operations
 G06F17/11—Complex mathematical operations for solving equations, e.g. nonlinear equations, general mathematical optimization problems

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06F—ELECTRIC DIGITAL DATA PROCESSING
 G06F9/00—Arrangements for program control, e.g. control units
 G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
 G06F9/44—Arrangements for executing specific programs
 G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
 G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
 G06F9/45508—Runtime interpretation or emulation, e g. emulator loops, bytecode interpretation

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
 G06N10/00—Quantum computing, i.e. information processing based on quantummechanical phenomena
 G06N10/40—Physical realisations or architectures of quantum processors or components for manipulating qubits, e.g. qubit coupling or qubit control

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
 G06N10/00—Quantum computing, i.e. information processing based on quantummechanical phenomena
 G06N10/60—Quantum algorithms, e.g. based on quantum optimisation, quantum Fourier or Hadamard transforms

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
 G06N10/00—Quantum computing, i.e. information processing based on quantummechanical phenomena
 G06N10/80—Quantum programming, e.g. interfaces, languages or softwaredevelopment kits for creating or handling programs capable of running on quantum computers; Platforms for simulating or accessing quantum computers, e.g. cloudbased quantum computing

 G—PHYSICS
 G06—COMPUTING; CALCULATING OR COUNTING
 G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
 G06N5/00—Computing arrangements using knowledgebased models
 G06N5/01—Dynamic search techniques; Heuristics; Dynamic trees; Branchandbound

 B—PERFORMING OPERATIONS; TRANSPORTING
 B82—NANOTECHNOLOGY
 B82Y—SPECIFIC USES OR APPLICATIONS OF NANOSTRUCTURES; MEASUREMENT OR ANALYSIS OF NANOSTRUCTURES; MANUFACTURE OR TREATMENT OF NANOSTRUCTURES
 B82Y10/00—Nanotechnology for information processing, storage or transmission, e.g. quantum computing or single electron logic
Landscapes
 Engineering & Computer Science (AREA)
 Theoretical Computer Science (AREA)
 Physics & Mathematics (AREA)
 Software Systems (AREA)
 General Physics & Mathematics (AREA)
 General Engineering & Computer Science (AREA)
 Computer Hardware Design (AREA)
 Mathematical Physics (AREA)
 Computing Systems (AREA)
 Data Mining & Analysis (AREA)
 Pure & Applied Mathematics (AREA)
 Computational Mathematics (AREA)
 Mathematical Optimization (AREA)
 Mathematical Analysis (AREA)
 Evolutionary Computation (AREA)
 Artificial Intelligence (AREA)
 Condensed Matter Physics & Semiconductors (AREA)
 Operations Research (AREA)
 Databases & Information Systems (AREA)
 Computational Linguistics (AREA)
 Algebra (AREA)
 Management, Administration, Business Operations System, And Electronic Commerce (AREA)
 Memory System Of A Hierarchy Structure (AREA)
 Optical Modulation, Optical Deflection, Nonlinear Optics, Optical Demodulation, Optical Logic Elements (AREA)
 Complex Calculations (AREA)
Abstract
A system is presented for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns. The system includes a classical processor that is configured by operational instructions to perform operations that include producing final weights and variable assignments for the N columns based on N iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a corresponding subset of the N columns, wherein the preliminary weights and variable assignments for a selected column of the corresponding subset based on the preliminary weights and variable assignments generated for a column adjacent to the selected column of the corresponding subset, and wherein the sampling of the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
Description
TITLE OF APPLICATION
SYSTEMS FOR EMULATING A QUANTUM COMPUTER
AND METHODS FOR USE THEREWITH
BACKGROUND OF THE INVENTION
TECHNICAL FIELD OF THE INVENTION
[0001] This invention relates generally to computer systems and also to quantum computing.
DESCRIPTION OF RELATED ART
SYSTEMS FOR EMULATING A QUANTUM COMPUTER
AND METHODS FOR USE THEREWITH
BACKGROUND OF THE INVENTION
TECHNICAL FIELD OF THE INVENTION
[0001] This invention relates generally to computer systems and also to quantum computing.
DESCRIPTION OF RELATED ART
[0002] Computing devices are known to communicate data, process data, and/or store data.
Such computing devices range from wireless smart phones, laptops, tablets, personal computers (PC), work stations, smart watches, connected cars, and video game devices, to web servers and data centers that support millions of web searches, web applications, or online purchases every day. In general, a computing device includes a processor, a memory system, user input/output interfaces, peripheral device interfaces, and an interconnecting bus structure.
Such computing devices range from wireless smart phones, laptops, tablets, personal computers (PC), work stations, smart watches, connected cars, and video game devices, to web servers and data centers that support millions of web searches, web applications, or online purchases every day. In general, a computing device includes a processor, a memory system, user input/output interfaces, peripheral device interfaces, and an interconnecting bus structure.
[0003] Classical digital computing devices operate based on data encoded into binary digits (bits), each of which has one of the two definite binary states (i.e., 0 or 1). In contrast, a quantum computer utilizes quantummechanical phenomena to encode data as quantum bits or qubits, which can be in superpositions of the traditional binary states.
BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWING(S)
BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWING(S)
[0004] Figure 1 is a schematic block diagram of an embodiment of a quantum computing emulator in accordance with the present invention;
[0005] Figure 2 is a schematic block diagram of an embodiment of a quantum computing architecture in accordance with the present invention;
[0006] Figure 3 is a schematic block diagram of an embodiment of a quantum computing architecture in accordance with the present invention;
[0007] Figures 4A, 4B and 4C represent an embodiment of a flow of a multipass sampling in accordance with the present invention;
8 PCT/US2020/026580 [0008] Figures 5A and 5B represent an embodiment of a flow of a dualpass sampling in accordance with the present invention;
[0009] Figure 6 is a flow diagram of an embodiment of a method in accordance with the present invention;
[0010] Figure 7 is a flow diagram of an embodiment of a method in accordance with the present invention.
[0011] Figure 8 is a flow diagram of an embodiment of a method in accordance with the present invention.
DETAILED DESCRIPTION OF THE INVENTION
DETAILED DESCRIPTION OF THE INVENTION
[0012] Figure 1 is a schematic block diagram of an embodiment of a quantum computing emulator in accordance with the present invention. The quantum computing emulator 102 includes a classical processor 120 and a classical memory 122 that stores a grid topology model 124.
[0013] The classical processor 120 includes a processing module and/or one or more other processing devices that operate via classical, rather than quantum computing.
Each such processing device may be a microprocessor, microcontroller, digital signal processor, microcomputer, central processing unit, field programmable gate array, programmable logic device, state machine, logic circuitry, analog circuitry, digital circuitry, and/or any device that manipulates signals (analog and/or digital) based on hard coding of the circuitry and/or operational instructions. The classical processor 120 operates in conjunction with an attached memory and/or an integrated memory element such as classical memory 122 or other memory device, which may be a single memory device, a plurality of memory devices, and/or embedded circuitry of another processing module, module, processing circuit, processing circuitry, and/or processing unit. Such a memory device may be a readonly memory, random access memory, volatile memory, nonvolatile memory, static memory, dynamic memory, flash memory, cache memory, and/or any device that stores digital information.
Each such processing device may be a microprocessor, microcontroller, digital signal processor, microcomputer, central processing unit, field programmable gate array, programmable logic device, state machine, logic circuitry, analog circuitry, digital circuitry, and/or any device that manipulates signals (analog and/or digital) based on hard coding of the circuitry and/or operational instructions. The classical processor 120 operates in conjunction with an attached memory and/or an integrated memory element such as classical memory 122 or other memory device, which may be a single memory device, a plurality of memory devices, and/or embedded circuitry of another processing module, module, processing circuit, processing circuitry, and/or processing unit. Such a memory device may be a readonly memory, random access memory, volatile memory, nonvolatile memory, static memory, dynamic memory, flash memory, cache memory, and/or any device that stores digital information.
[0014] Note that if the classical processor 120 includes more than one processing device, the processing devices may be centrally located (e.g., directly coupled together via a wired and/or wireless bus structure) or may be distributedly located (e.g., cloud computing via indirect coupling via a local area network and/or a wide area network).
Further note that if the classical processor 120 implements one or more of its functions via a state machine, analog circuitry, digital circuitry, and/or logic circuitry, the memory and/or memory element storing the corresponding operational instructions may be embedded within, or external to, the circuitry comprising the state machine, analog circuitry, digital circuitry, and/or logic circuitry.
Still further note that, the classical memory 122 stores, and the classical processor 120 executes, hard coded and/or other operational instructions corresponding to at least some of the steps and/or functions illustrated in one or more of the Figures. Such a memory device or memory element can be tangible memory device or other nontransitory storage medium included in or implemented as an article of manufacture.
Further note that if the classical processor 120 implements one or more of its functions via a state machine, analog circuitry, digital circuitry, and/or logic circuitry, the memory and/or memory element storing the corresponding operational instructions may be embedded within, or external to, the circuitry comprising the state machine, analog circuitry, digital circuitry, and/or logic circuitry.
Still further note that, the classical memory 122 stores, and the classical processor 120 executes, hard coded and/or other operational instructions corresponding to at least some of the steps and/or functions illustrated in one or more of the Figures. Such a memory device or memory element can be tangible memory device or other nontransitory storage medium included in or implemented as an article of manufacture.
[0015] The Quadratic Unconstrained Binary Optimization (QUBO) model is a unifying mathematical framework for an important class of optimization problems. The problems involve finding the global minimum of the scalar y=xTQx where x is a vector of binary variables and Q is a square matrix of coefficients. The matrix Q, in its upper triangular form, can be defined as follows:
Q[i, I], contains cii coefficient from ciixix, Q[i, for i<j, contains cij coefficient from cuxixj Q[/, I], for i>j, contains 0 If a given QUBO problem contains a limited subset of all possible variable combination pairs xi and xj and the dependency between xi and xj can be modelled on a gridbased layout, then the QUBO problem can be solved via classical computation as described herein.
Q[i, I], contains cii coefficient from ciixix, Q[i, for i<j, contains cij coefficient from cuxixj Q[/, I], for i>j, contains 0 If a given QUBO problem contains a limited subset of all possible variable combination pairs xi and xj and the dependency between xi and xj can be modelled on a gridbased layout, then the QUBO problem can be solved via classical computation as described herein.
[0016] The sampling via quantum computer emulator 102 improves the technology of computing by providing the advantages of quantum algorithmic speed for QUBO
problems and/or other problems that meet the criteria outlined herein, without the need for expensive and highly complex quantum computing hardware. In this fashion, highly complex problems such as path finding, weather forecasting, artificial intelligence, financial modeling, cryptography, molecular modeling, pattern recognition, particle physics, simulation, multidimensional optimization, and other computationally intensive applications can be solved without the need of such special purpose quantum computing computing hardware. While described above in terms of quantum computing emulation, the techniques described herein can be applied to more generalized Boltzmann sampling of a QUBO having a grid topology and/or to other QUBO
problems that meet the criteria outlined above.
problems and/or other problems that meet the criteria outlined herein, without the need for expensive and highly complex quantum computing hardware. In this fashion, highly complex problems such as path finding, weather forecasting, artificial intelligence, financial modeling, cryptography, molecular modeling, pattern recognition, particle physics, simulation, multidimensional optimization, and other computationally intensive applications can be solved without the need of such special purpose quantum computing computing hardware. While described above in terms of quantum computing emulation, the techniques described herein can be applied to more generalized Boltzmann sampling of a QUBO having a grid topology and/or to other QUBO
problems that meet the criteria outlined above.
[0017] Figure 2 is a schematic block diagram 200 of an embodiment of a quantum computing architecture in accordance with the present invention. In the example shown, the grid topology includes a NxN grid of nine cells (N=3) having three columns and three rows.
In various embodiments, the grid topology model 124 can correspond to an interconnected gridbased architecture of a quantum computer to be emulated by the quantum computing emulator 102, where each cell in the grid contains a plurality of qubits that are interconnected within the cell and where some qubits are interconnected with another grid elements. It should be noted that, while the terms "columns" and "rows" generally pertain, respectively, to vertical and horizontal onedimensional arrays of cells of a twodimensional grid, as used herein, the term "columns" refer to either vertical or horizontal onedimensional arrays of cells of a twodimensional grid, particularly because the actual orientation of the cells is arbitrary in the context of computation. Furthermore, while a square grid topology is shown, other nonsquare rectangles and other grid shapes can likewise be employed.
In various embodiments, the grid topology model 124 can correspond to an interconnected gridbased architecture of a quantum computer to be emulated by the quantum computing emulator 102, where each cell in the grid contains a plurality of qubits that are interconnected within the cell and where some qubits are interconnected with another grid elements. It should be noted that, while the terms "columns" and "rows" generally pertain, respectively, to vertical and horizontal onedimensional arrays of cells of a twodimensional grid, as used herein, the term "columns" refer to either vertical or horizontal onedimensional arrays of cells of a twodimensional grid, particularly because the actual orientation of the cells is arbitrary in the context of computation. Furthermore, while a square grid topology is shown, other nonsquare rectangles and other grid shapes can likewise be employed.
[0018] In various embodiments, the grid topology model 124 can represent a graph of qubits as a tree/subtree structure composed of a family of subtrees. Consider a specific tree decomposition (X, 7) of a graph satisfying the following properties:
X =N: =8n2, Tis a list, T={(XI,X2),...(XN1,XN)), Xj T/T7:=4n+2, j=1,...,N.
Alex Selby has proposed a singlepass dynamic programing solution to sampling in "Efficient subgraphbased sampling of Isingtype models with frustration". This approach, however, produces only approximate samples of the Boltzmann distribution and requires data structures that are large enough to store preliminary results for all qubits of the grid.
X =N: =8n2, Tis a list, T={(XI,X2),...(XN1,XN)), Xj T/T7:=4n+2, j=1,...,N.
Alex Selby has proposed a singlepass dynamic programing solution to sampling in "Efficient subgraphbased sampling of Isingtype models with frustration". This approach, however, produces only approximate samples of the Boltzmann distribution and requires data structures that are large enough to store preliminary results for all qubits of the grid.
[0019] In contrast, the classical processor 120 performs operational instructions that implement a multipass dynamic programming, guided by the family of subtrees, in order to compute multiple properties of a given QUBO instance on the graph in 0(N2w) time. The classical processor 120 can determine the assignment of all variables (both for the minimum state and for a single Boltzmann sample) by performing N properly tailored dynamicprogramming passes, giving a total complexity of 0(nN2w) per sample. More precisely, the classical processor 120 can compute any or all of the following:
= the minimum attainable energy and associated assignments of variables in Xv, = the total Boltzmann weight of all states, = the total Boltzmann weight of the minimum energy states, = the Boltzmann distribution of all assignments of the variables in Xv, = the assignment of variables in XN of a single Boltzmann sample.
= the minimum attainable energy and associated assignments of variables in Xv, = the total Boltzmann weight of all states, = the total Boltzmann weight of the minimum energy states, = the Boltzmann distribution of all assignments of the variables in Xv, = the assignment of variables in XN of a single Boltzmann sample.
[0020] In particular, the quantum computing emulator 102 provides a system for emulating the sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns. In various embodiments, the classical processor 120 is configured by the operational instructions stored in the classical memory 122 to perform operations that include producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a corresponding subset of the N columns, and wherein the preliminary weights and variable assignments for a selected column of the corresponding subset of the N columns based on the preliminary weights and variable assignments generated for a column adjacent to the selected column of the corresponding subset of the N columns and wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a corresponding subset of the N columns, and wherein the preliminary weights and variable assignments for a selected column of the corresponding subset of the N columns based on the preliminary weights and variable assignments generated for a column adjacent to the selected column of the corresponding subset of the N columns and wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
[0021] In various embodiments, a first iterative pass of the N iterative passes generates the final weights and variable assignments for an Nth column of the N columns, based on the preliminary weights and variable assignments generated for a (N1)st column of the N columns.
For example, the corresponding subset of the N columns associated with the first iterative pass of the N iterative passes includes all columns of the N columns in a range between a second column of the N columns and the (N1)st column of the N columns. The first iterative pass of the N iterative passes generates the preliminary weights and variable assignments for a first column of the N columns, based on based on null weights corresponding to a null column. The last iterative pass of the N iterative passes generates the final weights and variable assignments for a first column of the N columns, based on the final weights and variable assignments for a second column of the N columns and each of the N iterative passes generates the final weights and variable assignments for a corresponding one of the N columns.
For example, the corresponding subset of the N columns associated with the first iterative pass of the N iterative passes includes all columns of the N columns in a range between a second column of the N columns and the (N1)st column of the N columns. The first iterative pass of the N iterative passes generates the preliminary weights and variable assignments for a first column of the N columns, based on based on null weights corresponding to a null column. The last iterative pass of the N iterative passes generates the final weights and variable assignments for a first column of the N columns, based on the final weights and variable assignments for a second column of the N columns and each of the N iterative passes generates the final weights and variable assignments for a corresponding one of the N columns.
[0022] In various embodiments, a pth iterative pass of the N iterative passes generates the final weights and variable assignments for an (Np+1)st column of the N
columns, based on the preliminary weights and variable assignments generated for a (Np)th column of the N
columns. The corresponding subset of the N columns associated with the pth iterative pass of the N iterative passes can include all columns of the N columns in a range between a second column of the N columns and the (Np)th column of the N columns. The grid topology can correspond to a quadratic unconstrained binary optimization (QUBO) model. The sample can correspond to a Boltzmann distribution.
columns, based on the preliminary weights and variable assignments generated for a (Np)th column of the N
columns. The corresponding subset of the N columns associated with the pth iterative pass of the N iterative passes can include all columns of the N columns in a range between a second column of the N columns and the (Np)th column of the N columns. The grid topology can correspond to a quadratic unconstrained binary optimization (QUBO) model. The sample can correspond to a Boltzmann distribution.
[0023] Consider a further example. The classical processor 120 is configured by the operational instructions stored in the classical memory 122 to perform operations that include producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology. Each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns.
The final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N columns adjacent to the final column of the of the N columns.
The final column changes for each pass. Withe the final column being the Nth column in the first pass, the final column being the Nlst column in the second pass, and more generally, the final column being the (Np+ 1)st column in the pth pass. The final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated. The sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
iterative passes through the grid topology. Each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns.
The final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N columns adjacent to the final column of the of the N columns.
The final column changes for each pass. Withe the final column being the Nth column in the first pass, the final column being the Nlst column in the second pass, and more generally, the final column being the (Np+ 1)st column in the pth pass. The final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated. The sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
[0024] In various embodiments, the processor producing the preliminary weights and variable assignments for the N columns based on the N iterative passes includes:
(1) performing a first pass of the N iterative passes through the grid topology wherein the Nth column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are generated is equal to N1; and (2) performing N1 other passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, wherein the (Np+ 1)th column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are regenerated is equal to (Np);
(c) incrementing n; and (d) repeating steps (b) and (c) until p = N.
(1) performing a first pass of the N iterative passes through the grid topology wherein the Nth column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are generated is equal to N1; and (2) performing N1 other passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, wherein the (Np+ 1)th column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are regenerated is equal to (Np);
(c) incrementing n; and (d) repeating steps (b) and (c) until p = N.
[0025] In various embodiments, the first pass of the N iterative passes through the grid topology includes generating the preliminary weights and variable assignments for the first column of the N columns based on null weights and/or variable assignment corresponding to a null column  in effect, a dummy or phantom column that is placed adjacent to the first column of the grid.
[0026] Figure 3 is a schematic block diagram 300 of an embodiment of a quantum computing architecture in accordance with the present invention. Like the quantum computing architecture of FIG. 2, the grid topology includes a NxN grid of nine cells (N=3) having three columns and three rows. In the example shown, the grid topology corresponds to a Chimera graph (Ca) with 9 interconnected unit cells each having 8 interconnected individual qubits numbered 0 72, having corresponding variables xo, xi,... x7i. While there is a dependency between some variables (e.g. xo and x4) based on these interconnections, there is no dependency between other variables (e.g. xo and xi). Because this grid topology presents a QUBO problem that contains a limited subset of all possible variables combinations pairs xi and xj, and the dependency between xi and xj can be modelled on a gridbased layout, then the QUBO problem can be solved via classical computation.
[0027] In various embodiments, the classical processor 120 can operate based on the pseudocode below:
def calculate sampling( grid[ Rows][ Columns ] ):
( last column variables assigments[], weights and variable assignments[] ) =
calculate last column solution( grid[ Rows ][ Columns ] ) ( last column variable assignment, weight) =
select one sample with boltzman distribution( last column variables assigments[], weights and variable assignments[] ) for variable assignment in last column variable assignment:
if variable assignment = 0:
ignore elif variable assignment = 1:
grid[ Rows ][ Columns  1 ].xi coeff +=
grid[ Rows ][ Columns ].xi xj coeff return calculate sampling( qubo[ Rows ][ Columns  1]) last column variable assignment) +
last column variable assignment
def calculate sampling( grid[ Rows][ Columns ] ):
( last column variables assigments[], weights and variable assignments[] ) =
calculate last column solution( grid[ Rows ][ Columns ] ) ( last column variable assignment, weight) =
select one sample with boltzman distribution( last column variables assigments[], weights and variable assignments[] ) for variable assignment in last column variable assignment:
if variable assignment = 0:
ignore elif variable assignment = 1:
grid[ Rows ][ Columns  1 ].xi coeff +=
grid[ Rows ][ Columns ].xi xj coeff return calculate sampling( qubo[ Rows ][ Columns  1]) last column variable assignment) +
last column variable assignment
[0028] A marginal distribution on the last column in each pass can be the computed based on a dynamic programming on the tree decomposition. Consider a specific tree decomposition of a generalized chimera graph G:
= The set of N columns X={21/, X2, ...,XN} each consisting of size at most 4n+1 (Nn), = the underlying decomposition is a path P=KX/,X2), (X2,X3), ...,(XNi,XN)).
Using the dynamic programming approach described above, the quantum computing emulator 102 operates to:
= determine a ground energy value along with a corresponding subgraph that minimizes the energy, = determine total weight associated with Boltzmann (Gibbs) distribution, = draw a single sample according to the Boltzmann distribution.
= The set of N columns X={21/, X2, ...,XN} each consisting of size at most 4n+1 (Nn), = the underlying decomposition is a path P=KX/,X2), (X2,X3), ...,(XNi,XN)).
Using the dynamic programming approach described above, the quantum computing emulator 102 operates to:
= determine a ground energy value along with a corresponding subgraph that minimizes the energy, = determine total weight associated with Boltzmann (Gibbs) distribution, = draw a single sample according to the Boltzmann distribution.
[0029] In various embodiments, the classical processor 120 proceeds by computing weights (marginal distribution) of bits (qubits) for each column in the subgraph consisting of columns to the left of it. This is done by starting with 0 (for a phantom empty (null) column to the left of the first one), then transferring the weights from column Xk to Xk+I by applying the following equations for each edge e=uv where u Xk and v e Xk+/:
1. let wo and wi be the weights corresponding to some assignment of bits on the boundary of column such that, they differ only by the value assigned to u (this being 0 and 1 respectively), and let d be the energy of the edge uv and b be the energy of vertex v;
2. to compute the weights corresponding to the same assignment of bits, but now with v being the boundary vertex, consider the target weights 142'0 and w1 (likewise corresponding to assigning 0 and 1 respectively to v), then '0=w0+142/
w = (wo+ eficw eflb
1. let wo and wi be the weights corresponding to some assignment of bits on the boundary of column such that, they differ only by the value assigned to u (this being 0 and 1 respectively), and let d be the energy of the edge uv and b be the energy of vertex v;
2. to compute the weights corresponding to the same assignment of bits, but now with v being the boundary vertex, consider the target weights 142'0 and w1 (likewise corresponding to assigning 0 and 1 respectively to v), then '0=w0+142/
w = (wo+ eficw eflb
[0030] Applying this to the 3x3 example, the classical processor 120 can operate to sample the grid iteratively by proceeding columnbycolumn in N=3 passes. In particular, Figures 4A, 4B and 4C represent an embodiment of a flow diagrams 400, 425 and 450 of a multipass sampling in accordance with the present invention. The first pass proceeds from column 1 to 3 as shown in FIG. 4A. The results for the 3rd column are used in the second pass which only requires a pass from column 1 to 2 as shown in FIG. 4B. The third pass finalizes column 1 as shown in FIG. 4C. After 3 passes, the sample is obtained for the entire graph.
[0031] While described above in terms of drawing a single sample from the Boltzmann distribution, the techniques described above can be modified to efficiently draw multiple samples from the Boltzmann distribution. Assuming a draw of k samples, the naive approach of sequentially performing the techniques above gives a complexity of 0(knN2w). The method outlined below allows drawing k samples in 0(N(k+N2w)). When the term Nk is negligible, the new approach is clearly superior when dealing with significantly more that 0(n) samples.
[0032] To reach the desired complexity it suffices to show that for any j between 1 and N+1, k partial samples S1,...,Sk on Xj+i can be "pulled back" to k partial samples on X in 0(k+N2w) time. This can be obtained by performing the construction of Boltzmann weights on the assignments of variables in Xji as described above and extending the computation of the weights on assignments of variables in Xj by the following procedure:
1. Initially, for each sample sz choose a random number at uniformly between 0 (exclusive) and the weight of the assignment of .5/ in Xj+i (inclusive), 1=1,...,k.
2. During the computation of assignment weights and variable assignments, whenever we are about to increase the weight of an assignment s in Xj+i by (suitable adjusted) weight w of an assignment t in Xj, we decrement all at for which sz corresponds to s by w. Whenever this results in an sz going from positive to nonpositive, we put tr=t.
As each assignment on Xj+i is updated at most twice, the additional steps in 2 above occur at most twice for each sample, hence the complexity desired. This provides that advantage that multiple samples generated with only a fixed increase in computation. Greater efficiency is obtained when the number of extra samples is large.
1. Initially, for each sample sz choose a random number at uniformly between 0 (exclusive) and the weight of the assignment of .5/ in Xj+i (inclusive), 1=1,...,k.
2. During the computation of assignment weights and variable assignments, whenever we are about to increase the weight of an assignment s in Xj+i by (suitable adjusted) weight w of an assignment t in Xj, we decrement all at for which sz corresponds to s by w. Whenever this results in an sz going from positive to nonpositive, we put tr=t.
As each assignment on Xj+i is updated at most twice, the additional steps in 2 above occur at most twice for each sample, hence the complexity desired. This provides that advantage that multiple samples generated with only a fixed increase in computation. Greater efficiency is obtained when the number of extra samples is large.
[0033] The techniques described above can be modified in other ways as well. Instead of proceeding through columns 1 to N, then 1 to N1, etc. in N iterative passes, as long as oly0, all operations performed are invertible, thus after sampling the last column in the first pass, w*
can be recovered from w'* and used (together with the bits of last column) to sample the second to last column, and so on in reverse order. This allows a sample to be drawn via only 2 passes.
This changes the complexity of sampling to 0(N n
can be recovered from w'* and used (together with the bits of last column) to sample the second to last column, and so on in reverse order. This allows a sample to be drawn via only 2 passes.
This changes the complexity of sampling to 0(N n
[0034] In operation, the classical processor 120 can perform operations including:
(a) performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N
columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for a (N1)st column of the N columns; and (b) performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N1)st column of the N columns to the first column of the N columns.
As before, the sampling of the quantum computer is emulated by a sample based on the final weights and variable assignments for each of the N columns.
(a) performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N
columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for a (N1)st column of the N columns; and (b) performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N1)st column of the N columns to the first column of the N columns.
As before, the sampling of the quantum computer is emulated by a sample based on the final weights and variable assignments for each of the N columns.
[0035] Figures 5A and 5B represent an embodiment of flow diagrams 500 and 525 of a dualpass sampling in accordance with the present invention. The first pass proceeds from column 1 to 3 as shown in FIG. 5A. The results for the 3rd column are used in the second pass which proceeds in the reverse direction back to columns 2 and 1 as shown in FIG. 5B. After 2 passes, the sample is obtained for the entire graph. While described above as drawing only a single sample, the multisampling techniques described above can further be modified in this used to draw k samples in 2 passes.
[0036] The techniques described above can be modified in other ways.
Consider a case where a problem is detected with the graph indicating a low probability of solution via dynamic programing utilizing the particular subtree structures previously described.
In this case, the processing switch to dynamic programming via a second structure which uses the leaves of the tree, rather than the subtree structure. When the problem is cleared, the processing can switch back to dynamic programming using the subtree structure previously described.
This allows one or more samples to be drawn from graphs that may otherwise be blocked by problems with the particular graph structure.
Consider a case where a problem is detected with the graph indicating a low probability of solution via dynamic programing utilizing the particular subtree structures previously described.
In this case, the processing switch to dynamic programming via a second structure which uses the leaves of the tree, rather than the subtree structure. When the problem is cleared, the processing can switch back to dynamic programming using the subtree structure previously described.
This allows one or more samples to be drawn from graphs that may otherwise be blocked by problems with the particular graph structure.
[0037] Figure 6 is a flow diagram 600 of an embodiment of a method in accordance with the present invention. In particular, a method is presented for use with one or more functions and features described in conjunction with FIGs. 15. Step 602 includes performing a first iterative pass through the grid topology to produce final weights and variable assignments for the Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for the Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N columns adjacent to the Nth column, Step 604 includes setting p=2. Step 606 includes performing an pth pass through the grid topology, to produce final weights and variable assignments for the (Np+
1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+2)nd column.
Step 608 includes incrementing p.
1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+2)nd column.
Step 608 includes incrementing p.
[0038] In step 610, the method determines if p = N1. If no, the method returns to step 606. If yes, the method proceeds to step 612 of performing a final pass through the grid topology, to produce final weights and variable assignments for the first column of the N
columns, based on the final weights and variable assignments generated for the second column, wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
columns, based on the final weights and variable assignments generated for the second column, wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
[0039] Figure 7 is a flow diagram 700 of an embodiment of a method in accordance with the present invention. In particular, a method is presented for use with one or more functions and features described in conjunction with FIGs. 16. Step 702 includes performing a first iterative pass through the grid topology to produce final weights and variable assignments for the Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for the Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N columns adjacent to the Nth column, Step 704 includes setting p=2. Step 706 includes performing an nth pass through the grid topology, to produce final weights and variable assignments for the (Np+
1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+2)nd column.
Step 708 includes incrementing p.
1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+2)nd column.
Step 708 includes incrementing p.
[0040] In step 710, the method determines if p = N1. If no, the method returns to step 706. If yes, the method proceeds to step 712 of performing a final pass through the grid topology, to produce final weights and variable assignments for the first column of the N
columns, based on the final weights and variable assignments generated for the second column, wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
columns, based on the final weights and variable assignments generated for the second column, wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
[0041] In various embodiments, the first iterative pass of the N iterative passes through the grid topology includes generating the preliminary weights and variable assignments for the first column of the N columns based on null weights corresponding to a null column adjacent to the first column of the N columns. The grid topology can correspond to a quadratic unconstrained binary optimization model. The sample can correspond to a Boltzmann distribution.
[0042] Figure 8 is a flow diagram 800 of an embodiment of a method in accordance with the present invention. In particular, a method is presented for use with one or more functions and features described in conjunction with FIGs. 17. Step 802 includes performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for the (N1)st column of the N columns.
[0043] Step 804 includes performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N
columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N1)st column of the N columns to the first column of the N columns, wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N1)st column of the N columns to the first column of the N columns, wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
[0044] It should be noted that, while the techniques above have been presented for emulating the sampling of a quantum computer having a twodimensional grid topology, the techniques described herein can be extended to three dimensional grid topologies by producing results for a twodimensional slice in a multipass approach that proceeds columnbycolumn as outlined above, and then proceeding in a multipass approach, slicebyslice until final results are obtained for the threedimensional grid.
[0045] It is noted that terminologies as may be used herein such as bit stream, stream, signal sequence, etc. (or their equivalents) have been used interchangeably to describe digital information whose content corresponds to any of a number of desired types (e.g., data, video, speech, text, graphics, audio, etc. any of which may generally be referred to as 'data').
[0046] As may be used herein, the terms "substantially" and "approximately"
provides an industryaccepted tolerance for its corresponding term and/or relativity between items. For some industries, an industryaccepted tolerance is less than one percent and, for other industries, the industryaccepted tolerance is 10 percent or more. Other examples of industryaccepted tolerance range from less than one percent to fifty percent. Industryaccepted tolerances correspond to, but are not limited to, component values, integrated circuit process variations, temperature variations, rise and fall times, thermal noise, dimensions, signaling errors, dropped packets, temperatures, pressures, material compositions, and/or performance metrics. Within an industry, tolerance variances of accepted tolerances may be more or less than a percentage level (e.g., dimension tolerance of less than +/ 1%). Some relativity between items may range from a difference of less than a percentage level to a few percent.
Other relativity between items may range from a difference of a few percent to magnitude of differences.
provides an industryaccepted tolerance for its corresponding term and/or relativity between items. For some industries, an industryaccepted tolerance is less than one percent and, for other industries, the industryaccepted tolerance is 10 percent or more. Other examples of industryaccepted tolerance range from less than one percent to fifty percent. Industryaccepted tolerances correspond to, but are not limited to, component values, integrated circuit process variations, temperature variations, rise and fall times, thermal noise, dimensions, signaling errors, dropped packets, temperatures, pressures, material compositions, and/or performance metrics. Within an industry, tolerance variances of accepted tolerances may be more or less than a percentage level (e.g., dimension tolerance of less than +/ 1%). Some relativity between items may range from a difference of less than a percentage level to a few percent.
Other relativity between items may range from a difference of a few percent to magnitude of differences.
[0047] As may also be used herein, the term(s) "configured to", "operably coupled to", "coupled to", and/or "coupling" includes direct coupling between items and/or indirect coupling between items via an intervening item (e.g., an item includes, but is not limited to, a component, an element, a circuit, and/or a module) where, for an example of indirect coupling, the intervening item does not modify the information of a signal but may adjust its current level, voltage level, and/or power level. As may further be used herein, inferred coupling (i.e., where one element is coupled to another element by inference) includes direct and indirect coupling between two items in the same manner as "coupled to".
[0048] As may even further be used herein, the term "configured to", "operable to", "coupled to", or "operably coupled to" indicates that an item includes one or more of power connections, input(s), output(s), etc., to perform, when activated, one or more its corresponding functions and may further include inferred coupling to one or more other items. As may still further be used herein, the term "associated with", includes direct and/or indirect coupling of separate items and/or one item being embedded within another item.
[0049] As may be used herein, the term "compares favorably", indicates that a comparison between two or more items, signals, etc., provides a desired relationship. For example, when the desired relationship is that signal 1 has a greater magnitude than signal 2, a favorable comparison may be achieved when the magnitude of signal 1 is greater than that of signal 2 or when the magnitude of signal 2 is less than that of signal 1. As may be used herein, the term "compares unfavorably", indicates that a comparison between two or more items, signals, etc., fails to provide the desired relationship.
[0050] As may be used herein, one or more claims may include, in a specific form of this generic form, the phrase "at least one of a, b, and c" or of this generic form "at least one of a, b, or c", with more or less elements than "a", "b", and "c". In either phrasing, the phrases are to be interpreted identically. In particular, "at least one of a, b, and c" is equivalent to "at least one of a, b, or c" and shall mean a, b, and/or c. As an example, it means: "a"
only, "b" only, "c" only, "a" and "b", "a" and "c", "b" and "c", and/or "a", "b", and "c".
only, "b" only, "c" only, "a" and "b", "a" and "c", "b" and "c", and/or "a", "b", and "c".
[0051] One or more embodiments have been described above with the aid of method steps illustrating the performance of specified functions and relationships thereof.
The boundaries and sequence of these functional building blocks and method steps have been arbitrarily defined herein for convenience of description. Alternate boundaries and sequences can be defined so long as the specified functions and relationships are appropriately performed. Any such alternate boundaries or sequences are thus within the scope and spirit of the claims.
Further, the boundaries of these functional building blocks have been arbitrarily defined for convenience of description. Alternate boundaries could be defined as long as the certain significant functions are appropriately performed. Similarly, flow diagram blocks may also have been arbitrarily defined herein to illustrate certain significant functionality.
The boundaries and sequence of these functional building blocks and method steps have been arbitrarily defined herein for convenience of description. Alternate boundaries and sequences can be defined so long as the specified functions and relationships are appropriately performed. Any such alternate boundaries or sequences are thus within the scope and spirit of the claims.
Further, the boundaries of these functional building blocks have been arbitrarily defined for convenience of description. Alternate boundaries could be defined as long as the certain significant functions are appropriately performed. Similarly, flow diagram blocks may also have been arbitrarily defined herein to illustrate certain significant functionality.
[0052] To the extent used, the flow diagram block boundaries and sequence could have been defined otherwise and still perform the certain significant functionality. Such alternate definitions of both functional building blocks and flow diagram blocks and sequences are thus within the scope and spirit of the claims. One of average skill in the art will also recognize that the functional building blocks, and other illustrative blocks, modules and components herein, can be implemented as illustrated or by discrete components, application specific integrated circuits, processors executing appropriate software and the like or any combination thereof.
[0053] In addition, a flow diagram may include a "start" and/or "continue"
indication. The "start" and "continue" indications reflect that the steps presented can optionally be incorporated in or otherwise used in conjunction with one or more other routines. In addition, a flow diagram may include an "end" and/or "continue" indication. The "end" and/or "continue"
indications reflect that the steps presented can end as described and shown or optionally be incorporated in or otherwise used in conjunction with one or more other routines. In this context, "start"
indicates the beginning of the first step presented and may be preceded by other activities not specifically shown. Further, the "continue" indication reflects that the steps presented may be performed multiple times and/or may be succeeded by other activities not specifically shown.
Further, while a flow diagram indicates a particular ordering of steps, other orderings are likewise possible provided that the principles of causality are maintained.
indication. The "start" and "continue" indications reflect that the steps presented can optionally be incorporated in or otherwise used in conjunction with one or more other routines. In addition, a flow diagram may include an "end" and/or "continue" indication. The "end" and/or "continue"
indications reflect that the steps presented can end as described and shown or optionally be incorporated in or otherwise used in conjunction with one or more other routines. In this context, "start"
indicates the beginning of the first step presented and may be preceded by other activities not specifically shown. Further, the "continue" indication reflects that the steps presented may be performed multiple times and/or may be succeeded by other activities not specifically shown.
Further, while a flow diagram indicates a particular ordering of steps, other orderings are likewise possible provided that the principles of causality are maintained.
[0054] The one or more embodiments are used herein to illustrate one or more aspects, one or more features, one or more concepts, and/or one or more examples. A
physical embodiment of an apparatus, an article of manufacture, a machine, and/or of a process may include one or more of the aspects, features, concepts, examples, etc. described with reference to one or more of the embodiments discussed herein. Further, from figure to figure, the embodiments may incorporate the same or similarly named functions, steps, modules, etc. that may use the same or different reference numbers and, as such, the functions, steps, modules, etc. may be the same or similar functions, steps, modules, etc. or different ones.
physical embodiment of an apparatus, an article of manufacture, a machine, and/or of a process may include one or more of the aspects, features, concepts, examples, etc. described with reference to one or more of the embodiments discussed herein. Further, from figure to figure, the embodiments may incorporate the same or similarly named functions, steps, modules, etc. that may use the same or different reference numbers and, as such, the functions, steps, modules, etc. may be the same or similar functions, steps, modules, etc. or different ones.
[0055] Unless specifically stated to the contra, signals to, from, and/or between elements in a figure of any of the figures presented herein may be analog or digital, continuous time or discrete time, and singleended or differential. For instance, if a signal path is shown as a singleended path, it also represents a differential signal path. Similarly, if a signal path is shown as a differential path, it also represents a singleended signal path.
While one or more particular architectures are described herein, other architectures can likewise be implemented that use one or more data buses not expressly shown, direct connectivity between elements, and/or indirect coupling between other elements as recognized by one of average skill in the art.
While one or more particular architectures are described herein, other architectures can likewise be implemented that use one or more data buses not expressly shown, direct connectivity between elements, and/or indirect coupling between other elements as recognized by one of average skill in the art.
[0056] The term "module" is used in the description of one or more of the embodiments.
A module implements one or more functions via a device such as a processor or other processing device or other hardware that may include or operate in association with a memory that stores operational instructions. A module may operate independently and/or in conjunction with software and/or firmware. As also used herein, a module may contain one or more submodules, each of which may be one or more modules.
A module implements one or more functions via a device such as a processor or other processing device or other hardware that may include or operate in association with a memory that stores operational instructions. A module may operate independently and/or in conjunction with software and/or firmware. As also used herein, a module may contain one or more submodules, each of which may be one or more modules.
[0057] As may further be used herein, a computer readable memory includes one or more memory elements. A memory element may be a separate memory device, multiple memory devices, or a set of memory locations within a memory device. Such a memory device may be a readonly memory, random access memory, volatile memory, nonvolatile memory, static memory, dynamic memory, flash memory, cache memory, and/or any device that stores digital information. The memory device may be in a form a solidstate memory, a hard drive memory, cloud memory, thumb drive, server memory, computing device memory, and/or other physical medium for storing digital information.
[0058] While particular combinations of various functions and features of the one or more embodiments have been expressly described herein, other combinations of these features and functions are likewise possible. The present disclosure is not limited by the particular examples disclosed herein and expressly incorporates these other combinations.
Claims (24)
1. A system for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the system comprising:
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a corresponding subset of the N columns, and wherein the preliminary weights and variable assignments for a selected column of the corresponding subset of the N columns is based on the preliminary weights and variable assignments generated for a column adjacent to the selected column of the corresponding subset of the N columns;
wherein the sampling of the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a corresponding subset of the N columns, and wherein the preliminary weights and variable assignments for a selected column of the corresponding subset of the N columns is based on the preliminary weights and variable assignments generated for a column adjacent to the selected column of the corresponding subset of the N columns;
wherein the sampling of the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N columns.
2. The system of claim 1, wherein a first iterative pass of the N iterative passes generates the final weights and variable assignments for an Nth column of the N columns, based on the preliminary weights and variable assignments generated for a (N1)st column of the N columns.
3. The system of claim 2, wherein the corresponding subset of the N columns associated with the first iterative pass of the N iterative passes includes all columns of the N columns in a range between a second column of the N columns and the (N1)st column of the N
columns.
columns.
4. The system of claim 2, wherein the first iterative pass of the N
iterative passes generates the preliminary weights and variable assignments for a first column of the N
columns, based on based on null weights corresponding to a null column.
iterative passes generates the preliminary weights and variable assignments for a first column of the N
columns, based on based on null weights corresponding to a null column.
5. The system of claim 2, wherein the last iterative pass of the N
iterative passes generates the final weights and variable assignments for a first column of the N
columns, based on the final weights and variable assignments for a second column of the N columns.
iterative passes generates the final weights and variable assignments for a first column of the N
columns, based on the final weights and variable assignments for a second column of the N columns.
6. The system of claim 1, wherein each of the Niterative passes generates the final weights and variable assignments for a corresponding one of the N columns.
7. The system of claim 1, wherein a pth iterative pass of the N iterative passes generates the final weights and variable assignments for an (Np+ 1)st column of the N
columns, based on the preliminary weights and variable assignments generated for a (Np)th column of the N
columns.
columns, based on the preliminary weights and variable assignments generated for a (Np)th column of the N
columns.
8. The system of claim 7, wherein the corresponding subset of the N columns associated with the pth iterative pass of the N iterative passes includes all columns of the N columns in a range between a second column of the N columns and the (Np)th column of the N
columns.
columns.
9. The system of claim 1, wherein the grid topology corresponds to a quadratic unconstrained binary optimization (QUBO) model.
10. The system of claim 1, wherein the sample corresponds to a Boltzmann distribution.
11. A system for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the system comprising:
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N
columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns, wherein final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N columns adjacent to the final column of the of the N columns, wherein the final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N
columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns, wherein final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N columns adjacent to the final column of the of the N columns, wherein the final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
12. The system of claim 11, wherein producing the preliminary weights and variable assignments for the N columns based on the N iterative passes includes:
performing a first pass of the N iterative passes through the grid topology wherein a Nth column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are generated is equal to N1 .
performing a first pass of the N iterative passes through the grid topology wherein a Nth column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are generated is equal to N1 .
13. The system of claim 12, wherein producing the preliminary weights and variable assignments for the N columns based on the N iterative passes includes:
performing N1 other passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, wherein the (Np+ 1)th column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are regenerated is equal to (Np);
(c) incrementing p; and (d) repeating steps (b) and (c) until p = N.
performing N1 other passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, wherein the (Np+ 1)th column of the N columns corresponds to the final column, and wherein the number of columns of the N columns where preliminary weights and variable assignments are regenerated is equal to (Np);
(c) incrementing p; and (d) repeating steps (b) and (c) until p = N.
14. The system of claim 12, wherein the first pass of the N iterative passes through the grid topology includes generating the preliminary weights and variable assignments for a first column of the N columns based on null weights corresponding to a null column.
15. The system of claim 11, wherein the grid topology corresponds to a quadratic unconstrained binary optimization (QUBO) model.
16. The system of claim 11, wherein the sample corresponds to a Boltzmann distribution.
17. A method for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the method comprising:
performing a first iterative pass through the grid topology to produce final weights and variable assignments for a Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for the Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N
columns adjacent to the Nth column;
performing N1 other iterative passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, to produce final weights and variable assignments for the (Np+ 1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+ 2)nd column;
(c) incrementing p;
(d) repeating steps (b) and (c) until p = N; and (e) performing a final pass through the grid topology, to produce final weights and variable assignments for a first column of the N columns, based on the final weights and variable assignments generated for a second column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
performing a first iterative pass through the grid topology to produce final weights and variable assignments for a Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for the Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N
columns adjacent to the Nth column;
performing N1 other iterative passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, to produce final weights and variable assignments for the (Np+ 1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for the (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+ 2)nd column;
(c) incrementing p;
(d) repeating steps (b) and (c) until p = N; and (e) performing a final pass through the grid topology, to produce final weights and variable assignments for a first column of the N columns, based on the final weights and variable assignments generated for a second column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
18. The method of claim 17, wherein the first iterative pass of the N iterative passes through the grid topology includes generating the preliminary weights and variable assignments for the first column of the N columns based on null weights corresponding to a null column adjacent to the first column of the N columns.
19. The method of claim 17, wherein the grid topology corresponds to a quadratic unconstrained binary optimization (QUBO) model.
20. The method of claim 17, wherein the sample corresponds to a Boltzmann distribution.
21. A system for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the system comprising:
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N
columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns, wherein final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N
columns adjacent to the final column of the of the N columns, wherein the final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
producing final weights and variable assignments for the N columns based on N
iterative passes through the grid topology, wherein each of the N iterative passes generates preliminary weights and variable assignments for a number of columns of the N
columns based on preliminary weights and variable assignments generated for an adjacent column for each of the number of columns, wherein final weights and variable assignments are generated for a final column of the N columns for each of the N iterative passes based on the preliminary weights and variable assignments generated for a column of the N
columns adjacent to the final column of the of the N columns, wherein the final weights and variable assignments for the final column of the N columns are used in a next successive pass of the N
iterative passes to reduce the number of columns of the N columns where the preliminary weights and variable assignments are regenerated until the N iterative passes are complete and final weights and variable assignments for each of the N columns have been generated;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
22. A method for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the method comprising:
performing a first iterative pass through the grid topology to produce final weights and variable assignments for the Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for an Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N columns adjacent to the Nth column;
performing N1 other iterative passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, to produce final weights and variable assignments for the (Np+ 1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for an (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+ 2)nd column;
(c) incrementing p;
(d) repeating steps (b) and (c) until p = N; and (e) performing a final pass through the grid topology, to produce final weights and variable assignments for the first column of the N columns, based on the final weights and variable assignments generated for the second column;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
performing a first iterative pass through the grid topology to produce final weights and variable assignments for the Nth column of the N columns, by generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights and variable assignments generated for an adjacent column for each of the N1 columns, wherein final weights and variable assignments are generated for an Nth column based on the preliminary weights and variable assignments generated for an (N1)st column of the N columns adjacent to the Nth column;
performing N1 other iterative passes of the N iterative passes through the grid topology by:
(a) setting p=2;
(b) performing an pth pass through the grid topology, to produce final weights and variable assignments for the (Np+ 1)st column of the N columns, by regenerating preliminary weights and variable assignments for Np columns of the N columns based on preliminary weights and variable assignments regenerated for an adjacent column for each of the Np columns, wherein final weights and variable assignments are generated for an (Np+ 1)st column based on the preliminary weights and variable assignments regenerated for an (Np)th column of the N columns adjacent to the (Np+ 1)st column and the final weights and variable assignments generated for the (Np+ 2)nd column;
(c) incrementing p;
(d) repeating steps (b) and (c) until p = N; and (e) performing a final pass through the grid topology, to produce final weights and variable assignments for the first column of the N columns, based on the final weights and variable assignments generated for the second column;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by producing a plurality of samples from the N iterative passes based on the final weights and variable assignments for each of the N columns.
23. A
system for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the system comprising:
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for a (N 1)st column of the N columns; and performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N 1)st column of the N columns to the first column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
system for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the system comprising:
a memory that stores operational instructions;
at least one classical processor that is configured by the operational instructions to perform operations, the operations including:
performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for a (N 1)st column of the N columns; and performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N 1)st column of the N columns to the first column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
24. A
method for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the method comprising:
performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for the (N1)st column of the N columns; and performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N 1)st column of the N columns to the first column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
method for emulating sampling of a quantum computer having a plurality of qubits arranged in a grid topology with N columns, the method comprising:
performing a first pass through the grid topology, wherein the first pass includes iteratively generating preliminary weights and variable assignments for N1 columns of the N columns based on preliminary weights generated for a preceding adjacent column for each of the N1 columns in a first order from the first column in the N columns to a (N1)st column of the N columns, wherein final weights are generated for the Nth column based on the preliminary weights generated for the (N1)st column of the N columns; and performing a second pass through the grid topology by producing final weights and variable assignments for the remaining N1 columns of the N columns, wherein the second pass includes iteratively generating final weights and variable assignments for N1 columns of the N columns based on final weights generated for a preceding adjacent column for each of the N1 columns in a second order from the (N 1)st column of the N columns to the first column of the N columns;
wherein the sampling of the quantum computer having the plurality of qubits is emulated by a sample based on the final weights and variable assignments for each of the N
columns.
Applications Claiming Priority (9)
Application Number  Priority Date  Filing Date  Title 

US201962864778P  20190621  20190621  
US201962864765P  20190621  20190621  
US62/864,778  20190621  
US62/864,765  20190621  
US201962949764P  20191218  20191218  
US62/949,764  20191218  
US16/835,914  20200331  
US16/835,914 US10922618B2 (en)  20190621  20200331  Multipass system for emulating a quantum computer and methods for use therewith 
PCT/US2020/026580 WO2020256808A1 (en)  20190621  20200403  Systems for emulating a quantum computer and methods for use therewith 
Publications (1)
Publication Number  Publication Date 

CA3140980A1 true CA3140980A1 (en)  20201224 
Family
ID=74037810
Family Applications (1)
Application Number  Title  Priority Date  Filing Date 

CA3140980A Pending CA3140980A1 (en)  20190621  20200403  Systems for emulating a quantum computer and methods for use therewith 
Country Status (6)
Country  Link 

US (3)  US10922618B2 (en) 
EP (1)  EP3987458A4 (en) 
JP (1)  JP7452885B2 (en) 
KR (1)  KR20220024456A (en) 
CA (1)  CA3140980A1 (en) 
WO (1)  WO2020256808A1 (en) 
Families Citing this family (1)
Publication number  Priority date  Publication date  Assignee  Title 

CN114491859A (en) *  20220128  20220513  苏州浪潮智能科技有限公司  Automatic design method and device for superconducting quantum chip readout cavity and storage medium 
Family Cites Families (12)
Publication number  Priority date  Publication date  Assignee  Title 

US20070239366A1 (en)  20040605  20071011  Hilton Jeremy P  Hybrid classicalquantum computer architecture for molecular modeling 
US20060224547A1 (en)  20050324  20061005  Ulyanov Sergey V  Efficient simulation system of quantum algorithm gates on classical computer based on fast algorithm 
US9727824B2 (en)  20130628  20170808  DWave Systems Inc.  Systems and methods for quantum processing of data 
CN109871259A (en)  20130816  20190611  运软网络科技(上海)有限公司  A kind of imitative brain calculates the method and system of virtualization 
US9588940B2 (en) *  20131205  20170307  DWave Systems Inc.  Sampling from a set of spins with clamping 
US10452989B2 (en) *  20150505  20191022  Kyndi, Inc.  Quanton representation for emulating quantumlike computation on classical processors 
US10599988B2 (en) *  20160302  20200324  DWave Systems Inc.  Systems and methods for analog processing of problem graphs having arbitrary size and/or connectivity 
US10565514B2 (en) *  20160331  20200218  Board Of Regents, The University Of Texas System  System and method for emulation of a quantum computer 
US10229355B2 (en)  20160413  20190312  Iqb Information Technologies Inc.  Quantum processor and its use for implementing a neural network 
US11042811B2 (en) *  20161005  20210622  DWave Systems Inc.  Discrete variational autoencoder systems and methods for machine learning using adiabatic quantum computers 
US10332024B2 (en) *  20170222  20190625  Rigetti & Co, Inc.  Modeling superconducting quantum circuit systems 
US10691771B2 (en) *  20170313  20200623  Universities Space Research Association  System and method to hardcode interger linear optimization problems on physical implementations of the Ising model 

2020
 20200331 US US16/835,914 patent/US10922618B2/en active Active
 20200403 JP JP2021575025A patent/JP7452885B2/en active Active
 20200403 KR KR1020227000705A patent/KR20220024456A/en unknown
 20200403 EP EP20827941.4A patent/EP3987458A4/en active Pending
 20200403 WO PCT/US2020/026580 patent/WO2020256808A1/en active Application Filing
 20200403 CA CA3140980A patent/CA3140980A1/en active Pending

2021
 20210112 US US17/147,161 patent/US11113623B2/en active Active
 20210804 US US17/393,676 patent/US20210365828A1/en active Pending
Also Published As
Publication number  Publication date 

KR20220024456A (en)  20220303 
JP2022537311A (en)  20220825 
US11113623B2 (en)  20210907 
US20200401926A1 (en)  20201224 
WO2020256808A1 (en)  20201224 
US20210365828A1 (en)  20211125 
EP3987458A4 (en)  20230719 
EP3987458A1 (en)  20220427 
US20210133619A1 (en)  20210506 
US10922618B2 (en)  20210216 
JP7452885B2 (en)  20240319 
Similar Documents
Publication  Publication Date  Title 

CN106875013B (en)  System and method for multicore optimized recurrent neural networks  
US10726096B2 (en)  Sparse matrix vector multiplication with a matrix vector multiplication unit  
KR101880901B1 (en)  Method and apparatus for machine learning  
US11763156B2 (en)  Neural network compression based on bankbalanced sparsity  
CN108090565A (en)  Accelerated method is trained in a kind of convolutional neural networks parallelization  
JP2022540550A (en)  Systems and methods for reading and writing sparse data in neural network accelerators  
US20210125071A1 (en)  Structured Pruning for Machine Learning Model  
Wu et al.  Numerical method for reliability analysis of phasedmission system using Markov chains  
CN104346629A (en)  Model parameter training method, device and system  
CN111353591B (en)  Computing device and related product  
CN115803754A (en)  Hardware architecture for processing data in a neural network  
US11429849B2 (en)  Deep compressed network  
US11295236B2 (en)  Machine learning in heterogeneous processing systems  
CN114742210A (en)  Hybrid neural network training method, traffic flow prediction method, apparatus, and medium  
US20210365828A1 (en)  Multipass system for emulating sampling of a plurality of qubits and methods for use therewith  
Shen et al.  PRAPPIM: A weight pattern reusing aware pruning method for ReRAMbased PIM DNN accelerators  
EP4141751A1 (en)  Error mitigation for sampling on quantum devices  
US10896366B2 (en)  Reduction of parameters in fully connected layers of neural networks by low rank factorizations  
Venkataramanaiah et al.  A 28nm 8bit FloatingPoint Tensor CoreBased Programmable CNN Training Processor With Dynamic Structured Sparsity  
US11086634B2 (en)  Data processing apparatus and method  
US11307866B2 (en)  Data processing apparatus and method  
CN116134415A (en)  Pulse generation for updating a crossbar array  
Ueyoshi et al.  Robustness of hardwareoriented restricted Boltzmann machines in deep belief networks for reliable processing  
CN111382835A (en)  Neural network compression method, electronic device and computer readable medium  
US12130886B1 (en)  Tensor automatic differentiation 
Legal Events
Date  Code  Title  Description 

EEER  Examination request 
Effective date: 20220913 

EEER  Examination request 
Effective date: 20220913 

EEER  Examination request 
Effective date: 20220913 

EEER  Examination request 
Effective date: 20220913 

EEER  Examination request 
Effective date: 20220913 