Update old qutip doc links

Author: BoxiLi

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/qutip-4.7.x/index.html).
 
 ### Installation
 
@@ -152,7 +152,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/qutip-4.7.x/index.html) or try `help(Qobj)` or `dir(Qobj)`.
 
 
 ## States and operators

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/qutip-4.7.x/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`. 
 

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/qutip-4.7.x/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.

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/qutip-4.7.x/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)

tutorials-v4/time-evolution/002_larmor-precession.md

@@ -21,9 +21,9 @@ Author: C. Staufenbiel, 2022
 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).
+explore the functionality of [`qutip.sesolve()`](https://qutip.readthedocs.io/en/qutip-4.7.x/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/qutip-4.7.x/guide/guide-dynamics.html).
 
 ### Setup
 
@@ -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/qutip-4.7.x/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.ipython.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.

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/qutip-4.7.x/apidoc/functions.html?highlight=sesolve#module-qutip.sesolve).
 
 ### Import
 Here we import the required modules for this example.

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/qutip-4.7.x/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/qutip-4.7.x/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$
 

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/qutip-4.7.x/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/qutip-4.7.x/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

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/qutip-4.7.x/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/qutip-4.7.x/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/qutip-4.7.x/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/qutip-4.7.x/guide/dynamics/dynamics-time.html)). 
 
 $$ H = \hat{n} + sin(t) \hat{x} $$
 

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/qutip-4.7.x/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.