Ciro Santilli OurBigBook.com  Sponsor 中国独裁统治 China Dictatorship 新疆改造中心、六四事件、法轮功、郝海东、709大抓捕、2015巴拿马文件 邓家贵、低端人口、西藏骚乱
quantum-computing.bigb
= Quantum computing
{tag=Computer physical principle of operation}
{wiki}

= Quantum computer
{synonym}

= Quantum computation
{synonym}

Quantum is getting hot in 2019, and even <Ciro Santilli> got a bit excited: <quantum computing could be the next big thing>.

No useful algorithm has been economically accelerated by quantum yet as of 2019, only <quantum supremacy>[useless ones], but <quantum computing player>[the bets are on, big time].

To get a feeling of this, just have a look at the insane number of startups that are already developing <quantum algorithms> for hardware that doesn't/barely exists! https://quantumcomputingreport.com/players/privatestartup (https://web.archive.org/web/20191223175204/https://quantumcomputingreport.com/players/privatestartup/[archive]). Some feared we might be in a bubble: <Are we in a quantum computing bubble?>

To get a basic idea of what programming a quantum computer looks like start by reading: <quantum computing is just matrix multiplication>{full}.

Some people <quantum computing skepticism>[have their doubts], and that is not unreasonable, it might truly not work out. We could be on the verge of an <AI Winter> of quantum computing. But <Ciro Santilli> feels that it is genuinely impossible to tell as of 2020 if something will work out or not. We really just have to try it out and see. There must have been skeptics before every single <next big thing>.

= Introduction to quantum computing
{parent=Quantum computing}

Course plan:
* <Programmer's model of quantum computers>{full}
* look at a <Qiskit hello world>
  * e.g. ours: <qiskit/hello.py>{file}
* learn about <quantum circuits>.
  * <tensor product in quantum computing>
  * First we learn some <quantum logic gates>. This shows an alternative, and extremely important view of a quantum computer besides a matrix multiplication: as a circuit. Fundamental subsections:
    * <quantum logic gates are needed because you can't compute the matrix explicitly as it grows exponentially>{full}
    * <quantum logic gates are needed for physical implementation>{full}
    * <universal quantum gates>{full}
    * <quantum circuits vs classical circuits>{full}
    * Examples of specific gates:
      * <Single-qubit gates>:
        * <Pauli gate>
          * <Pauli-X gate>
        * <Hadamard gate>
      * <Controlled quantum gate>
        * <CNOT gate>
      * <Bell state>
        * <Bell circuit>
  * <quantum algorithms>
    * <Quantum Fourier transform>{full}
    * <Shor's algorithm>{full}

= Programmer's model of quantum computers
{parent=Quantum computing}
{tag=articles}

= How to program a quantum computer
{synonym}
{title2}

= Quantum computing is just matrix multiplication
{synonym}
{title2}

This is a quick tutorial on how a <quantum computer> programmer thinks about how a quantum computer works. If you know:
* what a <complex number> is
* how to do <matrix multiplication>
* what is a <probability>
a concrete and precise <hello world> operation can be understood in 30 minutes.

Although there are several <quantum computer physical implementations>[types of quantum computer] under development, there exists a single high level model that represents what most of those computers can do, and we are going to explain that model here. This model is the is the <digital quantum computer> model, which uses a <quantum circuit>, that is made up of many <quantum gates>.

Beyond that basic model, programmers only may have to consider the <quantum logic gates are needed for physical implementation>[imperfections of their hardware], but the starting point will almost always be this basic model, and tooling that automates mapping the high level model to real hardware considering those imperfections (i.e. <quantum compilers>) is already getting better and better.

This model is very simple to understand, being only marginally more complex than that of a classical computer, see also: https://quantumcomputing.stackexchange.com/questions/6639/is-my-background-sufficient-to-start-quantum-computing/14317#14317

The situation of quantum computers today in the 2020's is somewhat analogous to that of the early days of classical circuits and computers in the 1950's and 1960's, before <CPU> came along and software ate the world. Even though the <semiconductor physical implementation>[exact physics of a classical computer] might be hard to understand and vary across different types of <integrated circuits>, those early hardware pioneers (and to this day modern CPU designers), can usefully view circuits from a higher level point of view, thinking only about concepts such as:
* <logic gates> like AND, NOR and NOT
* a clock + registers
as modelled at the <register transfer level>, and only in a separate compilation step translated into actual chips. This high level understanding of how a classical computer works is what we can call "the programmer's model of a classical computer". So we are now going to describe the quantum analogue of it.

The way quantum programmers think about a quantum computer in order to program can be described as follows:
* the input of a N qubit quantum computer is a vector of dimension N containing classic bits 0 and 1
* the quantum program, also known as circuit, is a $2^n \times 2^n$ <unitary matrix> of <complex numbers> $Q \in \C^{2^n} \times \C^{2^n}$ that operates on the input to generate the output
* the output of a N qubit computer is also a vector of dimension N containing classic bits 0 and 1

To operate a quantum computer, you follow the <step of operation of a quantum computer>:
* set the input <qubits> to classic input bits (<state initialization (quantum computing)>)
* press a big red "RUN" button
* read the classic output bits (<readout quantum computing>)

Each time you do this, you are literally conducting a physical experiment of the specific <quantum computer physical implementations>[physical implementation] of the computer:
* setup your physical system to represent the classical 0/1 inputs
* let the state evolve for long enough
* measure the classical output back out
and each run as the above can is simply called "an experiment" or "a measurement".

The output comes out "instantly" in the sense that it is physically impossible to observe any intermediate state of the system, i.e. there are no clocks like in classical computers, further discussion at: <quantum circuits vs classical circuits>. Setting up, running the experiment and taking the does take some time however, and this is important because you have to run the same experiment multiple times because results are probabilistic as mentioned below.

Unlike in a classical computer, the output of a quantum computer is not deterministic however.

But the each output is not equally likely either, otherwise the computer would be useless except as <random number generator>!

This is because the probabilities of each output for a given input depends on the program (<unitary matrix>) it went through.

Therefore, what we have to do is to design the quantum circuit in a way that the right or better answers will come out more likely than the bad answers.

We then calculate the error bound for our circuit based on its design, and then determine how many times we have to run the experiment to reach the desired accuracy.

The probability of each output of a quantum computer is derived from the input and the circuit as follows.

First we take the classic input vector of dimension N of 0's and 1's and convert it to a "<quantum state vector>" $\va{q_{in}}$ of dimension $2^n$:
$$
\va{q_{in}} \in \C^{2^n}
$$

We are after all going to multiply it by the program matrix, as you would expect, and that has dimension $2^n \times 2^n$!

Note that this initial transformation also transforms the discrete zeroes and ones into <complex numbers>.

For example, in a 3 qubit computer, the quantum state vector has dimension $2^3 = 8$ and the following shows all 8 possible conversions from the classic input to the quantum state vector:
``
000 -> 1000 0000 == (1.0, 0.0, 0.0, 0.0,  0.0, 0.0, 0.0, 0.0)
001 -> 0100 0000 == (0.0, 1.0, 0.0, 0.0,  0.0, 0.0, 0.0, 0.0)
010 -> 0010 0000 == (0.0, 0.0, 1.0, 0.0,  0.0, 0.0, 0.0, 0.0)
011 -> 0001 0000 == (0.0, 0.0, 0.0, 1.0,  0.0, 0.0, 0.0, 0.0)
100 -> 0000 1000 == (0.0, 0.0, 0.0, 0.0,  1.0, 0.0, 0.0, 0.0)
101 -> 0000 0100 == (0.0, 0.0, 0.0, 0.0,  0.0, 1.0, 0.0, 0.0)
110 -> 0000 0010 == (0.0, 0.0, 0.0, 0.0,  0.0, 0.0, 1.0, 0.0)
111 -> 0000 0001 == (0.0, 0.0, 0.0, 0.0,  0.0, 0.0, 0.0, 1.0)
``

This can be intuitively interpreted as:
* if the classic input is `000`, then we are certain that all three bits are 0.

  Therefore, the probability of all three 0's is 1.0, and all other possible combinations have 0 probability.
* if the classic input is `001`, then we are certain that bit one and two are 0, and bit three is 1. The probability of that is 1.0, and all others are zero.
* and so on

Now that we finally have our quantum state vector, we just multiply it by the <unitary matrix> $Q$ of the quantum circuit, and obtain the $2^n$ dimensional output quantum state vector $\va{q_{out}}$:
$$
\va{q_{out}} = Q \: \va{q_{in}}
$$

And at long last, the probability of each classical outcome of the measurement is proportional to the square of the length of each entry in the quantum vector, analogously to what is done in the <Schrödinger equation>.

For example, suppose that the 3 qubit output were:
$$
\begin{aligned}
\va{q_{out}} &=
\begin{bmatrix}
\frac{\sqrt{3}}{2} \\
0.0 \\
\frac{1}{2} \\
0.0 \\
0.0 \\
0.0 \\
0.0 \\
0.0
\end{bmatrix}
\end{aligned}
$$

Then, the probability of each possible outcomes would be the length of each component squared:
$$
\begin{aligned}
P(000) &= \left|\frac{\sqrt{3}}{2}\right|^2 &= \frac{\sqrt{3}}{2}^2 &= \frac{3}{4} \\
P(001) &= \left|0\right|^2                  &= 0^2 &= 0 \\
P(010) &= \left|\frac{\sqrt{1}}{2}\right|^2 &= \frac{\sqrt{1}}{2}^2 &= \frac{1}{4} \\
P(011) &= \left|0\right|^2                  &= 0^2 &= 0 \\
P(100) &= \left|0\right|^2                  &= 0^2 &= 0 \\
P(101) &= \left|0\right|^2                  &= 0^2 &= 0 \\
P(110) &= \left|0\right|^2                  &= 0^2 &= 0 \\
P(111) &= \left|0\right|^2                  &= 0^2 &= 0 \\
\end{aligned}
$$
i.e. 75% for the first, and 25% for the third outcomes, where just like for the input:
* first outcome means `000`: all output bits are zero
* third outcome means `010`: the first and third bits are zero, but the second one is 1

All other outcomes have probability 0 and cannot occur, e.g.: `001` is impossible.

Keep in mind that the <quantum state vector> can also contain <why are complex numbers used in the Schrodinger equation?>[complex numbers because we are doing quantum mechanics], but we just take their magnitude in that case, e.g. the following quantum state would lead to the same probabilities as the previous one:
$$
\begin{aligned}
\abs{\frac{1 + \sqrt{2}i}{2}}^2 &= \frac{1^2 + \sqrt{2^2}}{2^2} &= \frac{3}{4} \\
\abs{\frac{i}{2}}^2             &= \frac{1^2}{2^2}              &= \frac{1}{4}
\end{aligned}
$$

This interpretation of the quantum state vector clarifies a few things:
* the input quantum state is just a simple state where we are certain of the value of each classic input bit
* the matrix has to be unitary because the total probability of all possible outcomes must be 1.0

  This is true for the input matrix, and unitary matrices have the probability of maintaining that property after multiplication.

  Unitary matrices are a bit analogous to https://en.wikipedia.org/wiki/Self-adjoint_operator[self-adjoint operators] in general quantum mechanics (self-adjoint in finite dimensions implies is stronger)

  This also allows us to understand intuitively why quantum computers may be capable of accelerating certain algorithms exponentially: that is because the quantum computer is able to quickly do an unitary matrix multiplication of a humongous $2^{N}$ sized matrix.

  If we are able to encode our algorithm in that matrix multiplication, considering the probabilistic interpretation of the output, then we stand a chance of getting that speedup.

Bibliography:
* https://arxiv.org/pdf/1804.03719.pdf Quantum Algorithm Implementations for Beginners by Abhijith et al. 2020

= Timeline of quantum computing
{parent=Quantum computing}
{wiki}

= Quantum algorithm
{parent=Quantum computing}
{wiki}

This is the true key question: what are the most important algorithms that would be accelerated by quantum computing?

Some candidates:
* <Shor's algorithm>: this one will actually make humanity worse off, as we will be forced into <post-quantum cryptography> that will likely be less efficient than existing classical <cryptography> to implement
* <quantum algorithm for linear systems of equations>, and related <application of systems of linear equations>
* <Grover's algorithm>: speedup not exponential. Still useful for anything?
* https://en.wikipedia.org/wiki/Quantum_Fourier_transform[Quantum Fourier transform]: TODO is the speedup exponential or not?
* Deutsch: solves an useless problem
* <NISQ algorithms>

Do you have proper optimization or <quantum chemistry> algorithms that will make trillions?

Maybe there is some room for doubt because some applications might be way better in some <quantum computer physical implementations>[implementations], but we should at least have a good general idea.

However, clear information on this really hard to come by, not sure why.

Whenever asked e.g. at: https://physics.stackexchange.com/questions/3390/can-anybody-provide-a-simple-example-of-a-quantum-computer-algorithm/3407 on <Physics Stack Exchange> people say the infinite mantra:

Lists:
* <Quantum Algorithm Zoo>: the leading list as of 2020
* <quantum computing computational chemistry algorithms> is the area that Ciro and many people are te most excited about is 
* https://cstheory.stackexchange.com/questions/3888/np-intermediate-problems-with-efficient-quantum-solutions
* https://mathoverflow.net/questions/33597/are-there-any-known-quantum-algorithms-that-clearly-fall-outside-a-few-narrow-cla

= Quantum computers are not expected to solve NP-complete problems
{parent=Quantum algorithm}

Only <NP-intermediate>, which includes notably <integer factorization>:
* https://quantumcomputing.stackexchange.com/questions/16506/can-quantum-computer-solve-np-complete-problems
* https://www.cs.virginia.edu/~robins/The_Limits_of_Quantum_Computers.pdf by <Scott Aaronson>
* https://cs.stackexchange.com/questions/130470/can-quantum-computing-help-solve-np-complete-problems
* https://www.quora.com/How-can-quantum-computing-help-to-solve-NP-hard-problems

= Quantum Algorithm Zoo
{c}
{parent=Quantum algorithm}

https://quantumalgorithmzoo.org/

Source on <GitHub>: https://github.com/stephenjordan/stephenjordan.github.io

The most comprehensive list is the amazing curated and commented list of <quantum algorithms> as of 2020.

= Quantum algorithm vs quantum gate vs quantum circuit
{parent=Quantum algorithm}

There is no fundamental difference between them, a <quantum algorithm> is a <quantum circuit>, which can be seen as a super complicated <quantum gate>.

Perhaps the greats practical difference is that algorithms tend to be defined for an arbitrary number of N qubits, i.e. as a <function> for that each N produces a specific <quantum circuit> with N <qubits> solving the problem. Most named gates on the other hand have fixed small sizes.

