Docs reviews

docs/advanced_tutorials/custom-models.md

@@ -46,7 +46,7 @@ class CustomQuantumModel(QuantumModel):
 The custom model can be used like any other `QuantumModel`:
 ```python exec="on" source="material-block" result="json" session="custom-model"
 from qadence import Parameter, RX, CNOT, QuantumCircuit
-from qadence import chain, kron, total_magnetization
+from qadence import chain, kron, hamiltonian_factory, Z
 from sympy import acos
 
 def quantum_circuit(n_qubits):
@@ -64,7 +64,7 @@ def quantum_circuit(n_qubits):
 n_qubits = 4
 batch_size = 10
 circuit = quantum_circuit(n_qubits)
-observable = total_magnetization(n_qubits)
+observable = hamiltonian_factory(n_qubits, detuning = Z)  # Total magnetization
 
 model = CustomQuantumModel(circuit, observable, backend="pyqtorch")
 

docs/advanced_tutorials/differentiability.md

@@ -66,7 +66,7 @@ In Qadence, the GPSR differentiation engine can be selected by passing `diff_mod
 
 ```python exec="on" source="material-block" session="differentiability"
 from qadence import (FeatureParameter, HamEvo, X, I, Z,
-                    total_magnetization, QuantumCircuit,
+                    hamiltonian_factory, QuantumCircuit,
                     QuantumModel, BackendName, DiffMode)
 import torch
 
@@ -83,7 +83,7 @@ block = HamEvo(generator, x)
 circuit = QuantumCircuit(n_qubits, block)
 
 # create total magnetization cost operator
-obs = total_magnetization(n_qubits)
+obs = hamiltonian_factory(n_qubits, detuning = Z)
 
 # create models with AD and GPSR differentiation engines
 model_ad = QuantumModel(circuit, obs,

docs/digital_analog_qc/pulser-basic.md

@@ -1,3 +1,7 @@
+!!! warning
+    This tutorial needs to be fixed.
+
+
 Qadence offers a direct interface with Pulser[^1], an open-source pulse-level interface written in Python and specifically designed for programming neutral atom quantum computers.
 
 Using directly Pulser requires deep knowledge on pulse-level programming and on how neutral atom devices work. Qadence abstracts out this complexity by using the familiar block-based interface for building pulse sequences in Pulser while leaving the possibility
@@ -54,7 +58,7 @@ bell_state = chain(
 To convert the chain block into a pulse sequence, we define a `Register` with two qubits and combine it to create a circuit as usual. Then we construct a `QuantumModel` with a Pulser backend to convert it into a proper parametrized pulse sequence. Supplying the
 parameter values allows to sample from the pulse sequence result.
 
-```python exec="on" source="material-block" session="pulser-basic"
+```python exec="on" source="material-block" "html=1" session="pulser-basic"
 import torch
 import matplotlib.pyplot as plt
 from qadence import Register, QuantumCircuit, QuantumModel
@@ -96,7 +100,10 @@ At variance with other backends, the Pulser one provides the concept of `Device`
 
 A `Device` instance encapsulate all the properties defining a real neutral atoms processor, including but not limited to the maximum laser amplitude for the pulses, the maximum distance between two qubits and the maximum duration of the pulse.
 
-`qadence` offers a simplified interface with only two devices which can be found [here][qadence.backends.pulser.devices]
+!!! warning
+    Fix link below.
+
+`qadence` offers a simplified interface with only two devices which can be found [here](/backends.pulser.devices)
 
 * `IDEALIZED` (default): ideal device which should be used only for testing purposes. It does not have any limitation in what can be run with it.
 * `REALISTIC`: device specification very similar to a real neutral atom quantum processor.
@@ -121,16 +128,17 @@ model = QuantumModel(
     configuration={"device_type": Device.REALISTIC}
 )
 
-# alternatively directly one of the devices available in Pulser
-# can also be supplied in the same way
-from pulser.devices import AnalogDevice
-
-model = QuantumModel(
-    circuit,
-    backend="pulser",
-    diff_mode="gpsr",
-    configuration={"device_type": AnalogDevice}
-)
+# FIXME: Specified device is not supported.
+# # alternatively directly one of the devices available in Pulser
+# # can also be supplied in the same way
+# from pulser.devices import AnalogDevice
+
+# model = QuantumModel(
+#     circuit,
+#     backend="pulser",
+#     diff_mode="gpsr",
+#     configuration={"device_type": AnalogDevice}
+# )
 ```
 
 ## Create your own gate
