Redirect link from qutip/docs to readthedocs

qutip · Apr 2, 2024 · c401ecc · c401ecc
1 parent 86868a4
commit c401ecc
Show file tree

Hide file tree

Showing 27 changed files with 56 additions and 56 deletions.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -2,6 +2,6 @@
 
 You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip-tutorials/issues).
 You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+All code contributions are acknowledged in the [contributors](https://qutip.readthedocs.io/en/latest/contributors.html) section in the documentation.
 
-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.readthedocs.io/en/latest/development/contributing.html).
diff --git a/tutorials-v4/lectures/Lecture-0-Introduction-to-QuTiP.md b/tutorials-v4/lectures/Lecture-0-Introduction-to-QuTiP.md
@@ -40,7 +40,7 @@ It includes facilities for representing and doing calculations with quantum obje
 It also includes solvers for a time-evolution of quantum systems, according to: Schrodinger equation, von Neuman equation, master equations, Floquet formalism, Monte-Carlo quantum trajectors, experimental implementations of the stochastic Schrodinger/master equations.
 
 For more information see the project web site at [qutip.org](https://qutip.org), and the 
-[QuTiP documentation](https://qutip.org/docs/latest/index.html).
+[QuTiP documentation](https://qutip.readthedocs.io/en/latest/index.html).
 
 ### Installation
 
@@ -148,7 +148,7 @@ H.tr()
 H.eigenenergies()
 ```
 
-For a complete list of methods and properties of the `Qobj` class, see the [QuTiP documentation](https://qutip.org/docs/latest/index.html) or try `help(Qobj)` or `dir(Qobj)`.
+For a complete list of methods and properties of the `Qobj` class, see the [QuTiP documentation](https://qutip.readthedocs.io/en/latest/index.html) or try `help(Qobj)` or `dir(Qobj)`.
 
 
 ## States and operators

diff --git a/tutorials-v4/pulse-level-circuit-simulation/qip-customize-device.md b/tutorials-v4/pulse-level-circuit-simulation/qip-customize-device.md
@@ -403,7 +403,7 @@ plt.show()
 ```
 
 ## Customizing the noise
-Apart from pre-defined noise such as T1, T2 noise and random noise in the control pulse amplitude (see this [guide](https://qutip.org/docs/latest/guide/qip/qip-processor.html), one can also define custom noise. Here we will see two examples of customizing noise, one systematic (pulse-independent) noise and one pulse-dependent noise. 
+Apart from pre-defined noise such as T1, T2 noise and random noise in the control pulse amplitude (see this [guide](https://qutip.readthedocs.io/en/latest/guide/qip/qip-processor.html), one can also define custom noise. Here we will see two examples of customizing noise, one systematic (pulse-independent) noise and one pulse-dependent noise. 
 
 To understand how noise is processed, we briefly introduced the data structure of the simulation framework. The control elements are stored as a list of `Pulse` objects in the Processor. In each Pulse contains the idea pulse, the control noise part and the decoherence part. For systematic noise, it is saved under the `Pulse` representation labelled `"system"`, which represents the intrinsic dynamics of the quantum system. For pulse-dependent noise, we will add them to their corresponding control `Pulse`. 
 

diff --git a/tutorials-v4/pulse-level-circuit-simulation/qip-optpulseprocessor.md b/tutorials-v4/pulse-level-circuit-simulation/qip-optpulseprocessor.md
@@ -27,7 +27,7 @@ from qutip.ipynbtools import version_table
 import qutip_qip
 ```
 
-The `qutip.OptPulseProcessor` is a noisy quantum device simulator integrated with the optimal pulse algorithm from the `qutip.control` module. It is a subclass of `qutip.Processor` and is equipped with a method to find the optimal pulse sequence (hence the name `OptPulseProcessor`) for a `qutip.QubitCircuit` or a list of `qutip.Qobj`. For the user guide of `qutip.Processor`, please refer to [the introductory guide](https://qutip.org/docs/latest/guide/qip/qip-processor.html).
+The `qutip.OptPulseProcessor` is a noisy quantum device simulator integrated with the optimal pulse algorithm from the `qutip.control` module. It is a subclass of `qutip.Processor` and is equipped with a method to find the optimal pulse sequence (hence the name `OptPulseProcessor`) for a `qutip.QubitCircuit` or a list of `qutip.Qobj`. For the user guide of `qutip.Processor`, please refer to [the introductory guide](https://qutip.readthedocs.io/en/latest/guide/qip/qip-processor.html).
 
 ## Single-qubit gate
 Like in the parent class `Processor`, we need to first define the available Hamiltonians in the system. The `OptPulseProcessor` has one more parameter, the drift Hamiltonian, which has no time-dependent coefficients and thus won't be optimized.

diff --git a/tutorials-v4/pulse-level-circuit-simulation/qip-scheduler.md b/tutorials-v4/pulse-level-circuit-simulation/qip-scheduler.md
@@ -97,7 +97,7 @@ for gate in circuit.gates:
 scheduler.schedule(instructions)
 ```
 
-The scheduled execution time for each gate can no longer be assigned to gate cycles. But we can see this through the [noisy circuit simulator](https://qutip.org/docs/latest/guide/qip/qip-processor.html) of qutip, where the circuit is compiled to control signals: (Notice that the execution time follows the hardware parameter of spin chain and the Y gate is decomposed into a Z-X-Z rotation).
+The scheduled execution time for each gate can no longer be assigned to gate cycles. But we can see this through the [noisy circuit simulator](https://qutip.readthedocs.io/en/latest/guide/qip/qip-processor.html) of qutip, where the circuit is compiled to control signals: (Notice that the execution time follows the hardware parameter of spin chain and the Y gate is decomposed into a Z-X-Z rotation).
 
 ```python
 device = LinearSpinChain(3)

diff --git a/tutorials-v4/time-evolution/002_larmor-precession.md b/tutorials-v4/time-evolution/002_larmor-precession.md
@@ -18,12 +18,12 @@ Author: C. Staufenbiel, 2022
 
 ### Introduction
 
-This notebook guides you through the process of setting up a Schrödinger 
-equation in QuTiP and using the corresponding solver to obtain the time 
-evolution. We will investigate the example of the Larmor precession to 
-explore the functionality of [`qutip.sesolve()`](https://qutip.org/docs/latest/apidoc/functions.html?highlight=sesolve#module-qutip.sesolve).
+This notebook guides you through the process of setting up a Schrödinger
+equation in QuTiP and using the corresponding solver to obtain the time
+evolution. We will investigate the example of the Larmor precession to
+explore the functionality of [`qutip.sesolve()`](https://qutip.readthedocs.io/en/latest/apidoc/functions.html?highlight=sesolve#module-qutip.sesolve).
 
-You can also find more on time evolutions with QuTiP [here](https://qutip.org/docs/latest/guide/guide-dynamics.html).
+You can also find more on time evolutions with QuTiP [here](https://qutip.readthedocs.io/en/latest/guide/guide-dynamics.html).
 
 ### Setup
 
@@ -49,8 +49,8 @@ b.show()
 ### Simulation with constant magnetic field
 
 Let's define a simple Hamiltonian and use `qutip.sesolve` to solve the
-Schrödinger equation. The Hamiltonian describes a constant magnetic field 
-along the z-axis. We can describe this magnetic field by the corresponding 
+Schrödinger equation. The Hamiltonian describes a constant magnetic field
+along the z-axis. We can describe this magnetic field by the corresponding
 Pauli matrix, which is defined as `qutip.sigmaz()` in QuTiP.
 
 To solve the Schrödinger equation for this particular Hamiltonian, we have to pass the Hamiltonian, the initial state, the times for which we want to simulate the system, and a set of observables that we evaluate at these times.
@@ -64,7 +64,7 @@ times = np.linspace(0, 10, 100)
 result = sesolve(H, psi, times, [sigmay()])
 ```
 
-`result.expect` holds the expecation values for the times that we passed to `sesolve`. `result.expect` is a two dimensional array, where the first dimension refers to the different expectation operators that we passed to `sesolve` before. 
+`result.expect` holds the expecation values for the times that we passed to `sesolve`. `result.expect` is a two dimensional array, where the first dimension refers to the different expectation operators that we passed to `sesolve` before.
 
 Above we passed `sigmay()` as the only expectation operator and therefore we can access its values by `result.expect[0]`. Below we plot the evolution of the expecation value.
 
@@ -85,7 +85,7 @@ b.show()
 
 ## Simulation with varying magnetic field
 
-Above we passed a constant Hamiltonian to `sesolve`. In QuTiP these constant operators are represented by `Qobj`. However, `sesolve` can also take time-dependent operators as an argument, which are represented by [`QobjEvo`](https://qutip.org/docs/latest/apidoc/classes.html?highlight=qobjevo#qutip.QobjEvo) in QuTiP. In this section we define the magnetic field with a linear and a periodic field strength, and observe the changes in the expecation value of $\sigma_y$.
+Above we passed a constant Hamiltonian to `sesolve`. In QuTiP these constant operators are represented by `Qobj`. However, `sesolve` can also take time-dependent operators as an argument, which are represented by [`QobjEvo`](https://qutip.readthedocs.io/en/latest/apidoc/classes.html?highlight=qobjevo#qutip.QobjEvo) in QuTiP. In this section we define the magnetic field with a linear and a periodic field strength, and observe the changes in the expecation value of $\sigma_y$.
 You can find more information on `QobjEvo` in [this notebook](https://nbviewer.jupyter.org/github/qutip/qutip-notebooks/blob/master/examples/qobjevo.ipynb).
 
 We start by defining two functions for the field strength of the magnetic field. To be passed on to `QobjEvo` the functions need two arguments: the times and optional arguments.
@@ -127,8 +127,8 @@ plt.show()
 ```
 
 ### Conclusion
-We can use `sesolve` to solve unitary time evolutions. This is not only 
-limited to constant Hamiltonians, but we can also make use of time-dependent Hamiltonians using `QobjEvo`. 
+We can use `sesolve` to solve unitary time evolutions. This is not only
+limited to constant Hamiltonians, but we can also make use of time-dependent Hamiltonians using `QobjEvo`.
 
 ### About
 

diff --git a/tutorials-v4/time-evolution/003_qubit-dynamics.md b/tutorials-v4/time-evolution/003_qubit-dynamics.md
@@ -21,7 +21,7 @@ Modified by: C. Staufebiel (2022)
 ### Introduction
 In this notebook we will explore the dynamics of a single-qubit interacting with an environment. The evolution of the qubit state is governed by the Master equation. We will make use of the master equation solver `qutip.mesolve` implemented in qutip, to obtain the time-evolution of the qubit for different settings.
 
-You can read more about the master equation solver (and the theory behind it) in the [QuTiP docs](https://qutip.org/docs/latest/apidoc/functions.html?highlight=sesolve#module-qutip.sesolve).
+You can read more about the master equation solver (and the theory behind it) in the [QuTiP docs](https://qutip.readthedocs.io/en/latest/apidoc/functions.html?highlight=sesolve#module-qutip.sesolve).
 
 ### Import
 Here we import the required modules for this example.

diff --git a/tutorials-v4/time-evolution/004_rabi-oscillations.md b/tutorials-v4/time-evolution/004_rabi-oscillations.md
@@ -25,7 +25,7 @@ Jaynes-Cumming model, i.e., the cavity and the atom are coupled to an
 environment.
 
 
-For more information on the theory behind the Master Equation Solver see [the documentation](https://qutip.org/docs/latest/guide/dynamics/dynamics-master.html#non-unitary-evolution).
+For more information on the theory behind the Master Equation Solver see [the documentation](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-master.html#non-unitary-evolution).
 
 
 ### Package import
@@ -50,7 +50,7 @@ $H_{\rm RWA} = \hbar \omega_c a^\dagger a + \frac{1}{2}\hbar\omega_a\sigma_z + \
 
 where $\omega_c$ and $\omega_a$ are the frequencies of the cavity and atom, respectively, and $g$ is the interaction strength.
 
-In this example we also consider the coupling of the Jaynes-Cummings model to an external environment, i.e., we need to solve the system using the Master Equation Solver `qutip.mesolve`. The coupling to the environment is described by the collapse operators (as described in [the docs](https://qutip.org/docs/latest/guide/dynamics/dynamics-master.html#non-unitary-evolution)). Here, we consider two collapse operators for the cavity $C_1, C_2$, describing creation and annihilation of photons, and one collapse operator for the atom $C_3$.
+In this example we also consider the coupling of the Jaynes-Cummings model to an external environment, i.e., we need to solve the system using the Master Equation Solver `qutip.mesolve`. The coupling to the environment is described by the collapse operators (as described in [the docs](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-master.html#non-unitary-evolution)). Here, we consider two collapse operators for the cavity $C_1, C_2$, describing creation and annihilation of photons, and one collapse operator for the atom $C_3$.
 
 $C_1 = \sqrt{\kappa (1+\langle n \rangle)} \; a$
 

diff --git a/tutorials-v4/time-evolution/006_photon_birth_death.md b/tutorials-v4/time-evolution/006_photon_birth_death.md
@@ -21,7 +21,7 @@ Modifications: C. Staufenbiel (2022)
 
 ### Introduction
 
-In this tutorial we demonstrate the *Monte Carlo Solver* functionality implemented in `qutip.mcsolve()`. For more information on the *MC Solver* refer to the [QuTiP documentation](https://qutip.org/docs/latest/guide/dynamics/dynamics-monte.html). 
+In this tutorial we demonstrate the *Monte Carlo Solver* functionality implemented in `qutip.mcsolve()`. For more information on the *MC Solver* refer to the [QuTiP documentation](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-monte.html). 
 
 We aim to reproduce the experimental results from:
 

diff --git a/tutorials-v4/time-evolution/007_brmesolve_tls.md b/tutorials-v4/time-evolution/007_brmesolve_tls.md
@@ -24,7 +24,7 @@ with inspirations from the [`brmesolve notebook`](https://github.com/qutip/qutip
 
 The Bloch-Redfield solver is another method to solve a master equation. In comparison to the Lindblad Master equation solver `qutip.mesolve()` the Bloch-Redfield solver `qutip.brmesolve()` differs in the description of the interaction with the environment. In `qutip.mesolve()` we described the dissipation by collapse operators, which do not necessarily have a physical interpretation. The `qutip.brmesolve()` function requires the a dissipation description by the so-called *noise-power-spectrum*, which gives the intensity of the dissipation depending on the frequency $\omega$.
 
-In this notebook we will introduce the basic usage of `qutip.brmesolve()` and compare it to `qutip.mesolve()`. For more information on the Bloch-Redfield solver see the follow-up notebooks and the [QuTiP Documentation of the functionality](https://qutip.org/docs/latest/guide/dynamics/dynamics-bloch-redfield.html).
+In this notebook we will introduce the basic usage of `qutip.brmesolve()` and compare it to `qutip.mesolve()`. For more information on the Bloch-Redfield solver see the follow-up notebooks and the [QuTiP Documentation of the functionality](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-bloch-redfield.html).
 
 ### Imports
 <!-- #endregion -->
@@ -111,7 +111,7 @@ plt.legend(), plt.xlabel("time"), plt.ylabel("<X>");
 
 ## Bloch-Redfield Tensor
 
-We described the dynmamics of the system by the Bloch-Redfield master equation, which is constructed from the Bloch-Redfield tensor $R_{abcd}$ (see [documentation of Bloch-Redfield master equation](https://qutip.org/docs/latest/guide/dynamics/dynamics-bloch-redfield.html)). Hence the dynamics are determined by this tensor. We can calculate the tensor in QuTiP using the `qutip.bloch_redfield_tensor()` function. We have to pass the Hamiltonian of the system and the dissipation description in `a_ops` to construct $R_{abcd}$. Furthermore, the function gives us the **eigenstates of the Hamiltonian**, as they are calculated along the way.
+We described the dynmamics of the system by the Bloch-Redfield master equation, which is constructed from the Bloch-Redfield tensor $R_{abcd}$ (see [documentation of Bloch-Redfield master equation](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-bloch-redfield.html)). Hence the dynamics are determined by this tensor. We can calculate the tensor in QuTiP using the `qutip.bloch_redfield_tensor()` function. We have to pass the Hamiltonian of the system and the dissipation description in `a_ops` to construct $R_{abcd}$. Furthermore, the function gives us the **eigenstates of the Hamiltonian**, as they are calculated along the way.
 
 
 ```python

diff --git a/tutorials-v4/time-evolution/008_brmesolve_time_dependence.md b/tutorials-v4/time-evolution/008_brmesolve_time_dependence.md
@@ -16,10 +16,10 @@ jupyter:
 
 Authors: C. Staufenbiel, 2022
 
-following the instructions in the [Bloch-Redfield documentation](https://qutip.org/docs/latest/guide/dynamics/dynamics-bloch-redfield.html?#time-dependent-bloch-redfield-dynamics).
+following the instructions in the [Bloch-Redfield documentation](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-bloch-redfield.html?#time-dependent-bloch-redfield-dynamics).
 
 ### Introduction
-This notebook introduces the usage of time-dependent operators in the Bloch-Redfield solver, which is also described in the [corresponding documentation](https://qutip.org/docs/latest/guide/dynamics/dynamics-bloch-redfield.html?#time-dependent-bloch-redfield-dynamics).
+This notebook introduces the usage of time-dependent operators in the Bloch-Redfield solver, which is also described in the [corresponding documentation](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-bloch-redfield.html?#time-dependent-bloch-redfield-dynamics).
 
 We will discuss time-dependent Hamiltonians and time-dependent dissipations. The Bloch-Redfield solver is especially efficient since it uses Cython internally. For correct functioning we have to pass the time dependence in a string-based format. 
 
@@ -55,15 +55,15 @@ result_const = brmesolve(H, psi0, times, e_ops=[a.dag() * a])
 plot_expectation_values(result_const, ylabels=["<n>"]);
 ```
 
-Next we define a string, which describes some time-dependence. We can use functions that are supported by the Cython implementation. A list of all supported functions can be found in the  [docs](https://qutip.org/docs/latest/guide/dynamics/dynamics-time.html#time). For example, supported functions are `sin` or `exp`. The time variable is denoted by `t`.
+Next we define a string, which describes some time-dependence. We can use functions that are supported by the Cython implementation. A list of all supported functions can be found in the  [docs](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-time.html#time). For example, supported functions are `sin` or `exp`. The time variable is denoted by `t`.
 
 ```python
 time_dependence = "sin(t)"
 ```
 
 ### Time-dependent Hamiltonian
 
-As a first example, we define a time-dependent Hamiltonian (as described [here](https://qutip.org/docs/latest/guide/dynamics/dynamics-time.html)). 
+As a first example, we define a time-dependent Hamiltonian (as described [here](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-time.html)). 
 
 $$ H = \hat{n} + sin(t) \hat{x} $$
 

diff --git a/tutorials-v4/time-evolution/009_brmesolve-cavity-QED.md b/tutorials-v4/time-evolution/009_brmesolve-cavity-QED.md
@@ -21,7 +21,7 @@ with inspirations from the [`brmesolve notebook`](https://github.com/qutip/qutip
 
 ### Introduction
 
-This notebook does not introduce the usage of the Bloch-Redfield solver `qutip.brmesolve()` in detail. For a more detailed introduction to this solver see the [*Bloch-Redfield Solver: Two Level System* notebook](007_brmesolve_tls.md) and the [documentation of the function](https://qutip.org/docs/latest/guide/dynamics/dynamics-bloch-redfield.html).
+This notebook does not introduce the usage of the Bloch-Redfield solver `qutip.brmesolve()` in detail. For a more detailed introduction to this solver see the [*Bloch-Redfield Solver: Two Level System* notebook](007_brmesolve_tls.md) and the [documentation of the function](https://qutip.readthedocs.io/en/latest/guide/dynamics/dynamics-bloch-redfield.html).
 
 The Lindblad master equation solver, implemented in `qutip.mesolve()`, deals with dissipation using collapse operators which can act on subsystems of the general system. For example, we can define dissipation for the atom-cavity system for the cavity and the atom separately, by the corresponding annihilation operator. In this example, we will see the limitations of this approach when it comes to strong coupling between atom and cavity.