= Quantum algorithm by problem
{parent=Quantum algorithm}

= Quantum matrix multiplication
{parent=Quantum algorithm by problem}

https://cstheory.stackexchange.com/questions/2951/quantum-matrix-multiplication

= Quantum algorithm for linear systems of equations
{parent=Quantum algorithm by problem}
{tag=System of linear equations algorithm}

= HHL algorithm
{c}
{parent=Quantum algorithm for linear systems of equations}

= List of quantum algorithms
{parent=Quantum algorithm}

= Bernstein-Vazirani algorithm
{c}
{parent=List of quantum algorithms}
{wiki=Bernstein–Vazirani algorithm}

Toy/test/tought experiment algorithm.

= Grover's algorithm
{c}
{parent=List of quantum algorithms}
{wiki}

= Hiden shift algorithm
{parent=List of quantum algorithms}

= Hidden shift problem
{parent=Hiden shift algorithm}
{wiki}

= Quantum Fourier transform
{c}
{parent=List of quantum algorithms}
{tag=Discrete Fourier transform}
{title2=QFT}
{wiki}

Sample implementations:
* <Qiskit>: <qiskit/qft.py>{file}

= Shor's algorithm
{c}
{parent=List of quantum algorithms}
{tag=Integer factorization algorithm}
{title2=1994}
{wiki}