@@ -156,32 +164,33 @@ obs = [zz, xy + yx]
 
 Now we define the `QuantumModel` and pass the observable list to it together with the constructed circuit.
 
-```python exec="on" source="material-block" result="json" session="pulser-basic"
-from qadence import RX, AnalogRot
+```python exec="on" source="material-block" html="1" session="pulser-basic"
+# FIXME: protocol not defined
+# from qadence import RX, AnalogRot
 
-register = Register(2)
-circuit = QuantumCircuit(register, protocol)
-model = QuantumModel(circuit, backend="pulser", diff_mode='gpsr')
+# register = Register(2)
+# circuit = QuantumCircuit(register, protocol)
+# model = QuantumModel(circuit, backend="pulser", diff_mode='gpsr')
 
-params = {
-    "t": torch.tensor([383]),  # ns
-    "y": torch.tensor([torch.pi / 2]),
-}
+# params = {
+#     "t": torch.tensor([383]),  # ns
+#     "y": torch.tensor([torch.pi / 2]),
+# }
 
-sample = model.sample(params, n_shots=50)[0]
+# sample = model.sample(params, n_shots=50)[0]
 
-fig, ax = plt.subplots()
-plt.bar(sample.keys(), sample.values())
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(fig)) # markdown-exec: hide
+# fig, ax = plt.subplots()
+# plt.bar(sample.keys(), sample.values())
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(fig)) # markdown-exec: hide
 ```
 
 One can also easily access and manipulate the underlying pulse sequence.
 
 ```python exec="on" source="material-block" html="1" session="pulser-basic"
-model.assign_parameters(params).draw(draw_phase_area=True, show=False)
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
+# model.assign_parameters(params).draw(draw_phase_area=True, show=False)
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
 ```
 
 ## Large qubits registers
@@ -191,48 +200,50 @@ with two or three qubits. But for the blocks we have so far, large registers
 work better with a square loop layout like the following.
 
 ```python exec="on" source="material-block" html="1" session="pulser-basic"
-register = Register.square(qubits_side=4)
-register.draw(show=False)
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
+# register = Register.square(qubits_side=4)
+# register.draw(show=False)
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
 ```
 
 In those cases, global pulses are preferred to generate entanglement to avoid
 changing the addressing pattern on the fly.
 
 ```python exec="on" source="material-block" html="1" session="pulser-basic"
-protocol = chain(
-    entangle("t"),
-    AnalogRY(torch.pi / 2),
-)
+# from qadence import AnalogRY
 
-register = Register.square(qubits_side=2)
-circuit = QuantumCircuit(register, protocol)
-model = QuantumModel(circuit, backend="pulser", diff_mode="gpsr")
+# protocol = chain(
+#     entangle("t"),
+#     AnalogRY(torch.pi / 2),
+# )
 
-# add modulation to the pulse sequence by modifying the
-# backend configuration
-model.backend.backend.config.with_modulation = True
+# register = Register.square(qubits_side=2)
+# circuit = QuantumCircuit(register, protocol)
+# model = QuantumModel(circuit, backend="pulser", diff_mode="gpsr")
 
-params = {
-    "x": torch.tensor([3*torch.pi/2]),  # ns
-}
+# # add modulation to the pulse sequence by modifying the
+# # backend configuration
+# model.backend.backend.config.with_modulation = True
 
