17
It's just a coincidence.
I can speak from personal recollection on the Google side. Google originally intended to use a 72 qubit chip (Bristlecone) where qubits were essentially directly connected to each other. They then switched to an architecture where qubits were connected indirectly via a coupler. The coupler requires a control line, so this increased ...
9
They have different error rates because they are two different physical devices! This relates to the manufacturing processes of these chips. Every device is unique and will have its own fingerprint meaning its own error rate. Of course this is not something that manufactures do on purpose, but a side effect of making these qubit devices. It’s very difficult ...
9
Any compilation/circuit optimization happens transparently by Qiskit. As a user you have control over what happens via the optimization_level argument passed to transpile(). Setting optimization level high (e.g. level 3) will do more circuit optimizations and setting it low will do little or no optimization (e.g. level 0). The two examples that you provide ...
9
The graph shows you how the physical qubits are connected together on the real device you will be using. For example, on the graph you put, qubit 0 has a physical connection to qubit 1 and qubit 14 on the quantum device but is not connected to qubit 12.
This graph is really important when Qiskit tries to map a circuit to the quantum device because it shows ...
9
A quick and dirty list:
$T_{1}$ and $T_{2}$ - colloquially known as decoherence times, but slightly more precisely also as the (qubit) relaxation time ($T_{1}$) and the (qubit) dephasing time ($T_{2}$).
$T_{1}$ is a measure of how quickly a qubit in the excited ($|1\rangle$) state spontaneously relaxes to the ground ($|0\rangle$) state.
$T_{2}$ is slightly ...
8
In the classical case, there is a pretty big difference between digital computers and analogue ones. The methodology and hardware is very much distinct (in all cases I know of, at least).
The divide is still there in the quantum case, but it doesn't run quite as deep. The hardware can be similar, but requirements on how it behaves and how to manipulate it ...
7
Starting with the state $|\psi_0 \rangle = |0\rangle$, and we want to get to the state $|\psi_f \rangle = \dfrac{|0\rangle + i|1\rangle}{\sqrt{2}}$ then we must realize that we need to create some sort of a superposition between the state $|0\rangle$ and the state $|1\rangle$. This is where the Hadamard gate will come into play. The Hadamard gate which ...
6
From the public data given by IBM about IBM Q16 Melbourne (14 qubits available):
Mean gate error: $2.14 \times 10^{-3}$ (probably higher for CX and lower for 1-qubit gates, but this information seems to be no longer available).
Mean measure error: $2.68\times 10^{-2}$.
If your circuit contains $300$ gates then the probability that at least one gate fails ...
6
It depends on what you mean by "able to handle". You mention a circuit depth of 99, which might be possible, but what will be the fidelity of the final state with respect to the one it's supposed to be (assuming no decoherence)?
If your fidelity requirement is close to 100%, the maximum circuit depth that the IBM machines can handle, is zero (try just ...
6
Besides number of qubits, the devices can have other differences as well. The architecture of the device can be different, meaning that each device could have different connectivity maps. This would affect the mapping of valid multiqubit gates.
They also can have different error rates at any given time. Calibrations are run on each device daily. These error ...
6
To add onto Lena answer.
The plot topology graph of the device represents the qubit layout of the hardware. The qubits on IBM hardware are fixed. They don't move around as trapped-ion qubits built by Honeywell system. Hence, IBM hardware doesn't have what you would call all-to-all connectivity between qubits. Note that IBM uses superconducting transmon qubit ...
6
Just adding some stuff to the already good answer :
The gate time actually is related to the connexion between qubits, so is related to the CNOT, not the single-qubit gates.
The frequency is defined as the difference in energy between the ground and excited states, i.e. the |0⟩ and |1⟩ states, respectively.
for more info about how to measure all this (T1, ...
5
Basically being IBM Q Network member give you the possibility to access IBM’s most-powerful quantum computing systems through the cloud (currently 20Q, 27Q, 28Q, 53Q devices with Quantum Volume between 8 and 32 depending the device). Some of the premium devices are visible in this post: https://www.ibm.com/blogs/research/2020/07/qv32-performance/
Depending ...
5
First of all, the name of backends (devices) have nothing to do with their location! They are all located in US.
Back to your question, as others already mentioned the difference is in the architecture (topology), number of qubits, connectivity, and performance (influenced by various types of errors).
If you click the name of any backend (device) in your ...
5
A Hadamard gate isn't usually a physical object that you pass qubits through. In the case of superconducting qubits, the Hadamard gate is performed by bouncing microwaves off of the qubits. It doesn't look like anything.
So you're not going to find a picture of a superconducting Hadamard gate on a chip. The closest thing to that would be one of the blips in ...
4
The choice of gates is entirely dependent on the types of interactions that occur in the different architectures. The cross resonance gate used by IBM generates the ZX interaction you want (plus other stuff) that leads to a CNOT. Trapped ions have XX type interactions that give rise to Molmer Sorensen gates. For single qubit gates it depends on what driving ...
4
I am going to try to give guesses that can make sense:
More qubits does not mean better machines. They may be less noise-tolerant and with less connectivity between qubits. That is why, when you benchmark them (with or without error-correction), you look first at the simplest implementations of state of art algorithms. Plus, you may change some calibrations ...
4
When referring to the commercial quantum computers of both parties, it is that both are based on a different quantum principles.
The D-Wave machine works via quantum annealing and is suited for optimization problems. The machine by IBM is a gate-based quantum computer, similar to how digital computers work at the elementary level.
As the two quantum ...
4
IBMQ.load_accounts() was deprecated and removed in Qiskit 0.14. Please use IBMQ.load_account().
4
You can also create a Statevector, that can be directly initialized as follows:
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('11')
You can use sv.evolve(qc) to apply an operator/circuit to the state, where qc is the operator/circuit. sv.data gives you the numpy array, containing the actual implementation of the state.
Check this ...
4
qiskit-terra 0.16 or lower
As answered, probably the most canonical way to do this is with Statevector.from_label and initialize.
Here is the full example:
from qiskit import *
from qiskit.quantum_info import Statevector
n = 2
qc = QuantumCircuit(n)
qc.initialize(Statevector.from_label('1'*n).data, range(n))
qc.draw()
┌──────────────────────┐
q_0: ┤0 ...
4
Fundamentally, a device such as an IBM quantum computer interacts according to a Hamiltonian, which might have some time-varying parameters. For example, for a single qubit, it might look like:
$$
H=BZ+\Omega(t)X,
$$
where $X$ and $Z$ are the standard Pauli matrices, and $B$ is a constant.
The goal is "simply" to specify the function $\Omega(t)$ to ...
4
Yes. IBM uses superconducting Transmon qubit. Here is a quote from IBM's website:
At the heart of IBM quantum systems is the transmon qubit. Successive generations of IBM Quantum processors have demonstrated the potential of superconducting transmon qubits as the basis for electrically controlled solid-state quantum computers. With a scalable approach to ...
4
The first thing that comes to my mind with your problem is the fake devices available in Qiskit. Here is how to use it, the main idea is that Qiskit stored device properties in Terra and with it, you create simulators that will mimic exactly what the devices would do.
Basically, you can call them the same way you would a real device in qiskit.test.mock, for ...
4
This was due to temporary issue on IBM side. If you try to resubmit your job it should work as before.
4
There will be a lot of swapping and additional gates during the execution of your circuit since CCX is not a native gate. The actual circuit that is being executed is something like:
This circuit has 11 qubits and depth of 79 and close to 100 CNOT gates, this is way too much for current hardware. Below is the noise level for Melbourne.
4
The number of qubits is part of the backend configuration:
FakeManhattan().configuration().n_qubits
65
If you need to filter the list of mocked backends based on the amount of qubits:
from qiskit.test.mock import FakeProvider
provider = FakeProvider()
[ b.name() for b in provider.backends() if b.configuration().n_qubits > 20]
['fake_cambridge',
'...
4
Great observation!
The devices are calibrated daily(ish) and sometimes a bad calibration requires a "rerun". The value 1 is some sort of flag that something went wrong with the calibration.
Noise-aware transpilation algorithms will try to avoid that gate as will be presented as particularly noisy.
Thanks @paul-nation for the help answering this ...
4
The only API documentation available is the one you linked to. Its documentation page describes the steps needed to submit a job (although not in great details). However, you'll first need to convert your QASM string to a qObject, which is the format the API accepts. Assuming Qiskit is allowed for this part, you can first use QuantumCircuit.from_qasm_str() ...
3
Well actually when looking at the source code, the construct_circuit method:
quantum register where the sequential QFT is performed
self._up_qreg = QuantumRegister(2 * self._n, name='up')
# quantum register where the multiplications are made
self._down_qreg = QuantumRegister(self._n, name='down')
# auxiliary quantum register used in ...
Only top voted, non community-wiki answers of a minimum length are eligible