\Video[https://www.youtube.com/watch?v=lvTqbM5Dq4Q]
{title=<Shor's Algorithm> Explained by <minutephysics> (2019)}

= How many logical qubits are needed to run Shor's algorithm?
{parent=Shor's algorithm}

https://quantumcomputing.stackexchange.com/questions/5048/how-many-logical-qubits-are-needed-to-run-shors-algorithm-efficiently-on-large

= Integer factorization algorithms better than Shor's algorithm
{parent=Shor's algorithm}

* 2023 https://www.schneier.com/blog/archives/2023/01/breaking-rsa-with-a-quantum-computer.html comments on "Factoring integers with sublinear resources on a superconducting quantum processor” https://arxiv.org/pdf/2212.12372.pdf
\Q[
A group of Chinese researchers have just published a paper claiming that they can—although they have not yet done so—break 2048-bit RSA. This is something to take seriously. It might not be correct, but it’s not obviously wrong.

We have long known from Shor’s algorithm that factoring with a quantum computer is easy. But it takes a big quantum computer, on the orders of millions of qbits, to factor anything resembling the key sizes we use today. What the researchers have done is combine classical lattice reduction factoring techniques with a quantum approximate optimization algorithm. This means that they only need a quantum computer with 372 qbits, which is well within what’s possible today. (The IBM Osprey is a 433-qbit quantum computer, for example. Others are on their way as well.)
]

= Quantum compilation
{parent=Quantum computing}
{wiki}

= Quantum compiler
{synonym}

Software that maps higher level languages like <Qiskit> into actual quantum circuits.

= Quantum compiler benchmark
{parent=Quantum compilation}

These appear to be benchmarks that don't involve running anything concretely, just compiling and likely then counting <quantum gates>[gates]:
* https://github.com/ArlineQ/arline_benchmarks

= Quantum Intermediate Representation
{parent=Quantum compilation}
{tag=LLVM Intermediate Representation}
{title2=QIR}

https://devblogs.microsoft.com/qsharp/introducing-quantum-intermediate-representation-qir/

Used e.g. by <Oxford Quantum Circuits>, https://www.linkedin.com/in/john-dumbell-627454121/ mentions:
\Q[Using <LLVM> to consume QIR and run optimization, scheduling and then outputting hardware-specific instructions.]

Presumably the point of it is to allow simulation in <classical computers>?

= Quantum error correction
{parent=Quantum compilation}
{wiki}

Technique that uses multiple non-<ideal> qubits (physical qubits) to simulate/produce one perfect qubit (logical).

One is philosophically reminded of classical <error correction codes>, where we also have multiple input bits per actual information bit.

TODO understand in detail. This appears to be a fundamental technique since all physical systems we can manufacture are imperfect.

Part of the fundamental interest of this technique is due to the <quantum threshold theorem>.

For example, when https://www.bloomberg.com/news/articles/2020-04-06/quantum-computing-startup-raises-215-million-for-faster-device[PsiQuantum raised 215M in 2020], they announced that they intended to reach 1 million physical qubits, which would achieve between 100 and 300 logical qubits.

<video Jeremy O'Brien: "Quantum Technologies" by GoogleTechTalks (2014)> https://youtu.be/7wCBkAQYBZA?t=2778 describes an error correction approach for a <photonic quantum computer>.

Bibliography:
* https://errorcorrectionzoo.org/domain/quantum_domain

= Quantum error correction code
{parent=Quantum error correction}
{tag=Error correction code}

= Surface code
{parent=Quantum error correction code}

* https://www.nature.com/articles/s41586-022-05434-1
* https://www.qutube.nl/quantum-computer-12/surface-codes
* https://quantumcomputing.stackexchange.com/questions/2106/what-is-the-surface-code-in-the-context-of-quantum-error-correction

= Quantum threshold theorem
{parent=Quantum error correction}
{wiki}

This theorem roughly states that states that for every <quantum algorithm>, once we reach a certain level of physical error rate small enough (where small enough is algorithm dependant), then we can \i[perfectly] error correct.

This algorithm provides the conceptual division between <noisy intermediate-scale quantum era> and post-NISQ.

= Noisy intermediate-scale quantum era
{parent=Quantum threshold theorem}
{wiki}

= NISQ
{c}
{synonym}
{title2}

Era of <quantum computing> before we reach physical errors small enough to do perfect <quantum error correction> as demonstrated by the <quantum threshold theorem>.

= NISQ algorithm
{c}
{parent=Noisy intermediate-scale quantum era}
{tag=Quantum algorithm}

A <quantum algorithm> that is thought to be more likely to be useful in the <NISQ> era of <quantum computing>.

= Variational quantum eigensolver
{parent=NISQ algorithm}
{title2=VQE}
{wiki}

TODO clear example of the <computational problem> that it solves.

= Quantum optimization algorithm
{parent=NISQ algorithm}
{wiki=Quantum_optimization_algorithms}

= Quantum approximate optimization algorithm
{parent=Quantum optimization algorithm}
{title2=QAOA}

TODO clear example of the <computational problem> that it solves.

= Quadratic unconstrained binary optimization
{parent=Quantum optimization algorithm}
{title2=QUBO}
{wiki}

= High level quantum synthesis
{parent=Quantum compilation}

This is a term "invented" by <Ciro Santilli> to refer to quantum compilers that are able to convert non-specifically-quantum (<functional programming>[functional], since there is no state in quantum software) programs into <quantum circuit>.

The term is made by adding "quantum" to the more "classical" concept of "<high level synthesis>", which refers to software that converts an <imperative program> into <register transfer-level> hardware, typicially for <FPGA> applications.

= Classiq
{c}
{parent=High level quantum synthesis}

https://www.classiq.io

= Quantum computing player
{parent=Quantum computing}

It is hard to beat the lists present at: https://quantumcomputingreport.com (closed source unfortunately, no GitHub) in particular:
* https://quantumcomputingreport.com/scorecards/qubit-count/ lists what are the latest qubit counts and technologies that each player is using
* https://quantumcomputingreport.com/players/public-companies/ summarizes what each player has been doing in a few paragraphs

Also of interest: https://quantumzeitgeist.com/interactive-map-of-quantum-computing-companies-from-around-the-globe/

= Quantum computing player in Brazil
{parent=Quantum computing player}

* Paulo Nussenzveig physics researcher at <University of São Paulo>. Laboratory page: http://portal.if.usp.br/lmcal/pt-br/node/323[]: LMCAL, laboratory of coherente manipulation of atoms and light. <Google Scholar>: https://scholar.google.com/citations?user=FbGL0BEAAAAJ
* Brazil Quantum: interest group created by students. Might be a software consultancy: https://www.terra.com.br/noticias/tecnologia/inovacao/pesquisadores-paulistas-tentam-colocar-brasil-no-mapa-da-computacao-quantica,2efe660fbae16bc8901b1d00d139c8d2sz31cgc9.html
* DOBSLIT https://dobslit.com/en/the-company/ company in São Carlos, as of 2022 a quantum software consultancy with 3 people: https://www.linkedin.com/search/results/people/?currentCompany=%5B%2272433615%22%5D&origin=COMPANY_PAGE_CANNED_SEARCH&sid=TAj two of them from the <Federal University of São Carlos>
* https://computacaoquanticabrasil.com/ Website half broken as of 2022. Mentions a certain Lagrange Foundation, but their website is down.
* QuInTec academic interest group
  * https://www.terra.com.br/noticias/tecnologia/inovacao/pesquisadores-paulistas-tentam-colocar-brasil-no-mapa-da-computacao-quantica,2efe660fbae16bc8901b1d00d139c8d2sz31cgc9.html mentions 6 professors, 3 from <USP> 3 from <UNICAMP> interest group:
  * https://drive.google.com/file/d/1geGaRuCpRHeuLH2MLnLoxEJ1iOz4gNa9/view white paper gives all names
    * Celso Villas-Bôas
    * Frederico Brito
    * Gustavo Wiederhecker
    * Marcelo Terra Cunha
    * Paulo Nussenzveig
    * Philippe Courteille
  * https://sites.google.com/unicamp.br/quintec/home their website.
  * a 2021 symposium they organized: http://www.saocarlos.usp.br/dia-09-quintec-quantum-engineering-workshop/ some people of interest:
    * Samuraí Brito https://www.linkedin.com/in/samuraí-brito-4a57a847/ at Itaú Unibanco, a Brazilian bank
    * https://www.linkedin.com/in/dario-sassi-thober-5ba2923/ from https://wvblabs.com.br/
    * https://www.linkedin.com/in/roberto-panepucci-phd from https://en.wikipedia.org/wiki/Centro_de_Pesquisas_Renato_Archer in Campinas
* Quanby quantum software in Florianópolis, founder Eduardo Duzzioni
* https://thequantumhubs.com/category/quantum-brazil-news/ good links
* http://qubit.lncc.br/?lang=en Quantum Computing Group of the National Laboratory for Scientific Computing: https://pt.wikipedia.org/wiki/Laboratório_Nacional_de_Computação_Científica in Rio. The principal researcher seems to be https://www.lncc.br/~portugal/[]. He knows what <GitHub> is: https://github.com/programaquantica/tutoriais[], PDF without .tex though.
* https://quantum-latino.com/ conference. E.g. 2022: https://www.canva.com/design/DAFErjU3Wvk/2xo25nEuqv9O7RbCPLNEkw/view

= Quantum computing company
{parent=Quantum computing player}

= Quantum computing research institute
{parent=Quantum computing player}

= QuTech
{c}
{parent=Quantum computing research institute}
{tag=Delft University of Technology}

= QuTech Academy
{c}
{parent=QuTech}
{tag=Quantum computing outreach}

One of their learning sites: https://www.qutube.nl/

= QuTechAcademy
{c}
{synonym}

The educational/outreach branch of <QuTech>.

https://qutechacademy.nl/

https://www.youtube.com/@QuTechAcademy

= Organization developing quantum hardware
{parent=Quantum computing player}

= Organizations developing quantum hardware
{synonym}

= D-Wave Systems
{c}
{parent=Organization developing quantum hardware}
{tag=Company}
{wiki}

<Vaporware>?

= ColdQuanta
{c}
{parent=Organization developing quantum hardware}
{tag=American company}
{title2=2007}

Not a <quantum computing> pure-play, they also do sensing.

= Organization developing quantum software
{parent=Quantum computing player}

= Organizations developing quantum software
{synonym}

= Quantum Computing Inc.
{c}
{parent=Organization developing quantum software}
{wiki}

Really weird and obscure company, good coverage: https://thequantuminsider.com/2020/02/06/quantum-computing-incorporated-the-first-publicly-traded-quantum-computing-stock/

Publicly traded in 2007, but only pivoted to <quantum computing> much later.

Social media:
* https://www.youtube.com/@quantumcomputinginc6758/videos
* https://twitter.com/QciQuantum?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor
* https://www.quantumcomputinginc.com/

= Microsoft Quantum
{c}
{parent=Organization developing quantum software}
{tag=Microsoft}
{wiki}

= Phasecraft
{c}
{parent=Organization developing quantum software}
{title2=2018}
{wiki}

https://www.phasecraft.io

The co-founder's name, Toby Cubitt, is the mos awesome thing ever (Cubitt -> <qubit>). From <UCL>.

Funding:
* 2023: £13m: https://www.uktech.news/deep-tech/phasecraft-quantum-computing-20230816

= Quantum computing paradigm
{parent=Quantum computing}

= Quantum computing hardware
{parent=Quantum computing}

= Step of operation of a quantum computer
{parent=Quantum computing hardware}

= Steps of operation of a quantum computer
{synonym}

= State initialization
{disambiguate=quantum computing}
{parent=Step of operation of a quantum computer}

= Readout
{disambiguate=quantum computing}
{parent=Step of operation of a quantum computer}

= Quantum computers as experiments that are hard to predict outcomes
{parent=Quantum computing hardware}

One possibly interesting and possibly obvious point of view, is that a quantum computer is an experimental device that executes a quantum probabilistic experiment for which the probabilities cannot be calculated theoretically efficiently by a <nuclear weapon>.

This is how quantum computing was originally theorized by the likes of <Richard Feynman>: they noticed that "Hey, here's a well formulated <quantum mechanics> problem, which I know the algorithm to solve (calculate the probability of outcomes), but it would take exponential time on the problem size".

The converse is then of course that if you were able to encode useful problems in such an experiment, then you have a computer that allows for exponential speedups.

This can be seen very directly by studying one specific quantum computer implementation. E.g. if you take the simplest to understand one, <photonic quantum computer>, you can make systems for which you need exponential time to calculate the probabilities that photons will exit through certain holes and not others.

The obvious aspect of this idea is by coming from <quantum logic gates are needed because you can't compute the matrix explicitly as it grows exponentially>: knowing the full explicit matrix is impossible in practice, and knowing the matrix is equivalent to knowing the probabilities of every outcome.

= Quantum computing is hard because we want long coherence but fast control
{parent=Quantum computing hardware}
{wiki}

Mentioned e.g. at:
* https://youtu.be/t5nxusm_Umk?t=176
* https://youtu.be/xjlGL4Mvq7A?t=169

These are two conflicting constraints:
* long <coherence times>: require isolation from external world, otherwise observation destroys quantum state
* <state initialization (quantum computing)>[fast control] and <readout (quantum computing)>: require coupling with external world

= Quantum computer type
{parent=Quantum computing hardware}
{wiki}

= Model of quantum computing
{parent=Quantum computer type}

= Measurement and circuit based quantum computers
{parent=Model of quantum computing}

= Circuit-based quantum computer
{parent=Measurement and circuit based quantum computers}

Synonym to <gate-based quantum computer>/<digital quantum computer>?

= Measurement-based quantum computer
{parent=Measurement and circuit based quantum computers}
{wiki=One-way quantum computer}

TODO confirm: apparently in the paradigm you can choose to measure only certain output <qubits>.

This makes things irreversible (TODO what does reversibility mean in this random context?), as opposed to <Circuit-based quantum computer> where you measure all output qubits at once.

TODO what is the advantage?

= One-way quantum computer
{synonym}
{title2}

= Analog and digital quantum computers
{parent=Model of quantum computing}

= Digital quantum computer
{parent=Analog and digital quantum computers}

= Gate-based quantum computer
{synonym}
{title2}

As of 2022, this tends to be the more "default" when you talk about a quantum computer.

But there are some serious <analog quantum computer> contestants in the field as well.

= Quantum circuit
{parent=Digital quantum computer}
{wiki}

A <quantum circuit> is a <graph> of <quantum logic gates>.

<Quantum circuits> are the prevailing <model of quantum computing> as of the 2010's - 2020's

= Quantum state vector
{parent=Quantum circuit}

Sample implementations:
* 

= Tensor product in quantum computing
{parent=Quantum circuit}
{tag=Tensor product}

We don't need to understand a super generalized version of <tensor products> to know what they mean in basic <quantum computing>!

Intuitively, taking a <tensor product> of two <qubits> simply means putting them together on the same quantum system/computer.

When we write the <bra-ket notation>: $\ket{00}$ that is the same as $\ket{0} \otimes \ket{0}$.

The tensor product is called a "product" because it distributes over addition.

E.g. consider:
$$
(\frac{\ket{0} + \ket{1}}{\sqrt{2}}) \otimes \ket{0} =
\frac{\ket{0} \otimes \ket{0} + \ket{1} \otimes \ket{0}}{\sqrt{2}} =
\frac{\ket{00} + \ket{10}}{\sqrt{2}}
$$

Intuitively, in this operation we just put a <Hadamard gate> qubit together with a second pure $\ket{0}$ qubit.

And the outcome still has the second qubit as always 0, because we haven't made them interact.

The <quantum state> $\frac{\ket{00} + \ket{10}}{\sqrt{2}}$ is called a <separable state>, because it can be written as a single product of two different qubits. We have simply brought two qubits together, without making them interact.

If we then add a <CNOT gate> to make a <Bell state>:
$$
\frac{\ket{00} + \ket{11}}{\sqrt{2}} =
\frac{\ket{0} \otimes \ket{0} + \ket{1} \otimes \ket{1}}{\sqrt{2}}
$$
we can now see that the <Bell state> is <non-separable>: we've made the two qubits interact, and there is no way to write this state with a single <tensor product>. The qubits are fundamentally <entangled>.

= Quantum circuits vs classical circuits
{parent=Quantum circuit}

Just like a classic <software engineer>[programmer] does not need to understand the intricacies of how transistors are implemented and CMOS semiconductors, the quantum programmer does not understand physical intricacies of the underlying <quantum computer physical implementations>[physical implementation].

The main difference to keep in mind is that quantum computers cannot https://en.wikipedia.org/wiki/Observer_effect_(physics)[save and observe intermediate quantum state], so programming a quantum computer is basically like programming a combinatorial-like circuit with gates that operate on (qu)bits:
* https://quantumcomputing.stackexchange.com/questions/8441/does-a-quantum-computer-have-a-clock-signal-and-if-yes-how-big-is-it/9383#9383
* https://quantumcomputing.stackexchange.com/questions/8849/quantum-circuits-explain-algorithms-why-didnt-classical-circuits/8869#8869

For this reason programming a quantum computer is much like programming a classical combinatorial circuit as you would do with https://en.wikipedia.org/wiki/SPICE[SPICE], <register transfer level>[verilog-or-vhdl], in which you are basically describing a graph of gates that goes from the input to the output

For this reason, we can use the words "program" and "circuit" interchangeably to refer to a quantum program

Also remember that and there is no no clocks in combinatorial circuits because there are no registers to drive; and so there is no analogue of clock in the quantum system either,

Another consequence of this is that programming quantum computers does not look like programming the more "common" procedural programming languages such as C or Python, since those fundamentally rely on processor register / memory state all the time.

Quantum programmers can however use classic languages to help describe their quantum programs more easily, for example this is what happens in <Qiskit>, where you write a Python program that makes Qiskit library calls that describe the quantum program.

= Quantum logic gate
{parent=Digital quantum computer}
{wiki}

= Quantum gate
{synonym}

At <quantum computing is just matrix multiplication>{full} we saw that making a quantum circuit actually comes down to designing one big <unitary matrix>.

We have to say though that that was a bit of a lie.

Quantum programmers normally don't just produce those big matrices manually from scratch.

Instead, they use </quantum logic gates>.

The following are the main reasons for that:
* <quantum logic gates are needed because you can't compute the matrix explicitly as it grows exponentially>{full}
* <quantum logic gates are needed for physical implementation>{full}

= Quantum logic gates are needed because you can't compute the matrix explicitly as it grows exponentially
{parent=Quantum logic gate}

One key insight, is that the matrix of a non-trivial quantum circuit is going to be huge, and won't fit into any amount classical memory that can be present in this universe.

This is because the matrix is exponential in the number qubits, and $2^{100}$ is more than the number of atoms in the universe!

Therefore, off the bat we know that we cannot possibly describe those matrices in an explicit form, but rather must use some kind of shorthand.

But it gets worse.

Even if we had enough memory, the act of explicitly computing the matrix is not generally possible.

This is because knowing the matrix, basically means knowing the probability result for all possible $2^{N}$ outputs for each of the $2^{N}$ possible inputs.

But if we had those probabilities, our algorithmic problem would already be solved in the first place! We would "just" go over each of those output probabilities (OK, there are $2^{N}$ of those, which is also an insurmountable problem in itself), and the largest probability would be the answer.

So if we could calculate those probabilities on a classical machine, we would also be able to simulate the quantum computer on the classical machine, and quantum computing would not be able to give exponential speedups, which we know it does.

To see this, consider that for a given input, say `000` on a 3 qubit machine, the corresponding 8-sized quantum state looks like:
``
000 -> 1000 0000 == (1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
``
and therefore when you multiply it by the unitary matrix of the quantum circuit, what you get is the first column of the unitary matrix of the quantum circuit. And `001`, gives the second column and so on.

As a result, to prove that a quantum algorithm is correct, we need to be a bit smarter than "just calculate the full matrix".

Which is why you should now go and read: <quantum algorithm>{full}.

This type of thinking links back to how physical experiments relate to quantum computing: a quantum computer realizes a physical experiment to which we cannot calculate the probabilities of outcomes without exponential time.

So for example in the case of a <photonic quantum computer>, you are not able to calculate from theory the probability that photons will show up on certain wires or not.

= Quantum logic gates are needed for physical implementation
{parent=Quantum logic gate}

One direct practical reason is that we need to map the matrix to real quantum hardware somehow, and all quantum hardware designs so far and likely in the future are gate-based: you manipulate a small number of qubits at a time (2) and add more and more of such operations.

While there are "<quantum compilers>" to increase the portability of quantum programs, it is to be expected that programs manually crafted for a specific hardware will be more efficient just like in classic computers.

TODO: is there any clear reason why computers can't beat humans in approximating any unitary matrix with a gate set?

This is analogous to what classic circuit programmers will do, by using smaller <logic gates> to create complex circuits, rather than directly creating one huge <truth table>.

The most commonly considered quantum gates take 1, 2, or 3 qubits as input.

The gates themselves are just unitary matrices that operate on the input qubits and produce the same number of output qubits.

For example, the matrix for the <CNOT gate>, which takes 2 qubits as input is:
``
1 0 0 0
0 1 0 0
0 0 0 1
0 0 1 0
``

The final question is then: if I have a 2 qubit gate but an input with more qubits, say 3 qubits, then what does the 2 qubit gate (4x4 matrix) do for the final big 3 qubit matrix (8x8)? In order words, how do we scale quantum gates up to match the total number of qubits?

The intuitive answer is simple: we "just" extend the small matrix with a larger identity matrix so that the sum of the probabilities third bit is unaffected.

More precisely, we likely have to extend the matrix in a way such that the https://cs.stackexchange.com/questions/71462/how-are-partial-measurements-performed-on-a-n-qubit-quantum-circuit[partial measurement] of the original small gate qubits leaves all other qubits unaffected.

For example, if the circuit were made up of a CNOT gate operating on the first and second qubits as in:
``
0 ----+----- 0
      |
1 ---CNOT--- 1

2 ---------- 2
``

then we would just extend the 2x2 CNOT gate to:

TODO lazy to properly learn right now. Apparently you have to use the https://en.wikipedia.org/wiki/Kronecker_product[Kronecker product] by the identity matrix. Also, <zX-calculus> appears to provide a powerful alternative method in some/all cases.

Bibliography:
* https://quantumcomputing.stackexchange.com/questions/2299/how-to-interpret-a-quantum-circuit-as-a-matrix

= Universal quantum gates
{parent=Quantum logic gate}
{{wiki=Quantum_logic_gate#Universal_quantum_gates}}

Just https://en.wikipedia.org/wiki/Functional_completeness[like as for classic gates], we would like to be able to select <quantum computer physical implementations> that can represent one or a few gates that can be used to create \i[any] quantum circuit.

Unfortunately, in the case of quantum circuits this is obviously impossible, since the space of N x N unitary matrices is infinite and continuous.

Therefore, when we say that certain gates form a "set of universal quantum gates", we actually mean that "any unitary matrix can be approximated to arbitrary precision with enough of these gates".

Or if you like fancy Mathy words, you can say that the subgroup of the <unitary group> <subgroup generated by a group>[generated by] our basic gate set is a <dense set>[dense subset] of the unitary group.

= Single-qubit gate
{parent=Quantum logic gate}

= Single-qubit quantum gate
{synonym}

The first two that you should study are:
* <Quantum NOT gate>
* <Hadamard gate>
* <Phase shift gate>

= Hadamard gate
{c}
{parent=Single qubit gate}
{{wiki=Quantum_logic_gate#Hadamard_gate}}

The <Hadamard gate> takes $\ket{0}$ or $\ket{1}$ (<quantum states> with probability 1.0 of measuring either 0 or 1), and produces states that have equal probability of 0 or 1.

$$
H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}
$$
{title=<Hadamard gate> <matrix>}

\Image[https://upload.wikimedia.org/wikipedia/commons/1/1a/Hadamard_gate.svg]
{title=<Hadamard gate> symbol}

= Pauli gate
{c}
{parent=Single qubit gate}

= Pauli-X gate
{c}
{parent=Single qubit gate}

= Quantum NOT gate
{title2}
{synonym}

The <quantum NOT gate> swaps the state of $\ket{0}$ and $\ket{1}$, i.e. it maps:
$$
x \ket{0} + y \ket{y} \to y \ket{0} + x \ket{y}
$$
As a result, this gate also inverts the probability of measuring 0 or 1, e.g.
* if the old probability of 0 was 0, then it becomes 1
* if the old probability of 0 was 0.2, then it becomes 0.8

$$
\begin{bmatrix}
0 & 1 \\
1 & 0 \\
\end{bmatrix}
$$
{title=<Quantum NOT gate> <matrix>}

\Image[https://upload.wikimedia.org/wikipedia/commons/9/91/Qcircuit_CNOT.svg]
{title=<Quantum NOT gate> symbol}

= Phase shift gate
{c}
{parent=Single qubit gate}
{{wiki=Quantum_logic_gate#Phase_shift_gates}}

= Multi-qubit gate
{parent=Single qubit gate}

= Multi-qubit quantum gate
{synonym}

= Two-qubit gate
{synonym}

The most common way to construct <multi=qubit gates> is to use <single-qubit gates> as part of a <controlled quantum gate>.

= Controlled quantum gate
{parent=Multi qubit gate}
{{wiki=Quantum_logic_gate#Controlled_gates}}

<Controlled quantum gates> are gates that have two types of input qubits:
* control <qubits>
* operand <qubits> (terminology made up by <Ciro Santilli> just now)
These gates can be understood as doing a certain <unitary operation> only if the control qubits are enabled or disabled.

The first example to look at is the <CNOT gate>.

\Image[https://upload.wikimedia.org/wikipedia/commons/d/dc/Controlled_gate.svg]
{title=Generic <controlled quantum gate> symbol}
{description=
The black dot means "control qubit", and "U" means an arbitrary <Unitary operation>.

When the operand has a conventional symbol, e.g. the <image Quantum NOT gate symbol> for the <quantum NOT gate> to form the <CNOT gate>, that symbol is used in the operand instead. 
}

= Empty circle control qubit notation
{parent=Controlled quantum gate}

Some authors use the convention of:
* filled black circle: conventional <controlled quantum gate>, i.e. operate if control qubit is active
* empty (White) circle: operarate if control qubit is inactive

= CNOT gate
{c}
{parent=Controlled quantum gate}
{wiki=Controlled_NOT_gate}

= Controlled NOT gate
{synonym}
{title2}

The <CNOT gate> is a <controlled quantum gate> that operates on two <qubits>, flipping the second (operand) <qubit> if the first (control) <qubit> is set.

This gate is the first example of a <controlled quantum gate> that you should study.

$$
\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{bmatrix}
$$
{title=<CNOT gate> <matrix>}

\Image[https://upload.wikimedia.org/wikipedia/commons/4/4e/CNOT_gate.svg]
{title=<CNOT gate> symbol}
{description=The symbol follow the generic symbol convention for <controlled quantum gates> shown at <image Generic controlled quantum gate symbol>, but replacing the generic "U" with the <image Quantum NOT gate symbol>.}

To understand why the gate is called a CNOT gate, you should think as follows.

First let's produce a generic <quantum state> vector where the control qubit is certain to be 0.

On the standard basis:
$$
\ket{00} \\
\ket{01} \\
\ket{10} \\
\ket{11} \\
$$
we see that this means that only $\ket{00}$ and $\ket{01}$ should be possible. Therefore, the state must be of the form:
$$
\begin{bmatrix}
x \\
y \\
0 \\
0
\end{bmatrix}
$$
where $x$ and $y$ are two <complex numbers> such that $|x| + |y| = 1.0$

If we operate the <CNOT gate> on that state, we obtain:
$$
\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{bmatrix}

\times

\begin{bmatrix}
x \\
y \\
0 \\
0
\end{bmatrix}

=

\begin{bmatrix}
x \\
y \\
0 \\
0
\end{bmatrix}
$$
and so the input is unchanged as desired, because the control qubit is 0.

If however we take only states where the control qubit is for sure 1:
$$
\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{bmatrix}

\times

\begin{bmatrix}
0 \\
0 \\
x \\
y
\end{bmatrix}

=

\begin{bmatrix}
0 \\
0 \\
y \\
x
\end{bmatrix}
$$

Therefore, in that case, what happened is that the probabilities of $\ket{10}$ and $\ket{11}$ were swapped from $x$ and $y$ to $y$ and $x$ respectively, which is exactly what the <quantum NOT gate> does.

So from this we understand more concretelly what "the gate only operates if the first <qubit> is set to one" means.

Now go and study the <Bell state> and understand intuitively how this gate is used to produce it.

= Toffoli gate
{c}
{parent=Multi qubit gate}
{wiki}

= Clifford gates
{c}
{parent=Quantum logic gate}
{wiki}

This gate set alone is not a set of <universal quantum gates>.

Notably, circuits containing those gates alone can be fully simulated by classical computers according to the <Gottesman-Knill theorem>, so there's no way they could be universal.

This means that if we add any number of Clifford gates to a quantum circuit, we haven't really increased the complexity of the algorithm, which can be useful as a transformational device.

A popular set of <universal quantum gates> derived from <Clifford gates> is <Clifford plus T>.

= Clifford plus T
{c}
{parent=Clifford gates}
{tag=Universal quantum gates}

Set of <quantum logic gate> composed of the <Clifford gates> plus the <Toffoli gate>. It forms a set of <universal quantum gates>.

= Gottesman-Knill theorem
{c}
{parent=Clifford gates}
{wiki}

= List of quantum logic gates
{c}
{parent=Quantum logic gate}
{wiki}

= Analog quantum computer
{parent=Analog and digital quantum computers}
{tag=Analog computer}
{tag=Analog and digital computers}

* https://quantumtech.blog/2023/01/17/quantum-computing-with-neutral-atoms/ OK this one hits it:
  \Q[As Alex Keesling, CEO of <QuEra> told me, "... whereas in gate-based \[digital\] quantum computing the focus is on the sequence of the gates, in analog quantum processing it's more about the position of the atoms and where you place them so they can mirror real life problems. We arrange the atoms and define the forces that drive them and then measure the result... so it’s a geometric encoding of the problem itself."]
  So we understand that it is truly like the <classical computer> analog vs digital case.
* https://thequantuminsider.com/2022/06/28/why-analog-neutral-atoms-quantum-computing-is-a-promising-direction-for-early-quantum-advantage on <The Quantum Insider> useless article mostly by <Pasqal>

\Video[https://youtu.be/-o9AhIz1uvo?t=295]
{title=<TensorFlow Quantum> by Masoud Mohseni (2020)}
{description=At the timestamp, Masoud gives a <thought experiment> example of the perhaps simplest to understand <analog quantum computer>: chained <double-slit experiments> with carefully calculated distances between slits. Calulating the final propability distribution of that grows exponentially.}

= Continuous-variable quantum information
{parent=Analog quantum computer}
{wiki}

TODO synonym to <analog quantum computer>?

It is also possible to carry out <quantum computing> without <qubits> using processes with a <continuous spectrum> of measurement.

As of 2020, these approaches seem less developed/promising, but who knows.

These computers can be seen as analogous to classical non-quantum <analog computers>.

= Quantum computer physical implementation
{parent=Quantum computing hardware}

Lists of the most promising implementations:
* https://en.wikipedia.org/wiki/Quantum_computing#Physical_realizations
* https://quantumcomputingreport.com/scorecards/qubit-count/[], see also: <quantum computing player>{full}.

As of 2020, the hottest by far are:
* <superconducting quantum computer>
* <trapped ion quantum computer>
* <photonic quantum computer>

\Video[https://www.youtube.com/watch?v=N06hC1GL1ns]
{title=How To Build A Quantum Computer by Lukas's Lab (2023)}
{description=
Super quick overview of the main types of <quantum computer physical implementations>, so doesn't any much to a quick <Google>.

He sais he's going to make a series about it, so then something useful might actually come out. The first one was: <video How to Turn Superconductors Into A Quantum Computer by Lukas's Lab (2023)>, but it is still too basic.

The author's full name is Lukas Baker, https://www.linkedin.com/in/lukasbaker1331/[], found with <Google reverse image search>, even though the LinkedIn image is very slightly different from the YouTube one.

As of 2023 he was a <PhD> student at <NYU>.
}

= Diamond vacancy quantum computer
{parent=Quantum computer physical implementation}

https://thequantuminsider.com/2022/03/31/5-quantum-computing-companies-working-with-nv-centre-in-diamond-technology/ on <The Quantum Insider>

5 Companies Working With Diamond NV Quantum Computing Technology.

= N-V center quantum computer
{c}
{parent=Diamond vacancy quantum computer}

= Nitrogen-vacancy center
{parent=Diamond vacancy quantum computer}
{wiki}

= Electron on helium quantum computer
{parent=Quantum computer physical implementation}
{wiki=Electron-on-helium qubit}

= eHe quantum computer
{c}
{synonym}
{title2}

= Organization developing electron on helium quantum computer
{parent=Electron on helium quantum computer}

= EeroQ
{c}
{parent=Organization developing electron on helium quantum computer}

https://eeroq.com/

= Quantum dot quantum computer
{parent=Quantum computer physical implementation}
{tag=Quantum dot}

= Organization developing quantum dot quantum computer
{parent=Quantum dot quantum computer}

= Quantum Motion
{c}
{parent=Organization developing quantum dot quantum computer}
{title2=2017}

* https://www.crunchbase.com/organization/quantum-motion-technologies
* https://quantummotion.tech/

Funding:
* 2023: <£>42m (~\x[\$]50m) https://www.uktech.news/deep-tech/quantum-motion-raises-42m-20230221

= Intel quantum computer
{c}
{parent=Quantum dot quantum computer}

\Video[https://www.youtube.com/watch?v=-5fKVn1GR9Y]
{title=Architecture All Access: Quantum Computing by James Clarke (2021)}

= Superconducting quantum computing
{parent=Quantum computer physical implementation}
{wiki}

= Superconducting quantum computer
{synonym}

Based on the <Josephson effect>. Yet another application of that phenomenal phenomena!

Philosophically, <superconducting qubits are good because superconductivity is macroscopic>.

It is fun to see that the representation of information in the QC basically uses an <LC circuit>, which is a very classical resonator circuit.

As mentioned at https://en.wikipedia.org/wiki/Superconducting_quantum_computing#Qubit_archetypes[] there are actually a few different types of superconducting qubits:
* flux
* charge
* phase

and hybridizations of those such as:
* <transmon>

Input:
* <microwave> radiation to excite circuit, or do nothing and wait for it to fall to 0 spontaneously
* interaction: TODO
* readout: TODO

\Video[http://youtube.com/watch?v=t5nxusm_Umk]
{title=Quantum Computing with Superconducting Qubits by Alexandre Blais (2012)}
{description=
* https://youtu.be/t5nxusm_Umk?t=176 <quantum computing is hard because we want long coherence but fast control>
* https://youtu.be/t5nxusm_Umk?t=784 <superconducting quantum computer need non-linear components>
}

\Video[http://youtube.com/watch?v=Kz6mhh1A_mU]
{title=Quantum Transport, Lecture 16: Superconducting qubits by Sergey Frolov (2013)}
{description=https://youtu.be/Kz6mhh1A_mU?t=1171 describes several possible realizations: charge, flux, charge/flux and phase.}

\Video[https://www.youtube.com/watch?v=uPw9nkJAwDY]
{title=Building a quantum computer with superconducting qubits by <Daniel Sank> (2019)}
{description=
Daniel wears a "Google SB" t-shirt, which either means <shabi> in <Chinese (language)>, or <Santa Barbara>. <Google Quantum AI> is based in <Santa Barbara>, with links to <UCSB>.
* https://youtu.be/uPw9nkJAwDY?t=293 <superconducting qubits are good because superconductivity is macroscopic>. Explains how in non superconducting metal, each electron moves separatelly, and can hit atoms and leak vibration/photos, which lead to observation and quantum error
* https://youtu.be/uPw9nkJAwDY?t=429 made of <aluminium>
* https://youtu.be/uPw9nkJAwDY?t=432 shows the <circuit diagram>, and notes that the thing is basically a <LC circuit>
  ``
  +-----+
  |     |
  |   +-+-+
  |   |   |
  C   X   X
  |   |   |
  |   +-+-+
  |     |
  +-----+
  ``
  using the newly created just now <Ciro's ASCII art circuit diagram notation>. Note that the block on the right is a <SQUID device>.
* https://youtu.be/uPw9nkJAwDY?t=471 mentions that the frequency between states 0 and 1 is chosen to be 6 GHz:
  * higher frequencies would be harder/more expensive to generate
  * lower frequencies would mean less energy according to the <Planck relation>. And less energy means that thermal energy would matter more, and introduce more noise.

    6 GHz is about $6^9 \times h = 6 \times 10^9 \times 6.62 \times 10^{-34} \approx 4\e{-24} J$

    From the definition of the <Boltzmann constant>, the temperature which has that average energe of particles is of the order of:
    $$
    T = E/k_b = 4\e{-24}/1.38\e{-23} \approx 0.3K
    $$
  This explains why we need to go to much lower temperatures than simply the <superconducting temperature of aluminum>!
}

\Video[https://www.youtube.com/watch?v=xjlGL4Mvq7A]
{title=A Brief History of Superconducting Quantum Computing by Steven Girvin (2021)}
{description=
* https://youtu.be/xjlGL4Mvq7A?t=138 <superconducting quantum computer need non-linear components> (too brief if you don't know what he means in advance)
* https://youtu.be/xjlGL4Mvq7A?t=169 <quantum computing is hard because we want long coherence but fast control>
}

\Video[https://www.youtube.com/watch?v=eZJjQGu85Ps]
{title=Superconducting Qubits I Part 1 by Zlatko Minev (2020)}
{description=The Q&A in the middle of talking is a bit annoying.

* https://youtu.be/eZJjQGu85Ps?t=2443 the first actually useful part, shows a <transmon> diagram with some useful formulas on it
}

\Video[https://www.youtube.com/watch?v=SDiiFOham6Y]
{title=Superconducting Qubits I Part 2 by Zlatko Minev (2020)}

\Video[https://www.youtube.com/watch?v=xsdleM-f0i8]
{title=How to Turn Superconductors Into A Quantum Computer by Lukas's Lab (2023)}
{description=This video is just the introduction, too basic. But if he goes through with the followups he promisses, then something might actually come out of it.}

= Superconducting quantum computer need non-linear components
{parent=Superconducting quantum computing}

Non-linearity is needed otherwise the input energy would just make the state go to higher and higher energy levels, e.g. from 1 to 2. But we only want to use levels 0 and 1.

The way this is modelled in by starting from a pure <LC circuit>, which is an harmonic oscillator, see also <quantum LC circuit>, and then replacing the linear <inductor> with a <SQUID device>, e.g. mentioned at: https://youtu.be/eZJjQGu85Ps?t=1655 <video Superconducting Qubits I Part 1 by Zlatko Minev (2020)}>.

= Superconducting qubit
{parent=Superconducting quantum computing}
{wiki}

= Pros and cons of superconducting qubits
{parent=Superconducting qubit}

= Con of superconducting qubits
{parent=Pros and cons of superconducting qubits}

* requires intense refrigeration to 15mK in <dilution refrigerator>. Note that this is much lower than the actual <superconducting temperature> of the metal, we have to go even lower to reduce noise enough, see e.g. https://youtu.be/uPw9nkJAwDY?t=471 from <video Building a quantum computer with superconducting qubits by Daniel Sank (2019)>
* less connectivity, normally limited to 4 nearest neighbours, or maybe 6 for 3D approaches, e.g. compared to <trapped ion quantum computers>, where each trapped ion can be entangled with every other on the same chip

= Superconducting qubits are bad because it is harder to ensure that they are all the same
{parent=Con of superconducting qubits}

This is unlike atomic systems like <trapped ion quantum computers>, where each atom is necessarily exactly the same as the other.

= Pro of superconducting qubits
{parent=Pros and cons of superconducting qubits}

= Superconducting qubits are good because superconductivity is macroscopic
{parent=Pro of superconducting qubits}

Superconducting qubits are regarded as promising because superconductivity is a <macroscopic quantum phenomena> of <Bose-Einstein condensate>[Bose Einstein condensation], and so as a macroscopic phenomena, it is easier to control and observe.

This is mentioned e.g. in this relatively early: https://physicsworld.com/a/superconducting-quantum-bits/[]. While most quantum phenomena is observed at the atomic scale, <superconducting qubits> are micrometer scale, which is huge!
\Q[Physicists are comfortable with the use of quantum mechanics to describe atomic and subatomic particles. However, in recent years we have discovered that micron-sized objects that have been produced using standard semiconductor-fabrication techniques – objects that are small on everyday scales but large compared with atoms – can also behave as quantum particles.]

= Superconducting qubits are bad because of fabrication variation
{parent=Pro of superconducting qubits}

Atom-based <qubits> like <trapped ion quantum computers> have parameters fixed by the laws of physics.

However superconducting qubits have a limit on how precise their parameters can be set based on how well we can fabricate devices. This may require per-device characterisation.

= Superconducting qubit type
{parent=Superconducting qubit}

= Flux qubit
{parent=Superconducting qubit type}
{wiki}

In <Ciro's ASCII art circuit diagram notation>, it is a loop with three <Josephson junctions>:
``
+----X-----+
|          |
|          |
|          |
+--X----X--+
``

\Image[https://upload.wikimedia.org/wikipedia/en/0/04/Flux_Qubit_-_Holloway.jpg]

\Video[https://www.youtube.com/watch?v=daQJMwvxC_U]
{title=Superconducting Qubit by NTT SCL (2015)}
{description=
Offers an interesting interpretation of <superposition> in that type of device (TODO precise name, seems to be a <flux qubit>): current going clockwise or current going counter clockwise at the same time.

Their circuit is a loop with three <Josephson junctions>, in <Ciro's ASCII art circuit diagram notation>:
``
+----X-----+
|          |
|          |
|          |
+--X----X--+
``

They name the clockwise and counter clockwise states $\ket{L}$ and $\ket{R}$ (named for Left and Right).

When half the <magnetic flux quantum> is applied as <microwaves>, this produces the ground state:
$$
\ket{0} = \ket{L} + \ket{R}
$$
where $L$ and $R$ cancel each other out. And the first excited state $\ket{1}$ is:
$$
\ket{0} = \ket{L} - \ket{R}
$$
Then he mentions that:
* to go from 0 to 1, they apply the difference in energy
* if the duration is reduced by half, it creates a superposition of $\ket{0} + \ket{1}$.
}

= Transmon
{parent=Superconducting qubit type}
{title2=2007}
{wiki}

Used e.g. in the <Sycamore processor>.

The most basic type of transmon is in <Ciro's ASCII art circuit diagram notation>, an <LC circuit> e.g. as mentioned at https://youtu.be/cb_f9KpYipk?t=180[] from <video the transmon qubit by Leo Di Carlo (2018)>:
``
+----------+
| Island 1 |
+----------+
   |   |
   X   C
   |   |
+----------+
| Island 2 |
+----------+
``

https://youtu.be/eZJjQGu85Ps?t=2443 from <video Superconducting Qubits I Part 1 by Zlatko Minev (2020)}> describes a (possibly simplified) physical model of it, as two superconducting metal islands linked up by a <Josephson junction> marked as `X` in the diagram as per-<Ciro's ASCII art circuit diagram notation>:
``
+-------+       +-------+
|       |       |       |
| Q_1() |---X---| Q_2() |
|       |       |       |
+-------+       +-------+
``
The circuit is then analogous to a <LC circuit>, with the islands being the <capacitor>. The <Josephson junction> functions as a non-linear <inductor>.

Others define it with a <SQUID device> instead: https://youtu.be/cb_f9KpYipk?t=328 from <video the transmon qubit by Leo Di Carlo (2018)>. He mentions that this allows tuning the inductive element without creating a new device.

\Video[https://www.youtube.com/watch?v=dKTNBN99xLw]
{title=The superconducting <transmon> qubit as a microwave resonator by <Daniel Sank> (2021)}

\Video[https://www.youtube.com/watch?v=5ggYJJjlw8o]
{title=Calibration of Transmon Superconducting Qubits by Stefan Titus (2021)}
{description=Possibly this <Keysight> which would make sense.}

= Rabi cycle
{c}
{parent=Transmon}

= Rabi oscillations
{c}
{synonym}
{title2}

= The Hardware of a Quantum Computer by TU Delft
{parent=Transmon}
{tag=TU Delft}

<EdX> course. Meh! Just give me the <YouTube> list!!

But seriously, this is a valuable little list.

The course is basically exclusively about <transmons>.

\Video[https://www.youtube.com/watch?v=cb_f9KpYipk]
{title=The <transmon> qubit by Leo Di Carlo (2018)}
{description=Via <QuTech Academy>.}

\Video[https://www.youtube.com/watch?v=JmnpcWEuMJY]
{title=Circuit QED by Leo Di Carlo (2018)}
{description=Via <QuTech Academy>.}

\Video[https://www.youtube.com/watch?v=KDANvtOkEc4]
{title=Measurements on transmon qubits by Niels Bultink (2018)}
{description=Via <QuTech Academy>. I wish someone would show some actual equipment running! But this is of interest.}

\Video[https://www.youtube.com/watch?v=_MfABBLtBd0]
{title=<Single-qubit gate> by Brian Taraskinki (2018)}
{description=Good video! Basically you make a phase rotation by controlling the envelope of a pulse.}

\Video[https://www.youtube.com/watch?v=vwjlEdwi2LU]
{title=<Two-qubit gate>[Two qubit gates] by Adriaan Rol (2018)}

\Video[https://www.youtube.com/watch?v=BA5thMaxkyY]
{title=Assembling a Quantum Processor by Leo Di Carlo (2018)}
{description=Via <QuTech Academy>.}

= Organization developing superconducting quantum computer
{parent=Superconducting quantum computing}
{tag=Organization developing quantum hardware}

= Alice&Bob
{c}
{parent=Organization developing superconducting quantum computer}
{tag=French company}
{wiki}

* https://alice-bob.com
* https://www.crunchbase.com/organization/alice-bob

Funding rounds:
* March 2022: 27M Euros

About their <qubit>:
* https://alice-bob.com/2023/02/15/computing-256-bit-elliptic-curve-logarithm-in-9-hours-with-126133-cat-qubits/ Computing 256-bit elliptic curve logarithm in 9 hours with 126,133 cat qubits (2023). This describes their "<cat qubit>".

= Cat qubit
{parent=Alice&Bob}

= Google Quantum AI
{c}
{parent=Organization developing superconducting quantum computer}
{tag=Google project}

https://quantumai.google/hardware/our-lab

<Google>'s quantum hardware/software effort.

The AI is just prerequisite buzzword of the era for any project.

According to job postings such as: https://archive.ph/wip/Fdgsv their center is in Goleta, <California>, near <Santa Barbara>. Though Google tends to promote it more as Santa Barbara, see e.g. Daniel's t-shirt at <video Building a quantum computer with superconducting qubits by Daniel Sank (2019)}>.

\Video[https://youtube.com/watch?v=VA2HEUmkrKo]
{title=Control of <transmon> qubits using a cryogenic <CMOS> integrated circuit (QuantumCasts) by <Google> (2020)}
{description=Fantastic video, good photos of the <Google Quantum AI> setup!}

= Daniel Sank
{c}
{parent=Google Quantum AI}
{wiki}

* https://www.linkedin.com/in/daniel-sank-a3679a92/
* https://github.com/DanielSank

Cool dude. Uses <Stack Exchange>: https://physics.stackexchange.com/users/31790/danielsank

Started at <Google Quantum AI> in 2014.

Has his <LaTeX> notes at: https://github.com/DanielSank/theory[]. One day he will convert to <OurBigBook.com>. Interesting to see that he is able to continue his notes despite being at Google.

= Sycamore processor
{c}
{parent=Google Quantum AI}
{wiki}

This is a good read: https://quantumai.google/hardware/datasheet/weber.pdf May 14, 2021. Their topology is so weird, not just a rectangle, one wonders why! You get different error rates in different qubits, it's mad.

\Image[https://raw.githubusercontent.com/cirosantilli/media/master/Google_Sycamore_Weber_quantum_computer_connectivity_graph.png]
{title=Google Sycamore Weber quantum computer connectivity graph}
{description=Weber is a specific processor of the Sycamore family. From this we see it clearly that qubits are connected to at most 4 other qubits, and that the full topology is not just a simple rectangle.}

= IBM Quantum Computing
{c}
{parent=Organization developing superconducting quantum computer}
{tag=IBM}

= IBM Q
{title2}
{synonym}

The term "IBM Q" has been used in some promotional material as of 2020, e.g.: https://www.ibm.com/mysupport/s/topic/0TO50000000227pGAA/ibm-q-quantum-computing?language=en_US though the fuller form "IBM Quantum Computing" is somewhat more widely used.

They also internally named an division as "IBM Q": https://sg.news.yahoo.com/ibm-thinks-ready-turn-quantum-050100574.html

= IBM quantum computer
{c}
{parent=IBM quantum computing}

= OpenSuperQ
{c}
{parent=Organization developing superconducting quantum computer}

<Open source> superconducting quantum computer hardware design!

\Video[https://www.youtube.com/watch?v=2cU2PA4Q0Bw]
{title=OpenSuperQ intro by Quantum Flagship (2021)}
{description=
* https://youtu.be/2cU2PA4Q0Bw?t=61[]: <Dilution refrigerator> by <Bluefors>
}

= Oxford Quantum Circuits
{c}
{parent=Organization developing superconducting quantum computer}
{tag=British company}
{tag=University of Oxford spinout company}
{title2=2017}
{title2=OQC}

https://oxfordquantumcircuits.com/

Their main innovation seems to be their 3D design which they call "Coaxmon".

Funding:
* 2023: \x[\$]1m (869,000 pounds) for <Japan> expansion: https://www.uktech.news/deep-tech/oqc-funding-japan-20230203
* 2022: \x[\$]47m (38M pounds) https://techcrunch.com/2022/07/04/uks-oxford-quantum-circuits-snaps-up-47m-for-quantum-computing-as-a-service/
* 2017: \x[\$]2.7m https://globalventuring.com/university/oxford-quantum-calculates-2-7m/

\Video[https://www.youtube.com/watch?v=dPtsOmdofnA]
{title=The Coaxmon by <Oxford Quantum Circuits> (2022)}

= Ilana Wisby
{c}
{parent=Oxford Quantum Circuits}

Founding CEO of <Oxford Quantum Circuits>.

As mentioned at https://www.investmentmonitor.ai/tech/innovation/in-conversation-with-oxford-quantum-circuits-ilana-wisby[] she is not the original tech person:
\Q[she was finally headhunted by Oxford Science and Innovation to become the founding CEO of OQC. The company was spun out of Oxford University's physics department in 2017, at which point Wisby was handed "a laptop and a patent".]
Did they mean <Oxford Sciences Enterprises>? There's nothing called "Oxford Science and Innovation" on <Google>. Yes, it is just a typo https://oxfordscienceenterprises.com/news/meet-the-founder-ilana-wisby-ceo-of-oxford-quantum-circuits/ says it clearly:
\Q[I was headhunted by <Oxford Sciences Enterprises> to be the founding CEO of OQC.]

https://oxfordquantumcircuits.com/story mentions that the core patent was by Dr. Peter Leek: https://www.linkedin.com/in/peter-leek-00954b62/

= Rigetti Computing
{c}
{parent=Organization developing superconducting quantum computer}
{tag=Company}
{title2=2017}
{title2=OQC}
{wiki}

\Video[https://www.youtube.com/watch?v=SDQXGv1V2dc]
{title=Forest: an Operating System for Quantum Computing by Guen Prawiroatmodjo (2017)}
{description=The title of the talk is innapropriate, this is a very basic overview of the entire <Rigetti Computing> stack. Still some fine mentions. Her name is so long, TODO origin? She later moved to <Microsoft Quantum>: https://www.linkedin.com/in/gueneverep/[].}

= Topological quantum computer
{parent=Quantum computer physical implementation}
{wiki}

= Topological quantum computation
{synonym}

\Video[https://www.youtube.com/watch?v=igPXzKjqrNg]
{title=Topological Quantum Computer by Professor John Preskill}

\Video[https://www.youtube.com/watch?v=CnsQRValXdk]
{title=Topological Quantum Computation by Jason Alicea (2021)}

\Video[https://www.youtube.com/watch?v=LRrRgGmEeqA]
{title=Anyons by Yuly Billig (2022)}

= Trapped ion quantum computer
{parent=Quantum computer physical implementation}
{wiki}

TODO understand.

\Video[https://www.youtube.com/watch?v=j1SKprQIkyE]
{title=Trapping Ions for Quantum Computing by Diana Craik (2019)}
{description=
A basic introduction, but very concrete, with only a bit of math it might be amazing:
* https://youtu.be/j1SKprQIkyE?t=217 you need <ultra-high vacuum>
* https://youtu.be/j1SKprQIkyE?t=257 you put the <Calcium> on a "calcium oven", heat it up, and make it evaporates a little bit
* https://youtu.be/j1SKprQIkyE?t=289 you need <lasers>. You shine the laser on the calcium atom to eject one of the two valence electrons from it. Though e.g. <Universal Quantum> is trying to do away with them, because alignment for thousands or millions of particles would be difficult.
* https://youtu.be/j1SKprQIkyE?t=518 keeping all surrounding electrodes positive would be unstable. So they instead alternate electrode quickly between plus and minus
* https://youtu.be/j1SKprQIkyE?t=643 talks about the alternative, of doing it just with electrodes on a chip, which is easier to manufacture. They fly at about 100 microns above the trap. And you can have multiple ions per chip.
* https://youtu.be/j1SKprQIkyE?t=1165 using <microwaves> you can flip the <spin> of the <electron>, or put it into a superposition. From more reading, we understand that she is talking about a <hyperfine transition>, which often happen in the <microwave> area.
* https://youtu.be/j1SKprQIkyE?t=1210 talks about making <quantum gates>. You have to put the ions into a <magnetic field> at one of the two <resonance frequencies> of the system. Presumably what is meant is an inhomogenous magnetic field as in the <Stern-Gerlach experiment>.

  This is the hard and interesting part. It is not clear why the atoms become coupled in any way. Is it due to electric repulsion?

  She is presumably describing the <Cirac–Zoller CNOT gate>.
Sounds complicated, several technologies need to work together for that to work! Videos of ions moving are from https://www.physics.ox.ac.uk/research/group/ion-trap-quantum-computing[].

A major flaw of this presentation is not explaining the <readout quantum computing> process.
}

\Video[https://www.youtube.com/watch?v=LR_aNOcnH0Q]
{title=How To Trap Particles in a Particle Accelerator by the <Royal Institution> (2016)}
{description=Demonstrates trapping pollen particles in an alternating field.}

\Video[https://www.youtube.com/watch?v=lJOuPmI--5c]
{title=Ion trapping and quantum gates by Wolfgang Ketterle (2013)}
{description=
* https://youtu.be/lJOuPmI--5c?t=1601 <Cirac–Zoller CNOT gate> was the first 2 qubit gate. Explains it more or less.
}

\Video[https://www.youtube.com/watch?v=W3l0QPEnaq0]
{title=Introduction to quantum optics by Peter Zoller (2018)}
{description=
THE Zoller from <Cirac–Zoller CNOT gate> talks about his gate.
* https://www.youtube.com/watch?v=W3l0QPEnaq0&t=427s shows that the state is split between two options: center of mass mode (ions move in same direction), and strechmode (atoms move in opposite directions)
* https://youtu.be/W3l0QPEnaq0?t=658 shows a schematic of the experiment
}

= Cirac–Zoller controlled-NOT gate
{c}
{parent=Trapped ion quantum computer}
{title2=1995}
{wiki}

= Cirac–Zoller CNOT gate
{c}
{synonym}

= Ion trap
{parent=Trapped ion quantum computer}
{wiki}

= Modular trapped ion quantum computer
{parent=Trapped ion quantum computer}

Trapped ion people acknowledge that they can't put a million qubits in on chip (TODO why) so they are already thinking of ways to entangle separate chips. Thinking is maybe the key word here. One of the propoesd approaches inolves optical links. <Universal Quantum> for example explicitly rejects that idea in favor of electric field link modularity.

= Organization developing trapped ion quantum computer
{parent=Trapped ion quantum computer}
{tag=Organization developing quantum hardware}

= IonQ
{c}
{parent=Organization developing trapped ion quantum computer}
{tag=Company}
{title2=2015}
{wiki}

\Video[https://www.youtube.com/watch?v=LEqPlDrMXjs]
{title=Quantum Simulation and Computation with Trapped Ions by Christopher Monroe (2021)}

\Video[https://www.youtube.com/watch?v=9aOLwjUZLm0]
{title=Quantum Computing with Trapped Ions by Christopher Monroe (2018)}
{description=
Co-founder of <IonQ>. Cool dude. Starts with basic background we already know now. Mentions that there is some relationship between <atomic clocks> and <trapped ion quantum computers>, which is interesting. Then he goes into turbo mode, and you get lost unless you're an expert! <video Quantum Simulation and Computation with Trapped Ions by Christopher Monroe (2021}> is perhaps a better watch.
* https://youtu.be/9aOLwjUZLm0?t=1216 <superconducting qubits are bad because it is harder to ensure that they are all the same>
* https://youtu.be/9aOLwjUZLm0?t=1270 our wires are provided by <lasers>. Gives example of <ytterbium>$^{+1}$, which has nice frequencies for practical <laser> choice. Ytterbium ends in 6s2 5d1, so they must remove the 5d1 electron? But then you are left with 2 electrons in 6s2, can you just change their spins at will without problem?
* https://youtu.be/9aOLwjUZLm0?t=1391 a single atom actually reflects 1% of the input laser, not bad!
* https://youtu.be/9aOLwjUZLm0?t=1475 a transition that they want to drive in Ytterbium has 355 nm, which is easy to generate TODO why.
* https://youtu.be/9aOLwjUZLm0?t=1520 mentions that 351 would be much harder, e.g. as used in inertially confied fusion, takes up a room
* https://youtu.be/9aOLwjUZLm0?t=1539 what they use: a <pulsed laser>. It is made primarily for <photolithography>, <Coherent, Inc.> makes 200 of them a year, so it is reliable stuff and easy to operate. At https://www.coherent.com/lasers/nanosecond/avia-nx we can see some of their 355 offers. https://archive.ph/wip/JKuHI shows a used system going for 4500 USD.
* https://youtu.be/9aOLwjUZLm0?t=1584 Cirac and Zoller proposed the idea of using entangled ions soon after they heard about <Shor's algorithm> in 1995
* https://youtu.be/9aOLwjUZLm0?t=1641 you use <optical tweezers> to move the pairs of ions you want to entangle. This means shining a <laser> on two ions at the same time. Their movement depends on their <spin>, which is already in a superposition. If both move up, their distance stats the same, so the <Coulomb interaction> is unchanged. But if they are different, then one goes up and the other down, distance increases due to the diagonal, and energy is lower.
* https://youtu.be/9aOLwjUZLm0?t=1939 S. Debnah 2016 Nature experiment with a pentagon. Well, it is not a pentagon, they are just in a linear chain, the pentagon is just to convey the full connectivity. Maybe also <Satanism>. Anyways. This point also mentions usage of an <acousto-optic modulator> to select which atoms we want to act on. On the other side, a simpler wide laser is used that hits all atoms (<optical tweezers> are literally like tweezers in the sense that you use two lasers). Later on mentions that the modulator is from Harris, later merged with L3, so: https://www.l3harris.com/all-capabilities/acousto-optic-solutions
* https://youtu.be/9aOLwjUZLm0?t=2119 <Bernstein-Vazirani algorithm>. This to illustrate better connectivity of their ion approach compared to an <IBM quantum computer>, which is a <superconducting quantum computer>
* https://youtu.be/9aOLwjUZLm0?t=2354 <hiden shift algorithm>
* https://youtu.be/9aOLwjUZLm0?t=2740 Zhang et al. Nature 2017 paper about a 53 ion system that calculates something that cannot be classically calculated. Not fully controllable though, so more of a <continuous-variable quantum information> operation.
* https://youtu.be/9aOLwjUZLm0?t=2923 usage of cooling to 4 K to get lower pressures on top of vacuum. Before this point all experiments were room temperature. Shows image of refrigerator labelled Janis cooler, presumably something like: https://qd-uki.co.uk/cryogenics/janis-recirculating-gas-coolers/
* https://youtu.be/9aOLwjUZLm0?t=2962 qubit vs gates plot by H. Neven
* https://youtu.be/9aOLwjUZLm0?t=3108 <modular trapped ion quantum computer> ideas. Mentions experiment with 2 separate systems with optical link. Miniaturization and their black box. Mentions again that their chip is from <Sandia>. Amazing how you pronounce that.
}

= NQIT
{c}
{parent=Organization developing trapped ion quantum computer}
{tag=UKRI}
{wiki}

\Video[https://www.youtube.com/watch?v=aV1wL5jsfRU]
{title=Quantum Computing with Networked <Ion Traps> by <NQIT> (2018)}
{description=The video is a bit useless. But it does show the networked approach proposal a little bit. <Universal Quantum>'s homepage particularly rejects that.}

= Oxford Ionics
{c}
{parent=Organization developing trapped ion quantum computer}
{tag=British company}
{tag=University of Oxford spinout company}
{title2=2017}
{title2=OQC}

* https://www.oxionics.com/
* https://www.crunchbase.com/organization/oxford-ionics

This job announcement from 2022 gives a good idea about their tech stack: https://web.archive.org/web/20220920114810/https://oxfordionics.bamboohr.com/jobs/view.php?id=32&source=aWQ9MTA%3D[]. Notably, they use <ARTIQ>.

Funding:
* 2023: \x[\$]36m https://www.forbes.com/sites/gilpress/2023/01/09/36-million-oxford-ionics-funding-to-jump-start-quantum-computing-in-2023/?sh=6af75e7a6ccb

= Quantinuum
{c}
{parent=Organization developing trapped ion quantum computer}
{tag=Company}

Merger between <Cambridge Quantum Computing>, which does <quantum software>, and <Honeywell Quantum Solutions>, which does the hardware.

= Quantinuum hardware
{c}
{parent=Quantinuum}

= Quantinuum H1
{c}
{parent=Quantinuum hardware}

= Quantinuum H1-2
{c}
{parent=Quantinuum hardware}

E.g.: https://www.quantinuum.com/pressrelease/demonstrating-benefits-of-quantum-upgradable-design-strategy-system-model-h1-2-first-to-prove-2-048-quantum-volume from 2021.

= Cambridge Quantum Computing
{c}
{parent=quantinuum}
{tag=Organization developing quantum software}
{tag=University of Cambridge spinout company}
{wiki}

In 2015, they got a 50 million investment from Grupo Arcano, led by Alberto Chang-Rajii, who is a really shady character who fled from justice for 2 years:
* http://web.archive.org/web/20160320064944/http://www.cambridgequantum.com/index.php?page=team Alberto on the board
* https://theshiftnews.com/2018/10/25/wanted-chilean-businessman-in-hiding-in-malta-for-two-years/
* https://www.techbritannia.co.uk/2015/09/cambridge-quantum-computing-receives-50m-funding-from-grupo-arcano/
Merged into <Quantinuum> later on in 2021.

= tket
{c}
{parent=Cambridge Quantum Computing}
{tag=Quantum compiler}
{wiki}

https://github.com/CQCL/tket

TODO vs all the others?

= Honeywell Quantum Solutions
{c}
{parent=Quantinuum}
{tag=Honeywell}

= Universal Quantum
{c}
{parent=Organization developing trapped ion quantum computer}
{tag=British company}

As of 2021, their location is a small business park in Haywards Heath, about 15 minutes north of <Brighton>https://www.midsussex.gov.uk/about-us/press-releases-and-publications/cutting-edge-tech-company-invests-in-mid-sussex/{ref}

Funding rounds:
* 2022:
  * 67m euro contract with the <German> government: https://www.uktech.news/deep-tech/universal-quantum-german-contract-20221102 Both co-founders are German. They then immediatly announced several jobs in Hamburg: https://apply.workable.com/universalquantum/?lng=en#jobs so presumably linked to the Hamburg University of Technology campus of the German Aerospace Center.
  * https://medium.com/@universalquantum/universal-quantum-wins-67m-contract-to-build-the-fully-scalable-trapped-ion-quantum-computer-16eba31b869e
* 2021: \$10M (7.5M GBP) grant from the <British Government>: https://www.uktech.news/news/brighton-universal-quantum-wins-grant-20211105

  This grant is very secretive, very hard to find any other information about it! Most investment trackers are not listing it.

  The article reads:
  \Q[Universal Quantum will lead a consortium that includes Rolls-Royce, quantum developer <Riverlane>, and world-class researchers from <Imperial College London> and The <University of Sussex>, among others.]
  Interesting!

  A but further down the article gives some more information of partners, from which some of the hardware vendors can be deduced:
  \Q[The consortium includes end-user <Rolls-Royce> supported by the <Science and Technology Facilities Council> (STFC) Hartree Centre, quantum software developer <Riverlane>, supply chain partners Edwards, https://www.tmd.co.uk/[TMD Technologies] (now acquired by Communications & Power Industries (CPI)) and https://www.diamondmic.com/[Diamond Microwave]]
  * Edwards is presumably <Edwards Vacuum>, since we know that <trapped ion quantum computers> rely heavily on good vacuum systems. Edwards Vacuum is also located quite close to Universal Quantum as of 2022, a few minutes drive.
  * TMD Technologies is a <microwave> technology vendor amongst other things, and we know that microwaves are used e.g. to initialize the spin states of the ions
  * Diamond Microwave is another microwave stuff vendor

  The money comes from UK's "Industrial Strategy Challenge Fund".

  https://www.riverlane.com/news/2021/12/riverlane-joins-7-5-million-consortium-to-build-error-corrected-quantum-processor/ gives some more details on the use case provided by Rolls Royce:
  \Q[
  The work with Rolls Royce will explore how quantum computers can develop practical applications toward the development of more sustainable and efficient jet engines.  

  This starts by applying quantum algorithms to take steps to toward a greater understanding of how liquids and gases flow, a field known as '<fluid dynamics>'. Simulating such flows accurately is beyond the computational capacity of even the most powerful classical computers today.
  ]

  This funding was part of a larger quantum push by the <UKNQTP>: https://www.ukri.org/news/50-million-in-funding-for-uk-quantum-industrial-projects/
* 2020: \$4.5M (3.5M GBP) https://www.crunchbase.com/organization/universal-quantum[]. Just out of stealth.

Co-founders:
* Sebastian Weidt. He is <German>, right? Yes at https://youtu.be/SwHaJXVYIeI?t=1078[] from <video Fireside Chat with with Sebastian Weidt by Startup Grind Brighton (2022)>. The company was founded by two Germans from Essex!
* Winfried Hensinger: if you saw him on the street, you'd think he plays in a punk-rock band. That West Berlin feeling.

Homepage says only needs cooling to 70 K. So it doesn't work with <liquid nitrogen> which is 77 K?

Homepage points to foundational paper: https://www.science.org/doi/10.1126/sciadv.1601540

\Video[https://www.youtube.com/watch?v=rYe9TXz35B8]
{title=Universal Quantum emerges out of stealth by <University of Sussex> (2020)}
{description=
Explains that a more "traditional" <trapped ion quantum computer> would user "pairs of <lasers>", which would require a lot of lasers. Their approach is to try and do it by applying voltages to a microchip instead.
* https://youtu.be/rYe9TXz35B8?t=127 shows some 3D models. It shows how <piezoelectric actuators> are used to align or misalign some plates, which presumably then determine conductivity
}

\Video[https://www.youtube.com/watch?v=WhredTaZvTs]
{title=Quantum Computing webinar with Sebastian Weidt by Green Lemon Company (2020)}
{description=The sound quality is to bad to stop and listen to, but it presumaby shows the coding office in the background.}

\Video[https://www.youtube.com/watch?v=SwHaJXVYIeI]
{title=Fireside Chat with with Sebastian Weidt by Startup Grind Brighton (2022)}
{description=
Very basic target audience:
* https://youtu.be/SwHaJXVYIeI?t=680 we are not at a point where you can buy victory. There is too much uncertainty involved across different approaches.
* https://youtu.be/SwHaJXVYIeI?t=949 his background
* https://youtu.be/SwHaJXVYIeI?t=1277 difference between <venture capitalists> in different countries
* https://youtu.be/SwHaJXVYIeI?t=1535 they are 33 people now. They've just setup their office in Haywards Heath, north of Bristol.
}

= Neutral atom quantum computer
{parent=Quantum computer physical implementation}

* https://quantumtech.blog/2023/01/17/quantum-computing-with-neutral-atoms/

= Organization developing neutral atom quantum computer
{parent=Neutral atom quantum computer}
{tag=Organization developing quantum hardware}

= Atom Computing
{c}
{parent=Organization developing neutral atom quantum computer}
{tag=American company}

These people are cool.

They use <optical tweezers> to place individual atoms floating in midair, and then do stuff to entangle their <nuclear spins>.

= QuEra
{c}
{parent=Organization developing neutral atom quantum computer}
{tag=American company}
{tag=Analog quantum computer}
{title2=2018}

* https://www.quera.com/about
* https://mobile.twitter.com/queracomputing

= Pasqal
{c}
{parent=Organization developing neutral atom quantum computer}
{tag=French company}
{tag=Analog quantum computer}

https://pasqal.io/

Funding:
* 2023: \x[\$]100m https://techcrunch.com/2023/01/23/pasqal-raises-100m-to-build-a-neutral-atom-based-quantum-computer/

= Photonic quantum computer
{parent=Quantum computer physical implementation}
{wiki=Linear optical quantum computing}

= Linear optical quantum computing
{title2}
{synonym}

* https://en.wikipedia.org/wiki/Linear_optical_quantum_computing
* https://en.wikipedia.org/wiki/KLM_protocol

Uses <photons>!

The key experiment/phenomena that sets the basis for photonic quantum computing is the <two photon interference experiment>.

The physical representation of the information encoding is very easy to understand:
* input: we choose to put or not photons into certain wires or no
* interaction: two wires pass very nearby at some point, and photons travelling on either of them can jump to the other one and interact with the other photons
* output: the probabilities that photos photons will go out through one wire or another

\Video[http://youtube.com/watch?v=7wCBkAQYBZA]
{title=Jeremy O'Brien: "Quantum Technologies" by GoogleTechTalks (2014)}
{description=
This is a good introduction to a <photonic quantum computer>. Highly recommended.
* https://youtube.com/watch?v=7wCBkAQYBZA&t=1285 shows an experimental curve for a <two photon interference experiment> by Hong, Ou, Mandel (1987)
* https://youtube.com/watch?v=7wCBkAQYBZA&t=1440 shows a KLM <CNOT gate>
* https://youtube.com/watch?v=7wCBkAQYBZA&t=2831 discusses the <quantum error correction> scheme for photonic QC based on the idea of the "Raussendorf unit cell"
}

= Organization developing photonic quantum computer
{parent=Photonic quantum computer}
{tag=Organization developing quantum hardware}

= Quandela
{c}
{parent=Organization developing photonic quantum computer}
{tag=French company}

https://www.quandela.com

One interesting aspect of this company is that they are trying to sell not only full <quantum computers>, but also components that could be used by competitors, such as 

= Prometheus single photon source
{c}
{parent=Quandela}

https://www.quandela.com/prometheus/ (https://web.archive.org/web/20240110044019/https://www.quandela.com/prometheus/[2024 archive])

= ORCA Computing
{c}
{parent=Organization developing photonic quantum computer}
{tag=British company}

https://www.orcacomputing.com/

* 2022: \$15 million https://www.orcacomputing.com/blog/orca-computing-completes-15-million-series-a-funding-round
* 2021: \$14.5 million for an <Innovate UK> project

= PsiQuantum
{c}
{parent=Organization developing photonic quantum computer}
{tag=Company}

CEO: <Jeremy O'Brien>

Raised 215M in 2020: https://www.bloomberg.com/news/articles/2020-04-06/quantum-computing-startup-raises-215-million-for-faster-device

Good talk by CEO before starting the company which gives insight on what they are very likely doing: <video Jeremy O'Brien: "Quantum Technologies" by GoogleTechTalks (2014)>

PsiQuantum appears to be particularly secretive, even more than other startups in the field.

They want to reuse classical <semiconductor physical implementation>[semiconductor fabrication technologies], notably they have close ties to <GlobalFoundries>.

So he went to the <US> and raised N times more from the <American> <military-industrial complex>.

= Jeremy O'Brien
{c}
{parent=PsiQuantum}
{wiki}

https://www.linkedin.com/in/jeremy-o-brien-39482631

= PsiQuantum founding myth
{c}
{parent=PsiQuantum}

Once upon a time, the <British Government> decided to invest some 80 million into <quantum computing>.

<Jeremy O'Brien> told his peers that he had the best tech, and that he should get it all.

Some well connected peers from well known universities did not agree however, and also bid for the money, and won.

Jeremy was defeated. And pissed.

So he moved to <Palo Alto> and raised a total of \$665 million instead as of 2021. The end.

Makes for a reasonable <the old man lost his horse>.

https://www.ft.com/content/afc27836-9383-11e9-aea1-2b1d33ac3271 British quantum computing experts leave for Silicon Valley talks a little bit about them leaving, but nothing too juicy. They were called PsiQ previously apparently.
\Q[The departure of some of the UK’s leading experts in a potentially revolutionary new field of technology will raise fresh concerns over the country’s ability to develop industrial champions in the sector.]
More interestingly, the article mentions that this was party advised by early investor <Hermann Hauser>, who is known to be preoccupied about UK's ability to create companies. Of course, <European Tower of Babel>.

= Xanadu Quantum Technologies
{c}
{parent=Organization developing photonic quantum computer}
{tag=Company}
{wiki}

= Xanadu
{disambiguate=quantum}
{c}
{synonym}

= Xanadu
{disambiguate=quantum computing company}
{c}
{synonym}

Rounds:
* 2022-11: 100m USD https://www.prnewswire.com/news-releases/xanadu-closes-100m-usd-series-c-to-accelerate-development-of-fault-tolerant-quantum-computers-301672611.html

https://www.youtube.com/watch?v=v7iAqcFCTQQ shows their base technology:
* <laser> beam comes in
* input set via of <optical ring resonators> that form a <squeezed state of light>. Does not seem to rely on <single photon production and detection experiments>?

= Quantum interconnect
{parent=Quantum computing}

"Quantum interconnect" refers to methods for linking up smaller quantum processors into a larger system.

As of 2024, seemingly few <organizations developing quantum hardware> had actually integrated multiple chips in interconnects as part of their main current roadmap. But many acknowledged that this would be an essential step towards scalable compuation.

The name "quantum interconnect" is likely partly a throwback to <classical computer>'s "<chip interconnect>".

Sample usages of the term:
* https://news.mit.edu/2023/quantum-interconnects-photon-emission-0105
  \Q[Researchers have demonstrated directional photon emission, the first step toward extensible \b[quantum interconnects]]
* https://qpl.ece.ucsb.edu/research/quantum-interconnects

= Quantum interconnect company
{parent=Quantum interconnect}

= Welinq
{c}
{parent=Quantum interconnect company}
{tag=French company}

Funding:
* 2023-01-23 €5 Million
  * https://thequantuminsider.com/2023/01/23/welinq-closes-e5-million-pre-seed-round/

= Quantum computer simulator
{parent=Quantum computing}

= Quantum computer simulation
{synonym}

Other good lists:
* https://quantumcomputingreport.com/resources/tools/ is hard to beat as usual.
* https://www.quantiki.org/wiki/list-qc-simulators

* <JavaScript>
  * https://algassert.com/quirk demo: https://github.com/Strilanc/Quirk drag-and-drop, by a 2019-quantum-computing-<Googler>, impressive. You can create gates. State store in URL.
  * https://github.com/stewdio/q.js/ demo: https://quantumjavascript.app/

Bibliography:
* https://www.epcc.ed.ac.uk/whats-happening/articles/energy-efficient-quantum-computing-simulations mentions two types of <quantum computer simulation>:
 * \Q[The most common approach to quantum simulations is to store the whole state in memory and to modify it with gates in a given order]
 * \Q[However, there is a completely different approach that can sometimes eliminate this issue - tensor networks]

= Quantum software
{parent=Quantum computing}

= Quantum programming framework
{parent=Quantum software}

= Cirq
{c}
{parent=Quantum programming framework}
{wiki}

= Qiskit
{c}
{parent=Quantum programming framework}
{tag=Python library}
{wiki}

<Python> library, claims multiple backends, including <Quantum computer simulator>[simulation] and real <IBM quantum computer>.

= Qiskit example
{c}
{parent=Qiskit}

= Qiskit hello world
{c}
{parent=Qiskit example}
{tag=Hello world}

The official <hello world> is documented at: https://qiskit.org/documentation/intro_tutorial1.html and contains a <Bell state circuit>.

Our version at <qiskit/hello.py>{file}.

= qiskit/hello.py
{file}
{parent=Qiskit hello world}

Our example uses a <Bell state circuit> to illustrate all the fundamental <Qiskit> basics.

Sample program output, `counts` are randomized each time.

First we take the <quantum state vector> immediately after the $\ket{00}$ input.
``
input:
state:
Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))
probs:
[1. 0. 0. 0.]
``
We understand that the first element of `Statevector` is $\ket{00}$, and has probability of 1.0.

Next we take the state after a <Hadamard gate> on the first <qubit>:
``
h:
state:
Statevector([0.70710678+0.j, 0.70710678+0.j, 0.        +0.j,
             0.        +0.j],
            dims=(2, 2))
probs:
[0.5 0.5 0.  0. ]
``
We now understand that the second element of the `Statevector` is $\ket{01}$, and now we have a 50/50 propabability split for the first bit.

Then we apply the <CNOT gate>:
``
cx:
state:
Statevector([0.70710678+0.j, 0.        +0.j, 0.        +0.j,
             0.70710678+0.j],
            dims=(2, 2))
probs:
[0.5 0.  0.  0.5]
``
which leaves us with the final $\frac{\ket{00} + \ket{11}}{\sqrt{2}}$.

Then we print the circuit a bit:
``
qc without measure:
     ┌───┐
q_0: ┤ H ├──■──
     └───┘┌─┴─┐
q_1: ─────┤ X ├
          └───┘
c: 2/══════════

qc with measure:
     ┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1
qasm:
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
``

And finally we <quantum compilation>[compile] the circuit and do some sample measurements:
``
qct:
     ┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1
counts={'11': 484, '00': 516}
counts={'11': 493, '00': 507}
``

= qiskit/initialize.py
{c}
{parent=Qiskit example}

In this example we will initialize a quantum circuit with a single <CNOT gate> and see the output values.

By default, <Qiskit> initializes every <qubit> to 0 as shown in the <qiskit/hello.py>{file}. But we can also initialize to arbitrary values as would be done when computing the output for various different inputs.

Output:
``
     ┌──────────────────────┐
q_0: ┤0                     ├──■──
     │  Initialize(1,0,0,0) │┌─┴─┐
q_1: ┤1                     ├┤ X ├
     └──────────────────────┘└───┘
c: 2/═════════════════════════════

init: [1, 0, 0, 0]
probs: [1. 0. 0. 0.]

init: [0, 1, 0, 0]
probs: [0. 0. 0. 1.]

init: [0, 0, 1, 0]
probs: [0. 0. 1. 0.]

init: [0, 0, 0, 1]
probs: [0. 1. 0. 0.]

     ┌──────────────────────────────────┐
q_0: ┤0                                 ├──■──
     │  Initialize(0.70711,0,0,0.70711) │┌─┴─┐
q_1: ┤1                                 ├┤ X ├
     └──────────────────────────────────┘└───┘
c: 2/═════════════════════════════════════════

init: [0.7071067811865475, 0, 0, 0.7071067811865475]
probs: [0.5 0.5 0.  0. ]
``
which we should all be able to understand intuitively given our understanding of the <CNOT gate> and <quantum state vectors>.

https://quantumcomputing.stackexchange.com/questions/13202/qiskit-initializing-n-qubits-with-binary-values-0s-and-1s describes how to initialize circuits qubits only with binary 0 or 1 to avoid dealing with the exponential number of elements of the <quantum state vector>.

= qiskit/qft.py
{file}
{parent=Qiskit example}
{tag=Quantum fourier transform}

This is an example of the `qiskit.circuit.library.QFT` implementation of the <Quantum fourier transform> function which is documented at: https://docs.quantum.ibm.com/api/qiskit/0.44/qiskit.circuit.library.QFT

Output:
``
init: [1, 0, 0, 0, 0, 0, 0, 0]
qc
     ┌──────────────────────────────┐┌──────┐
q_0: ┤0                             ├┤0     ├
     │                              ││      │
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├┤1 QFT ├
     │                              ││      │
q_2: ┤2                             ├┤2     ├
     └──────────────────────────────┘└──────┘
transpiled qc
     ┌──────────────────────────────┐                                     ┌───┐   
q_0: ┤0                             ├────────────────────■────────■───────┤ H ├─X─
     │                              │              ┌───┐ │        │P(π/2) └───┘ │ 
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├──────■───────┤ H ├─┼────────■─────────────┼─
     │                              │┌───┐ │P(π/2) └───┘ │P(π/4)                │ 
q_2: ┤2                             ├┤ H ├─■─────────────■──────────────────────X─
     └──────────────────────────────┘└───┘
Statevector([0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
             0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
             0.35355339+0.j, 0.35355339+0.j],
            dims=(2, 2, 2))

init: [0.0, 0.35355339059327373, 0.5, 0.3535533905932738, 6.123233995736766e-17, -0.35355339059327373, -0.5, -0.35355339059327384]
Statevector([ 7.71600526e-17+5.22650714e-17j,
              1.86749130e-16+7.07106781e-01j,
             -6.10667421e-18+6.10667421e-18j,
              1.13711443e-16-1.11022302e-16j,
              2.16489014e-17-8.96726857e-18j,
             -5.68557215e-17-1.11022302e-16j,
             -6.10667421e-18-4.94044770e-17j,
             -3.30200457e-16-7.07106781e-01j],
            dims=(2, 2, 2))
``
So this also serves as a more interesting example of <quantum compilation>, mapping the `QFT` gate to <Qiskit Aer> primitives.

If we don't `transpile` in this example, then running blows up with:
``
qiskit_aer.aererror.AerError: 'unknown instruction: QFT'
``

The second input is:
$$
x_i = \frac{1}{2} sin(2 * \pi * i / 8)
$$
and the output of that approximately:
``
[0, 1j/sqrt(2), 0, 0, 0, 0, 0, 1j/sqrt(2)]
``
which can be defined simply as the <normalized DFT> of the input <quantum state vector>.

From this we see that the <Quantum fourier transform> is equivalent to a direct <discrete Fourier transform> on the <quantum state vector>, related: https://physics.stackexchange.com/questions/110073/how-to-derive-quantum-fourier-transform-from-discrete-fourier-transform-dft

= Qiskit component
{c}
{parent=Qiskit}

= `qiskit.transpile()`
{c}
{parent=Qiskit component}

This function does <quantum compilation>. Shown e.g. at <qiskit/qft.py>{file}.

= Qiskit Aer
{c}
{parent=Qiskit component}
{tag=Quantum computer simulator}

https://github.com/Qiskit/qiskit-aer

= AerError: 'unknown instruction
{c}
{parent=Qiskit Aer}

You get an error like this if you forget to call <qiskit.transpile()>:
``
qiskit_aer.aererror.AerError: 'unknown instruction: QFT'
``
Related: https://quantumcomputing.stackexchange.com/questions/34396/aererror-unknown-instruction-c-unitary-while-using-control-unitary-operator/35132#35132

= Quantum circuit description language
{parent=Quantum software}

These are a bit like the <Verilog> of <quantum computing>.

One would hope that they are not <Turing complete>, this way they may serve as a way to pass on data in such a way that the receiver knows they will only be doing so much computation in advance to unpack the circuit. So it would be like <JSON> is for <JavaScript>.

= OpenQASM
{c}
{parent=Quantum software}
{wiki}

On <Qiskit> `qiskit==0.44.1`:
``
qc.qasm()
``

E.g. with our <qiskit/hello.py>{file}, we obtain the <Bell state circuit>:
``
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
``

= Quantum control system
{parent=Quantum software}

Some people call it "operating System".

The main parts of those systems are:
* sending multiple signals at very precise times to the system
* reading out some <quantum error correction> bits and sending error correcting signals back in a control loop

= Quantum control systems use FPGAs
{c}
{parent=Quantum control system}
{tag=FPGA}

It seems that all/almost all of them do. Quite cool.

\Video[https://www.youtube.com/watch?v=0262IFOdUV0]
{title=<FPGA> Architecture of the Quantum Control System by <Keysight> (2022)}
{description=They actually have a dedicated quantum team! Cool.}

\Video[https://www.youtube.com/watch?v=qjjuWSqEPQ8]
{title=<FPGA> based servo system by Atoms & Laser (2018)}
{description=The Indian lady is hardcore.}

= Organization developing quantum control systems
{parent=Quantum control system}
{tag=Organization developing quantum software}

= Organizations developing quantum control systems
{synonym}

https://github.com/m-labs/artiq

= M-Labs
{c}
{parent=Organization developing quantum control systems}
{tag=French company}

= ARTIQ
{c}
{parent=M-Labs}
{tag=Open source software}
{wiki}

= Duke ARTIQ extensions
{c}
{parent=ARTIQ}

https://gitlab.com/duke-artiq/dax

= Q-CTRL
{c}
{parent=Organization developing quantum control systems}
{tag=Australian company}

https://q-ctrl.com/

Someone attempted a <Wikipedia> page apparently: https://en.wikipedia.org/wiki/Q-CTRL[]. <Deletionism on Wikipedia>[Nice try, nice try].

= QuantrolOx
{c}
{parent=Organization developing quantum control systems}
{tag=University of Oxford spinout company}

https://q-ctrl.com/

= Riverlane
{c}
{parent=Organization developing quantum control systems}
{tag=British company}
{tag=University of Cambridge spinout company}
{title2=2017}

https://www.riverlane.com/

When you fail a HR interview, then you know you've reached rock bottom.

Investments:
* 2023-04: 15m GBP: https://www.uktech.news/deep-tech/riverlane-series-b-20230424 At 100 employeed on LinkedIn, this should keep them going for two more years.
* 2022 500k GBP: https://www.uktech.news/deep-tech/riverlane-rigetti-quantum-innovate-uk-20220628 by <Innovate UK> for joing project with <Rigetti Computing> to work on <quantum error correction>

\Video[https://www.youtube.com/watch?v=ugzWnw1LTBE]
{title=The Operating System for Quantum Computing by Steve Brierley (2021)}
{description=Founding CEO. He seems nice. You might as well just start watching at: https://youtu.be/ugzWnw1LTBE?t=1166[] where more specific things start to come out.}

= Deltaflow.OS
{c}
{parent=Riverlane}

A "quantum computer operating system". Or in English, control system + <quantum error correction>.

https://uknqt.ukri.org/wp-content/uploads/2021/10/UKNQTP-Strategic-Intent-2020.pdf page 24 mentions <UKNQTP> investment and gives an overview of some layers.

= Zurich Instruments
{c}
{parent=Organization developing quantum control systems}
{tag=French company}

https://www.zhinst.com/europe/en/quantum-computing-systems/qccs

= Classical computer
{parent=Quantum computing}

In the context of <quantum computing> of the 2020's, a "classical computer" is a <computer> that is not "quantum", i.e., the then dominating <CMOS> computers.

= ZX-calculus
{parent=Quantum computing}
{wiki}

As https://en.wikipedia.org/w/index.php?title=ZX-calculus&oldid=1071329204#Diagram_rewriting tries to explain <ourbigbook com/Wikipedia>[but fails to deliver as usual] consider the <GHZ state> represented as a quantum circuit.

How can we easily prove that that quantum circuit equals the state:
$$
\frac{|000> + |111>}{\sqrt{2}}
$$
?

The naive way would be to just do the matrix multiplication as explained at <quantum computing is just matrix multiplication>{full}.

However, ZX-calculus provides a simpler way.

And even more importantly, sometimes it is the only way, because in a real circuit, we would not be able to do the matrix multiplication 

What we do in ZX-calculus is we first transform the original quantum circuit into a ZX graph.

This is always possible, because we can describe how to do the conversion simply for any of the <Clifford plus T> gates, which is a set of <universal quantum gates>.

Then, after we do this transformation, we can start applying further transformations that simplify the circuit.

It has already been proven that there is no efficient algorithm for this (TODO source, someone said P-sharp complete best case)

But it has been proven in 2017 that any possible equivalence between quantum circuits can be reached by modifying ZX-calculus circuits.

There are only 7 transformation rules that we need, and all others can be derived from those, universality.

So, we can apply those rules to do https://en.wikipedia.org/w/index.php?title=ZX-calculus&oldid=1071329204#Diagram_rewriting[the transformation shown in Wikipedia]:

\Image[https://upload.wikimedia.org/wikipedia/commons/0/05/GHZ_circuit_as_ZX-diagram.svg]
{height=500}
{title=GHZ circuit as ZX-diagram}

and one of those rules finally tells us that that last graph means our desired state:
$$
\frac{|000> + |111>}{\sqrt{2}}
$$
because it is a Z spider with $m = 3$ and $n = 1$.

\Video[https://www.youtube.com/watch?v=JafI_LZts2g]
{title=Working with <PyZX> by Aleks Kissinger (2019)}
{description=This video appears to give amazing motivation on why you should care about <ZX-calculus>, it mentions
* <quantum compilation>
* <quantum computer simulation>
}

Bibliography:
* https://quantumcomputing.stackexchange.com/questions/9774/what-are-some-applications-of-the-zx-calculus

= ZX-calculus biliography
{c}
{parent=ZX-calculus}

= Picturing Quantum Processes
{parent=ZX-calculus biliography}
{title2=2017}

* https://www.amazon.co.uk/Picturing-Quantum-Processes-Diagrammatic-Reasoning/dp/110710422X
* https://www.cambridge.org/core/books/picturing-quantum-processes/1119568B3101F3A685BE832FEEC53E52
* <ISBN>-13: 978-1107104228

= PyZX
{c}
{parent=ZX-calculus}

https://github.com/Quantomatic/pyzx

= Quantum state
{parent=Quantum computing}
{wiki}

= Bell state
{c}
{parent=Quantum state}
{wiki}

One of the four following states:

$$
\begin{aligned}
\ket{\Phi^+} &= \frac{1}{\sqrt{2}} (\ket{00} &+ \ket{11})
\ket{\Phi^-} &= \frac{1}{\sqrt{2}} (\ket{00} &- \ket{11})
\ket{\Psi^+} &= \frac{1}{\sqrt{2}} (\ket{01} &+ \ket{10})
\ket{\Psi^-} &= \frac{1}{\sqrt{2}} (\ket{01} &- \ket{10})
\end{aligned}
$$

When unqualified as in "the Bell state", it generally just means $\ket{\Phi^+}$.

The Bell states are entangled and <non separable>. Intuitively, we can see that when we measure that state, the values of the first and second bit are strictly correlated. This is the hallmark of <quantum computation>: making up states where qubits are highly correlated to match a specific algorithmic answer, and opposed to uniformly random noise. For example, the <Bell state circuit> is a common <hello world>, e.g. it is used in the official <Qiskit hello world>.

= Bell circuit
{c}
{parent=Bell state}
{tag=Quantum circuit}

= Bell state circuit
{c}
{synonym}

A <quantum circuit> which when fed with input $\ket{00}$ produces the <Bell state>.

In <Qiskit> at: <qiskit/hello.py>{file}.

\Image[https://upload.wikimedia.org/wikipedia/commons/f/fc/The_Hadamard-CNOT_transform_on_the_zero-state.png]
{title=<Quantum circuit> that generates the <Bell state>}
{description=
The fundamental intuition for this circuit is as follows.

First the <Hadamard gate> makes the first <qubit> be in a 50/50 state.

Then, the <CNOT gate> gets controlled by that 50/50 value, and the controlled qubit also gets 50/50 chance as a result.

However, both qubits are now <entangled>: the result of the second qubit depends on the result of the first one. Because:
* if the first qubit is 0, cnot is not active, and so the second qubit remains 0 as its input
* if the first qubit is 1, cnot is active, and so the second qubit is flipped to 1
}

= Greenberger-Horne-Zeilinger state
{c}
{parent=Quantum state}
{wiki=Greenberger–Horne–Zeilinger_state}

= GHZ state
{c}
{synonym}

= Quantum supremacy
{parent=Quantum computing}
{title2=2019}
{wiki}

= Quantum advantage
{parent=Quantum supremacy}

Similar to <quantum supremacy>, but add the goal that the computation must be useful, i.e. make money or solve some open <mathematical> problem, <Ciro Santilli's wife> was quite excited about the possibility of finding some counter examples in <number theory> with quantum computers.

= Qubit
{parent=Quantum computing}
{wiki}

= Quantum computer benchmark
{parent=Quantum computing}
{wiki}

One important area of research and development of <quantum computing> is the development of benchmarks that allow us to compare different quantum computers to decide which one is more powerful than the other.

Ideally, we would like to be able to have a single number that predicts which computer is more powerful than the other for a wide range of algorithms.

However, much like in <CPU> benchmarking, this is a very complex problem, since different algorithms might perform differently in different architectures, making it very hard to sum up the architecture's capabilities to a single number as we would like.

The only thing that is directly comparable across computers is how two machines perform for a single algorithm, but we want a single number that is representative of many algorithms.

For example, the number of qubits would be a simple naive choice of such performance predictor number. But it is very imprecise, since other factors are also very important:
* qubit error rate
* <coherence time>, which determines the maximum circuit depth
* qubit connectivity. Can you only connect to 4 neighbouring qubits in a 2D plane? Or to every other qubit equally as well?

<Quantum volume> is another less naive attempt at such metric.

= Algorithmic qubits
{parent=Quantum computer benchmark}

Metric created by <IonQ>.

= Coherence time
{parent=Quantum computer benchmark}
{wiki}

It takes time for the quantum state to evolve. So in order to have a deep <quantum circuit>, we need longer <coherence times>.

= Depth of a quantum circuit
{parent=Quantum computer benchmark}
{wiki}

This is an important metric, because it takes some time for the quantum operations to propagate, and so the depth of a circuit gives you an idea of how long the <coherence time> a hardware needs to support a given circuit.

Bibliography:
* https://quantumcomputing.stackexchange.com/questions/14431/whats-meant-by-the-depth-of-a-quantum-circuit
* https://quantumcomputing.stackexchange.com/questions/5769/how-to-calculate-circuit-depth-properly

\Image[https://github.com/Qiskit/qiskit/blob/0.45.1/docs/source_images/depth.gif?raw=true]
{source=https://github.com/Qiskit/qiskit/blob/0.45.1/docs/source_images/depth.gif}

= Quantum volume
{parent=Quantum computer benchmark}
{wiki}

= Quantum computing market
{parent=Quantum computing}

= Quantum computing skepticism
{parent=Quantum computing market}

= Quantum computing skeptic
{synonym}

= Are we in a quantum computing bubble?
{parent=Quantum computing skepticism}

https://www.reddit.com/r/QuantumComputing/comments/lf1vp2/comment/ibuukcq/?utm_source=reddit&utm_medium=web2x&context=3

= Post-quantum cryptography
{parent=Quantum computing}
{tag=Cryptography}
{title2=PQC}
{wiki}

<Encryption algorithms> that run on <classical computers> that are expected to be resistant to <quantum computers>.

This is notably not the case of the dominant 2020 algorithms, <RSA (cryptosystem)> and <elliptic curve cryptography>, which are provably broken by <grover's algorithm>.

However, as of 2020, we <provably quantum secure encryption algorithm>[don't have any proof that any symmetric or public key algorithm is quantum resistant].

Post-quantum cryptography is the very first quantum computing thing at which people have to put money into.

The reason is that attackers would be able to store captured <ciphertext>, and then retroactively break them once and if <quantum computing> power becomes available in the future.

There isn't a shade of a doubt that <intelligence agencies> are actively doing this as of 2020. They must have a database of how interesting a given source is, and then store as much as they can given some ammount of storage budget they have available.

A good way to explain this to <quantum computing skeptics> is to ask them:
\Q[If I told you there is a 5% chance that I will be able to decrypt everything you write online starting today in 10 years. Would you give me a dollar to reduce that chance to 0.5%?]
Post-quantum cryptography is simply not a choice. It must be done now. Even if the risk is low, the cost would be way too great.

= Post-quantum cryptography company
{parent=Post-quantum cryptography}

= PQShield
{c}
{parent=Post-quantum cryptography company}
{tag=University of Oxford spinout company}
{title2=2018}
{wiki}

They seem to be doing hardware acceleration for <post-quantum cryptography> algorithm.

One has to feel bad for them as they likely threw out entire chip designs over <NIST Post-Quantum Cryptography Standardization> algorithm breakeges.

* 2024-06: \$37M https://techcrunch.com/2024/06/20/pqshield-secures-37m-more-for-quantum-resistant-cryptography/
* 2022-01: \$20M https://techcrunch.com/2022/01/25/pqshield-raises-20m-for-its-quantum-ready-future-proof-cryptographic-security-solutions/

= NIST Post-Quantum Cryptography Standardization
{c}
{parent=Post-quantum cryptography}
{title2=2017-}
{wiki}

This <post-quantum cryptography> competition by <NIST> is a huge milestone of the field.

It was mind blowing when in 2022, after several years of selection, one of the 7 finalists was broken on a <classical computer>, not even in a quantum computer! https://news.ycombinator.com/item?id=30466063 | https://eprint.iacr.org/2022/214 Breaking Rainbow Takes a Weekend on a Laptop by Ward Beullens. Dude announced he had a break a few days before submission: https://twitter.com/WardBeullens/status/1492780462028300290 On <Twitter>. He's so young. Epic.

Edit: and then, after the third round, things were a bit unclear, so they made a fourth round with 4 choices out of the 7 from round 3, and in August 2022 one of the four was broken again on a classic CPU!!! OMG: https://arstechnica.com/information-technology/2022/08/sike-once-a-post-quantum-encryption-contender-is-koed-in-nist-smackdown/

= Provably quantum secure encryption algorithm
{parent=Post-quantum cryptography}

None known as of 2020.

= Quantum resistant cryptosystem
{parent=Post-quantum cryptography}

= Quantum computing outreach
{parent=Quantum computing}

* https://qosf.org
* https://www.qubitbyqubit.org/
* https://www.qsium.com/
  \Q[Qsium is a student-led initiative that aims to democratise education in quantum computing. With the focus of raising 'quantum literacy' and creating a thriving quantum ecosystem through our Quantum Youth Network, we support <STEM> students in the <UK>. ]
* https://qworld.net

= Quantum computing scholarship
{parent=Quantum computing outreach}

* https://unitary.fund

= Quantum computing certification
{parent=Quantum computing}

* https://qworld.net/qsilver/

= Quantum computing bibliography
{parent=Quantum computing}

= Quantum computing news
{parent=Quantum computing bibliography}

= The Quantum Insider
{c}
{parent=Quantum computing news}
{title2=thequantuminsider.com}

https://thequantuminsider.com/

Good publication.

= Quantum computing book
{parent=Quantum computing bibliography}

= Quantum Computation and Quantum Information by Nielsen and Chuang
{parent=Quantum computing book}

https://www.amazon.com/dp/1107002176

= Quantum computing university course
{parent=Quantum computing bibliography}