feat: Release pages from the old Notion doc

docs/about_api_providers/about_the_provider.md

@@ -0,0 +1,5 @@
+# About the Qiskit provider
+
+Alice & Bob’s Qiskit provider is an open-source project which can be accessed via the following link:
+
+[https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider](https://github.com/Alice-Bob-SW/qiskit-alice-bob-provider)

docs/about_api_providers/changelog.md

@@ -0,0 +1,36 @@
+# Changelog
+## Version 0.5.4
+
+- Add support for the TDG gate for the logical backends of the remote provider (the TDG gate was already supported on the local provider)
+
+## Version 0.5.3
+
+- Fix a transpilation issue that prevented the usage of logical backends with the remote provider.
+
+## Version 0.5.2
+
+- Fix a transpilation issue for the logical backends, preventing the transpilation of circuits using a cswap gate.
+
+## Version 0.5.1
+
+- Improved transpilation and scheduling for the local backends, to better support programs imported from QASM code.
+
+## Version 0.5.0
+
+- Harmonized the `get_backend` functions of the remote and local provider to act in a similar manner. The following line is now working as it does for local:
+
+```python
+remote_provider.get_backend('EMU:6Q:PHYSICAL_CATS', average_nb_photons=4.5, kappa_1=1000)
+```
+
+## Version 0.4.2
+
+- Released multi-qubits logical and physical targets for the remote provider, allowing to run these models remotely.
+
+## Version 0.4.1
+
+- Added support for Python 3.11
+
+## Version 0.4.0
+
+- Added logical backends: `EMU:15Q:LOGICAL_EARLY` and `EMU:40Q:LOGICAL_TARGET`

docs/about_api_providers/the_api.md

@@ -0,0 +1,21 @@
+# The API
+
+If you want to integrate Felis with other tools, you may need to interact directly with our API.
+
+It can be accessed at [https://api.alice-bob.com/v1/](https://api.alice-bob.com/v1/).
+
+Here’s an example listing all jobs, pending or completed:
+
+```python
+curl --request GET \
+  --url https://api.alice-bob.com//v1/jobs/ \
+  --header 'Authorization: Basic <API key>'
+```
+
+Note the use of an API key: this is the same API key as the one used with the Qiskit provider `AliceBobRemoteProvider(api_key=<API key>)`. That’s because the Qiskit provider interacts with the API.
+
+Use the same API key with the API as with the Qiskit provider `AliceBobRemoteProvider`. That’s because the provider itself is backed by the API. For more information, see [Install the Qiskit provider](../getting_started/install_the_qiskit_provider.md).
+
+The up-to-date API reference can be accessed here: 
+
+[Alice & Bob - Cloud API - ReDoc](https://api.alice-bob.com/reference)

docs/about_api_providers/the_local_provider.md

@@ -0,0 +1,36 @@
+# The local Qiskit provider
+
+By default, the main Alice & Bob Qiskit provider `AliceBobRemoteProvider` runs all circuits remotely, on Alice & Bob classical or quantum computers.
+
+If you would rather emulate your circuit locally, you need to instantiate the local Qiskit provider `AliceBobLocalProvider` instead of the remote one:
+
+```python
+from qiskit_alice_bob_provider import AliceBobLocalProvider
+from qiskit import QuantumCircuit, execute, transpile
+
+provider = AliceBobLocalProvider()
+
+circ = QuantumCircuit(2, 2)
+circ.initialize('0+')
+circ.cx(0, 1)
+circ.measure(0, 0)
+circ.measure(1, 1)
+
+print(circ.draw())
+
+# Default 6-qubit QPU with the ratio of memory dissipation rates set to
+# k1/k2=1e-5 and cat size average_nb_photons set to 16.
+backend = provider.get_backend('EMU:6Q:PHYSICAL_CATS')
+
+print(transpile(circ, backend).draw())
+
+print(execute(circ, backend, shots=100000).result().get_counts())
+# {'11': 49823, '00': 50177}
+
+# Changing the cat size from 16 (default) to 4 and k1/k2 to 1e-2.
+backend = provider.get_backend('EMU:6Q:PHYSICAL_CATS', average_nb_photons=4, kappa_2=1e4)
+print(execute(circ, backend, shots=100000).result().get_counts())
+# {'01': 557, '11': 49422, '10': 596, '00': 49425}
+```
+
+As can be seen in the example above, the main difference with the remote provider `AliceBobRemoteProvider` is that the settings (like `average_nb_photons` or `kappa_2`) must be configured in `get_backend(...)` instead of `execute(...)`. Learn more in [Chip settings](../going_further/supported_instructions.md).

docs/contact_us.md

@@ -0,0 +1,8 @@
+# Contact us
+
+Need help? Have feedback?
+
+- Join [The Cat Tree](https://join.slack.com/t/the-cat-tree/shared_invite/zt-2cg0a3rno-PP~AaUztS3dtiRyzsawlnQ), our Slack community
+- Contact Laurent Prost at [email protected]
+
+We’ll be happy to know what you think, and we also take positive feedback! 🙂

docs/getting_started/a_first_example.md

@@ -0,0 +1,75 @@
+# Running Qiskit programs: a first example
+
+Here’s a very simple Qiskit program which lets you witness the biased noise of our cat qubits.
+
+- ☝ If you’re not familiar with Qiskit, here’s a [short introduction](https://qiskit.org/documentation/intro_tutorial1.html).
+
+- If you’re not familiar with cat qubits, you may want to read [Working with cat qubits: similarities & differences](working_with_cat_qubits.md) first.
+
+
+
+You may paste the following code in a Python script or a Jupyter notebook.
+
+First, we set up the provider and import dependencies:
+
+```python
+from qiskit import QuantumCircuit, execute
+from qiskit.visualization import plot_histogram
+from qiskit_alice_bob_provider import AliceBobRemoteProvider
+
+# Replace the placeholder with your actual API key in the line below
+# If you do not have an API key, read about the local provider
+ab = AliceBobRemoteProvider(api_key='YOUR_API_KEY')
+```
+
+If you do not have an API key, read about the [the local Qiskit provider](../about_api_providers/the_local_provider.md) which can emulate circuits on your own computer.
+
+We will then pick a backend to use:
+
+```python
+print(ab.backends())
+backend = ab.get_backend('EMU:1Q:LESCANNE_2020')
+```
+
+Then, we design and execute a simple circuit sensitive to bit-flips (Prepare |0> / Wait / Measure on the Z axis), whose result would always be 0 in a noiseless environment:
+
+```python
+# Measure bit-flip errors after 1µs
+c1 = QuantumCircuit(1, 1)
+c1.delay(1, unit='us')
+c1.measure(0, 0)
+job1 = execute(c1, backend, shots=1000, average_nb_photons=3)
+res1 = job1.result()
+plot_histogram(res1.get_counts())
+```
+
+Then, we replicate the same idea to design and execute a circuit sensitive to phase-flips (Prepare |+> / Wait / Measure on the X axis), whose result should also always be 0 in a noiseless environment:
+
+```python
+# Measure phase-flip errors after 1 µs
+c2 = QuantumCircuit(1, 1)
+c2.initialize('+', 0)
+c2.delay(1, unit='us')
+c2.measure_x(0, 0)
+job2 = execute(c2, backend, shots=1000, average_nb_photons=3)
+res2 = job2.result()
+plot_histogram(res2.get_counts())
+```
+
+The second circuit should show far more errors than the first, showing our qubits do have a noise bias: they are strongly protected against bit-flip errors.
+
+Come and show us your results!
+
+## Going further
+
+Now that you understand how things work, you can start having fun.
+
+Here are some ideas of experiments you can run:
+
+- Showcase exponential suppression of bit flips by varying `average_nb_photons`
+    - ℹ️ Varying `average_nb_photons` works differently in the local and in the remote provider. The example in this page works for the remote provider, see [The local Qiskit provider](../about_api_providers/the_local_provider.md) to learn how to adapt your code for the local provider.
+- Showcase linear increase of the phase flip rate by varying `average_nb_photons`
+- Measure the bit flip time
+- Measure the phase flip time
+
+In order to implement these ideas, have a look at the list of [Supported instructions](../going_further/supported_instructions.md).

docs/getting_started/hardware_availability_schedule.md

@@ -0,0 +1,15 @@
+# Hardware availability schedule
+
+All emulators in the remote provider are expected to be available 24/7.
+
+Real chips, when they first launch, will only be available during predetermined time slots.
+
+Likely several hours a day, several days a week, but probably not at night (Paris time) or during weekends.
+
+This will let us monitor how the chips behave and react in real time to any issues that might arise.
+
+If things go smoothly, our goal is to move towards 24/7 availability as soon as possible.
+
+We expect there will always be scheduled down times for maintenance though, but we will work to keep them as short as possible.
+
+We will update this page with a more detailed schedule when the first chip launches.

docs/getting_started/install_the_qiskit_provider.md

@@ -0,0 +1,65 @@
+# Install the Qiskit provider
+
+## Installation instructions
+
+⚠️ No installation is required if you use Felis through OVH’s AI Notebooks. Get started [here](https://www.ovhcloud.com/en/public-cloud/ai-notebooks/).
+
+Instructions below let you install Felis on your computer as an open source library.
+
+## 0. Set up your environment
+
+Qiskit is a Python framework, requiring Python 3.7 or later according to the [Qiskit documentation](https://qiskit.org/documentation/getting_started.html).
+
+We assume you know how to install Python and set up an environment.
+
+If you don’t, you can [go through the Python docs](https://www.python.org/about/gettingstarted/), or simply [reach out](../contact_us.md). We’ll be happy to help.
+
+## 1. Get an API key
+
+An API key is mandatory if you want to run circuits on real hardware.
+
+Emulation can be run locally with no API key, but speed and max number of qubits will depend on the specs of your machine.
+
+If you are part of our hardware beta program, you should have received an API key from us in your welcome email.
+
+If you haven’t, or if you have lost your key, please [let us know](../contact_us.md).
+
+## 2. Install the Alice & Bob Qiskit provider
+
+```bash
+pip install --upgrade qiskit-alice-bob-provider
+```
+
+Note: no need to install Qiskit separately, it will be installed automatically if it is not already installed.
+
+
+⚠️ We are currently incompatible with the latest version of Qiskit (0.45) because of the breaking changes it introduces. We are currently reviewing the impact of these changes and will update this page when we are done.
+
+In the mean time, you’ll need to run the provider in an environment using an earlier version of Qiskit.
+
+
+
+## 3. Write your first Qiskit program
+
+To use the Alice & Bob Qiskit provider in a Qiskit program, you need to instantiate it and retrieve a backend.
+
+```python
+from qiskit_alice_bob_provider import AliceBobRemoteProvider
+
+# Replace the placeholder with your actual API key in the line below
+ab = AliceBobRemoteProvider(api_key='YOUR_API_KEY')
+
+print(ab.backends())
+backend = ab.get_backend('EMU:1Q:LESCANNE_2020')
+```
+
+You may then use this backend to execute Qiskit circuits.
+
+Don’t forget to add your API key in the sample code above!
+
+For a complete example, please read [A first example](a_first_example.md) 
+
+
+💡 Note: our examples all use `AliceBobRemoteProvider`, which runs the circuits on Alice & Bob machines, but you may also use `AliceBobLocalProvider`, which is limited to emulators and runs on your own machine.
+Read more about this provider at [The local Qiskit provider](../about_api_providers/the_local_provider.md).
+

docs/getting_started/working_with_cat_qubits.md

@@ -0,0 +1,71 @@
+# Working with cat qubits: similarities & differences
+
+In this page, we will assume that you are familiar with transmon qubits like the ones found in IBM systems, and that you have already run circuits using Qiskit.
+
+# TL;DR
+
+## What stays the same:
+
+- You design and run quantum circuits made out of gates and qubits using Qiskit
+- You can use most if not all of the gates you are used to (at least in logical mode, see below)
+
+## What is different:
+
+- There are two modes: physical and logical
+    - The physical mode mimicks the behavior of physical qubits and features a limited set of gates. Error correction, logical qubits, and logical gates are implemented on top of physical qubits. In this mode:
+        - Qubits feature a biased noise (fewer bit-flip errors, more phase-flip errors compared to a regular transmon)
+        - You can only use a limited set of gates (so-called “bias-preserving” gates)
+        - Additional native operations are available (prepare |+> or |->, measure along the X axis)
+        - The chip can be tuned to use a different tradeoff between bit-flip and phase-flip errors
+    - The logical mode mimicks the behavior of logical qubits (error-corrected abstract qubits made of several physical qubits). The logical mode features a universal set of gates and is used to run algorithms. In this mode:
+        - You can use virtually any gate
+        - You get all-to-all connectivity and a very low error rate
+        - The noise bias is reduced if not completely eliminated
+
+# What is a cat qubit? What is it good for?
+
+![cat_qubits_presentation](../media/getting_started/working_with_cat_qubits/cat_qubit_presentation.png)
+
+Cat qubits are superconducting qubits which are particularly well-suited to implementing error correction, since they can advantageously trade bit-flip errors for phase-flip errors.
+
+When tuning a specific parameter (the average number of the photons in the cat qubit), the frequency of bit-flip errors decreases exponentially, while the frequency of phase-flip errors increases only linearly.
+
+This “biased noise” makes it possible to virtually eliminate bit-flip errors, while keeping phase-flip errors below the error correction threshold.
+
+This in turn enables much simpler error correction schemes: because there’s virtually only one type of error to correct, you can use a simple repetition code, instead of a surface code that requires far more qubits.
+
+Several physical qubits running a repetition code can then become a “logical qubit”, featuring a much lower error rate than any of the physical qubits it is made of.
+
+Using cat qubits, we estimate we can build a fault-tolerant quantum computer [requiring 60 fewer qubits](https://arxiv.org/abs/2302.06639) than if we were using transmons.
+
+To learn more about the physics of cat qubits, you can read our seminal paper at [https://www.nature.com/articles/s41567-020-0824-x](https://www.nature.com/articles/s41567-020-0824-x) or [https://arxiv.org/abs/1907.11729](https://arxiv.org/abs/1907.11729).
+
+# Logical mode and physical mode
+
+Since the purpose of cat qubits is to create logical qubits with a very low error rate, a processor based on cat qubits can run in two modes: physical and logical.
+
+### Physical mode
+
+In the physical mode, you’re working directly with cat qubits: one qubit in your quantum circuit corresponds to one physical cat qubit on the chip.
+
+This enables you to leverage the biased noise of cat qubits for your error correction experiments, but only lets you use a limited set of gates (see [Supported instructions](../going_further/supported_instructions.md) for more details).
+
+Indeed, when using cat qubits in physical mode, it only makes sense to use so-called “bias-preserving” gates, which do no leak information from the noisy phase channel to the clean bit channel.
+
+This means that gates such as the Hadamard gate are forbidden, since they do contaminate the bit channel with phase errors.
+
+In physical mode, you’ll also need to take the chip’s connectivity into account, since cat qubits are usually only connected with their nearest neighbor. Although Qiskit’s transpiler can do this job for you, transpilation may push the qubit number beyond the limits of what the emulator or the chip can do.
+
+You’ll use the physical mode if you want to study the **properties of cat qubits**, implement **error correction** or create your own **logical qubit**.
+
+### Logical mode
+
+In the logical mode, you’re working with error-corrected logical qubits: one qubit in your quantum circuit corresponds to a group of several physical qubits on the chip.
+
+This mode is more abstract that the physical mode, since all the error correction operations leveraging several physical qubits are hidden in the compilation step.
+
+But **the logical mode is the perfect choice to run quantum algorithms**: you can execute any quantum gate, you get low error rates and all-to-all connectivity.
+
+Also, the logical mode does not feature a noise bias as strong as in physical mode. The exact bias depends on the tuning of the chip (distance of the code, number of photons), but a good tuning can make bit-flip and phase-flip errors equally (un)likely.
+
+The logical mode is only possible with chips featuring enough physical cat qubits to run an effective error correction code. We estimate this minimal number to be somewhere between 5 (for a first demonstration of a single logical qubit) and 40 (for very high fidelities or multi-qubit logical operations).

docs/going_further/about_error_models.md

@@ -0,0 +1,19 @@
+# About error models in emulators
+
+Our emulators try to replicate as accurately as possible the behavior of past and current Alice & Bob chips. They also try to forecast what the behavior of future Alice & Bob chips might look like.
+
+Since these emulators are open sourced, you are free to explore the mathematical models we used, but we also want to explain how we came up with these models.
+
+This page, which we will update shortly, will give a detailed explanation for each of our backends.
+
+## Lescanne 2020
+
+To be added
+
+## Physical cats
+
+To be added
+
+## Logical qubits
+
+To be added