-sample = model.sample(params, n_shots=500)[0]
+# params = {
+#     "x": torch.tensor([3*torch.pi/2]),  # ns
+# }
 
-fig, ax = plt.subplots()
-ax.bar(sample.keys(), sample.values())
-plt.xticks(rotation='vertical')
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(fig)) # markdown-exec: hide
+# sample = model.sample(params, n_shots=500)[0]
+
+# fig, ax = plt.subplots()
+# ax.bar(sample.keys(), sample.values())
+# plt.xticks(rotation='vertical')
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(fig)) # markdown-exec: hide
 ```
 
 Again, let's plot the corresponding pulse sequence.
 
 ```python exec="on" source="material-block" html="1" session="pulser-basic"
-model.assign_parameters(params).draw(draw_phase_area=True, show=False)
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
+# model.assign_parameters(params).draw(draw_phase_area=True, show=False)
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
 ```
 
 !!! note
@@ -247,40 +258,40 @@ version of a quantum neural network circuit with feature map and variational
 ansatz.
 
 ```python exec="on" source="material-block" html="1" session="pulser-basic"
-from qadence import kron, fourier_feature_map
-from qadence.operations import RX, RY, AnalogRX
-
-hea_one_layer = chain(
-    kron(RY(0, "th00"), RY(1, "th01")),
-    kron(RX(0, "th10"), RX(1, "th11")),
-    kron(RY(0, "th20"), RY(1, "th21")),
-    entangle("t", qubit_support=(0,1)),
-)
-
-protocol = chain(
-    fourier_feature_map(1, param="x"),
-    hea_one_layer,
-    AnalogRX(torch.pi/4)
-)
-
-register = Register(2)
-circuit = QuantumCircuit(register, protocol)
-model = QuantumModel(circuit, backend="pulser", diff_mode="gpsr")
-
-params = {
-    "x": torch.tensor([0.8]), # rad
-    "t": torch.tensor([900]), # ns
-    "th00":  torch.rand(1), # rad
-    "th01":  torch.rand(1), # rad
-    "th10":  torch.rand(1), # rad
-    "th11":  torch.rand(1), # rad
-    "th20":  torch.rand(1), # rad
-    "th21":  torch.rand(1), # rad
-}
-
-model.assign_parameters(params).draw(draw_phase_area=True, show=True)
-from docs import docsutils # markdown-exec: hide
-print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
+# from qadence import kron, fourier_feature_map
+# from qadence.operations import RX, RY, AnalogRX
+
+# hea_one_layer = chain(
+#     kron(RY(0, "th00"), RY(1, "th01")),
+#     kron(RX(0, "th10"), RX(1, "th11")),
+#     kron(RY(0, "th20"), RY(1, "th21")),
+#     entangle("t", qubit_support=(0,1)),
+# )
+
+# protocol = chain(
+#     fourier_feature_map(1, param="x"),
+#     hea_one_layer,
+#     AnalogRX(torch.pi/4)
+# )
+
+# register = Register(2)
+# circuit = QuantumCircuit(register, protocol)
+# model = QuantumModel(circuit, backend="pulser", diff_mode="gpsr")
+
+# params = {
+#     "x": torch.tensor([0.8]), # rad
+#     "t": torch.tensor([900]), # ns
+#     "th00":  torch.rand(1), # rad
+#     "th01":  torch.rand(1), # rad
+#     "th10":  torch.rand(1), # rad
+#     "th11":  torch.rand(1), # rad
+#     "th20":  torch.rand(1), # rad
+#     "th21":  torch.rand(1), # rad
+# }
+
+# model.assign_parameters(params).draw(draw_phase_area=True, show=True)
+# from docs import docsutils # markdown-exec: hide
+# print(docsutils.fig_to_html(plt.gcf())) # markdown-exec: hide
 ```
 
 ## References

docs/index.md

@@ -127,7 +127,7 @@ For a more comprehensive introduction and advanced topics, please have a look at
 * [Basic tutorials](tutorials/getting_started.md) for first hands-on.
 * [Digital-analog basics](digital_analog_qc/analog-basics.md) to build quantum programs in the digital-analog paradigm.
 * [Parametric quantum circuits](tutorials/parameters.md) for the generation and manipulation of parametric programs.
-* [Advanced features](advanced_tutorials) about low-level backend interface and differentiablity.
+* [Advanced features](advanced_tutorials/differentiability.md) about low-level backend interface and differentiablity.
 * [`QuantumModel`](advanced_tutorials/custom-models.md) for defining custom models.
 
 ## Installation guide

docs/qml/qcl.md

@@ -72,7 +72,7 @@ ansatz = qd.hea(n_qubits, depth=n_qubits, strategy=qd.Strategy.SDAQC)
 ansatz = qd.tag(ansatz, "ansatz")
 
 # total magnetization observable
-observable = qd.total_magnetization(n_qubits)
+observable = qd.hamiltonian_factory(n_qubits, detuning = qd.Z)
 
 circuit = qd.QuantumCircuit(n_qubits, feature_map, ansatz)
 model = qd.QNN(circuit, [observable])

docs/tutorials/getting_started.md

@@ -17,7 +17,7 @@ which follow a more object-oriented way to construct circuits and express progra
 
 	```python exec="on" source="material-block" html="1"
 	from qadence import X, Y, kron
