How to design reliable embeddings and/or annealing schedule?

Some of my larger embeddings (~200 qubits) do not anneal down to the ground state while some of my embeddings of comparable size wind up at the ground state configuration quite easily.

I've gathered from reading other forums that this discrepancy is due to properties of the gap between the ground state and the first excited state of the eigenspectrum of the embedding hamiltonian. Is this correct?

If so, how does one ensure that they are designing an embedding with the desired spectral properties?

Or, alternatively, I've also gathered that one can use the eigenspectrum of the embedding hamiltonian to determine an annealing schedule that will work for the embedding. Is this true?

If so, what methods can be used to determine the spectrum of an embedding hamiltonian and how is this information used to determine an annealer schedule?

Are there any other considerations for designing reliable annealer emebeddings that I'm unaware of?

Thank you,
Malcolm

P.S. Sorry if this question is all over the place, this seems like a deep topic and I'm still just trying to sort out the fundamentals.


0

Comments

4 comments
  • Hello Malcolm,

    I have moved this discussion to the Quantum Computing Concepts section.

    This is a great question; embedding is an important topic and certainly worth the effort to grapple with. To start, I suggest looking into the concepts of embedding and annealing separately.

    Embedding is the process of mapping a single logical qubit to one or multiple physical qubits. The logical qubit is what you use to describe your problem, while the physical qubit is what is actually available on the QPU. The embedding step is necessary because the physical qubits are not all fully connected.

    Annealing is how the QPU moves from an initial state to a settled state, where a low-energy solution to the provided problem can be measured. As you mentioned, some problems have energy states that are close to the ground (or lowest-energy) state. Controlling the annealing process can improve the quality of problems with small gaps between low energy states.

    Finally, embedding a logical problem to the QPU will create chains of connected Qubits. These chains contribute to the energy state, so they can make it difficult to find the lowest energy state for the initial problem that you are interested in. In this case, it may be helpful to evaluate how the problem is constructed and see if there is a more efficient embedding (with fewer chains, for example) can be created.

    Hope this helps!

    0
    Comment actions Permalink
  • Thank you for your answer. I have a couple followup questions

    "Controlling the annealing process can improve the quality of problems with small gaps between low energy states."
    This is one of the things i want to know more about. Where can i find information about how to modify an annealing schedule to improve the chances that the ground state is found?

    Also, where can i read about why long or numerous chains render problems difficult to anneal? I've heard this about chains before but in my (albeit limited) experience the ability of a particular problem to anneal to the ground state doesn't seem correlate with the size or number of chains.

    0
    Comment actions Permalink
  • Hi Malcolm,

    With longer chains, it's possible to have "breaks" where the chain that is supposed to be representing the same value loses coherence and some qubits in the chain represent different values.

    It is briefly mentioned in this community post about chains:
    https://support.dwavesys.com/hc/en-us/community/posts/360016697094

     

    A more thorough description of chain and annealing schedule behaviour can be found in the technical document for the D-Wave QPU:

    Here is the PDF version:
    https://docs.dwavesys.com/docs/latest/_downloads/09-1109A-M_Technical_Description_of_DW_QPU.pdf

    Here is the HTML version:
    https://docs.dwavesys.com/docs/latest/doc_qpu.html

    This is the anneal schedule section in the html version:
    https://docs.dwavesys.com/docs/latest/c_qpu_0.html#variations-on-the-global-anneal-schedule

    This document contains information about the annealing schedule, what affects changing the schedule has on the outcome, how it interacts with chains, and a host of other information that will be useful to understand what happens by default.

     

    For information about how to actually set the annealing schedule in practice, the following community posts will be helpful.

    This post has information on working with the annealing schedule:
    https://support.dwavesys.com/hc/en-us/community/posts/360014009713

    This one has an example of an annealing schedule:
    https://support.dwavesys.com/hc/en-us/community/posts/360016680754

     

    We also now have a Jupyter Notebook in Leap for learning about the anneal schedule:
    https://support.dwavesys.com/hc/en-us/articles/360012164693
    NOTE: Be careful as it does use a large amount of QPU time, upwards of 30 seconds.
    At the very least it is a great example to look at and formulate your own anneal schedule.

     

    Another good method of finding information is by using the search bar at the top of this and other community pages.
    It searches all Leap content, and is really helpful in finding relevant documentation.
    I was very excited when I discovered how useful it is!

    1
    Comment actions Permalink
  • Thank you very much

    0
    Comment actions Permalink

Please sign in to leave a comment.

Didn't find what you were looking for?

New post