-	from visualization import display
+	from qadence.draw import display
 
 	kron_block = kron(X(0), Y(1))
 	display(kron_block)

docs/tutorials/ml_tools.md

@@ -50,16 +50,16 @@ Let's look at a complete example of how to use `train_with_grad` now.
 from pathlib import Path
 import torch
 from itertools import count
-from qadence.constructors import total_magnetization, hea, feature_map
-from qadence import chain, Parameter, QuantumCircuit
+from qadence.constructors import hamiltonian_factory, hea, feature_map
+from qadence import chain, Parameter, QuantumCircuit, Z
 from qadence.models import QNN
 from qadence.ml_tools import train_with_grad, TrainConfig
 import matplotlib.pyplot as plt
 
 n_qubits = 2
 fm = feature_map(n_qubits)
 ansatz = hea(n_qubits=n_qubits, depth=3)
-observable = total_magnetization(n_qubits)
+observable = hamiltonian_factory(n_qubits, detuning = Z)
 circuit = QuantumCircuit(n_qubits, fm, ansatz)
 
 model = QNN(circuit, observable, backend="pyqtorch", diff_mode="ad")
@@ -111,15 +111,15 @@ written without `train_with_grad`.
 from pathlib import Path
 import torch
 from itertools import count
-from qadence.constructors import total_magnetization, hea, feature_map
-from qadence import chain, Parameter, QuantumCircuit
+from qadence.constructors import hamiltonian_factory, hea, feature_map
+from qadence import chain, Parameter, QuantumCircuit, Z
 from qadence.models import QNN
 from qadence.ml_tools import train_with_grad, TrainConfig
 
 n_qubits = 2
 fm = feature_map(n_qubits)
 ansatz = hea(n_qubits=n_qubits, depth=3)
-observable = total_magnetization(n_qubits)
+observable = hamiltonian_factory(n_qubits, detuning = Z)
 circuit = QuantumCircuit(n_qubits, fm, ansatz)
 
 model = QNN(circuit, observable, backend="pyqtorch", diff_mode="ad")

docs/tutorials/parameters.md

@@ -261,7 +261,7 @@ print(html_string(circuit)) # markdown-exec: hide
     print(html_string(circuit)) # markdown-exec: hide
     ```
 
-The `hea` function will be further explored in the [QML Constructors tutorial](qml_constructors.md).
+The `hea` function will be further explored in the [QML Constructors tutorial](qml_tools.md).
 
 ## Parametric observables