Fix surface code link (#1843)

drdren · web-flow · commit 0be3fa118d7e · 2026-07-23T22:46:11.000-04:00
### Before submitting Please complete the following checklist when submitting a PR: - [ ] Ensure that your tutorial executes correctly, and conforms to the guidelines specified in the [README](https://github.com/PennyLaneAI/demos/blob/master/README.md). - [ ] Remember to do a grammar check of the content you include. - [ ] All tutorials conform to [PEP8 standards](https://www.python.org/dev/peps/pep-0008/). To auto format files, simply `pip install black`, and then run `black -l 100 path/to/file.py`. When all the above are checked, delete everything above the dashed line and fill in the pull request template. ------------------------------------------------------------------------------------------------------------ **Title:** **Summary:** **Relevant references:** **Possible Drawbacks:** **Related GitHub Issues:** ---- If you are writing a demonstration, please answer these questions to facilitate the marketing process. * GOALS — Why are we working on this now? *Eg. Promote a new PL feature or show a PL implementation of a recent paper.* * AUDIENCE — Who is this for? *Eg. Chemistry researchers, PL educators, beginners in quantum computing.* * KEYWORDS — What words should be included in the marketing post? * Which of the following types of documentation is most similar to your file? (more details [here](https://www.notion.so/xanaduai/Different-kinds-of-documentation-69200645fe59442991c71f9e7d8a77f8)) - [ ] Tutorial - [ ] Demo - [ ] How-to
diff --git a/demonstrations_v2/ensemble_multi_qpu/demo.py b/demonstrations_v2/ensemble_multi_qpu/demo.py
@@ -47,8 +47,8 @@
 ##############################################################################
 # This tutorial requires the ``pennylane-rigetti`` and ``pennylane-qiskit`` packages, which can be
 # installed by following the instructions `here <https://pennylane.ai/install>`__. We also
-# make use of the `PyTorch interface <https://pennylane.readthedocs.io/en/stable/introduction
-# /interfaces.html>`_, which can be installed from `here
+# make use of the `PyTorch interface <https://docs.pennylane.ai/en/stable/introduction/interfaces.html>`_, 
+# which can be installed from `here
 # <https://pytorch.org/get-started/locally/>`__.
 #
 # .. warning::
diff --git a/demonstrations_v2/ensemble_multi_qpu/metadata.json b/demonstrations_v2/ensemble_multi_qpu/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": false,
     "executable_latest": false,
     "dateOfPublication": "2020-02-14T00:00:00+00:00",
-    "dateOfLastModification": "2026-04-17T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Quantum Machine Learning"
     ],
diff --git a/demonstrations_v2/qonn/demo.py b/demonstrations_v2/qonn/demo.py
@@ -107,7 +107,7 @@
 #
 # Create a layer function which defines one layer of the QONN, consisting of a linear
 # `interferometer
-# <https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.subroutines.Interferometer.html>`__
+# <https://docs.pennylane.ai/en/stable/code/api/pennylane.Interferometer.html>`__
 # (i.e., an array of beamsplitters and phase shifts) and a non-linear Kerr interaction layer. Both
 # the interferometer and the non-linear layer are applied to all modes. The triangular mesh scheme,
 # described in `Reck et al. (1994) <https://dx.doi.org/10.1103/PhysRevLett.73.58>`__ is chosen here
diff --git a/demonstrations_v2/qonn/metadata.json b/demonstrations_v2/qonn/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": false,
     "executable_latest": false,
     "dateOfPublication": "2020-08-05T00:00:00+00:00",
-    "dateOfLastModification": "2026-04-14T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Optimization"
     ],
diff --git a/demonstrations_v2/tutorial_data_reuploading_classifier/demo.py b/demonstrations_v2/tutorial_data_reuploading_classifier/demo.py
@@ -128,7 +128,7 @@
 We can encode the output label as a particular quantum state that we want
 to end up in and use Pennylane to find the probability of ending up in that
 state after running the circuit. We construct an observable corresponding to
-the output label using the `Hermitian <https://pennylane.readthedocs.io/en/latest/code/ops/qubit.html#pennylane.ops.qubit.Hermitian>`_
+the output label using the `Hermitian <https://docs.pennylane.ai/en/stable/code/api/pennylane.Hermitian.html>`_
 operator. The expectation value of the observable gives the overlap or fidelity.
 We can then define the cost function as the sum of the fidelities for all
 the data points after passing through the circuit and optimize the parameters
diff --git a/demonstrations_v2/tutorial_data_reuploading_classifier/metadata.json b/demonstrations_v2/tutorial_data_reuploading_classifier/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2019-10-11T00:00:00+00:00",
-    "dateOfLastModification": "2026-06-19T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Quantum Machine Learning"
     ],
diff --git a/demonstrations_v2/tutorial_game_of_surface_codes/demo.py b/demonstrations_v2/tutorial_game_of_surface_codes/demo.py
@@ -16,7 +16,7 @@
 Introduction
 ------------
 
-The game of surface codes is a high-level framework for designing :doc:` surface code <demos/intro_to_surface_code>` quantum computing architectures.
+The game of surface codes is a high-level framework for designing :doc:`surface code <demos/intro_to_surface_code>` quantum computing architectures.
 The game helps us understand space-time trade-offs, where designs with a higher qubit overhead allow for faster computations and vice versa.
 For example, a space-efficient design might allow a computation with :math:`10^8` T gates to run in :math:`4` hours using :math:`55k` physical qubits, 
 whereas an intermediate design may run the same computation in :math:`22` minutes using :math:`120k` physical qubits, 
diff --git a/demonstrations_v2/tutorial_game_of_surface_codes/metadata.json b/demonstrations_v2/tutorial_game_of_surface_codes/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2025-06-02T00:00:00+00:00",
-    "dateOfLastModification": "2026-07-14T00:00:00+00:00",
+    "dateOfLastModification": "2026-07-23T00:00:00+00:00",
     "categories": [
         "Quantum Computing",
         "Compilation",
diff --git a/demonstrations_v2/tutorial_how_to_build_compressed_double_factorized_hamiltonians/demo.py b/demonstrations_v2/tutorial_how_to_build_compressed_double_factorized_hamiltonians/demo.py
@@ -229,7 +229,7 @@
 # :class:`~.pennylane.BasisRotation` operation, which implements the unitary transformation
 # :math:`\exp \left( \sum_{pq}[\log U]_{pq} (a^\dagger_p a_q - a^\dagger_q a_p) \right)`
 # using the `Givens rotation networks
-# <https://docs.pennylane.ai/en/stable/code/api/pennylane.qchem.givens_decomposition.html>`_
+# <https://docs.pennylane.ai/en/stable/code/api/pennylane.math.decomposition.givens_decomposition.html>`_
 # that can be efficiently implemented on quantum hardware. The ``leaf_unitary_rotation``
 # function below does this for a leaf tensor:
 #
diff --git a/demonstrations_v2/tutorial_how_to_build_compressed_double_factorized_hamiltonians/metadata.json b/demonstrations_v2/tutorial_how_to_build_compressed_double_factorized_hamiltonians/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2025-03-05T09:00:00+00:00",
-    "dateOfLastModification": "2026-05-28T00:00:00+00:00",
+    "dateOfLastModification": "2026-07-23T00:00:00+00:00",
     "categories": [
         "Quantum Chemistry",
         "Algorithms",
diff --git a/demonstrations_v2/tutorial_kernel_based_training/demo.py b/demonstrations_v2/tutorial_kernel_based_training/demo.py
@@ -205,7 +205,7 @@
 
 ######################################################################
 # We use the `angle-embedding
-# template <https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.embeddings.AngleEmbedding.html>`__
+# template <https://docs.pennylane.ai/en/stable/code/api/pennylane.AngleEmbedding.html>`__
 # which needs as many qubits as there are features:
 #
 
diff --git a/demonstrations_v2/tutorial_kernel_based_training/metadata.json b/demonstrations_v2/tutorial_kernel_based_training/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2021-02-03T00:00:00+00:00",
-    "dateOfLastModification": "2026-06-01T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Quantum Machine Learning"
     ],
diff --git a/demonstrations_v2/tutorial_mapping/demo.py b/demonstrations_v2/tutorial_mapping/demo.py
@@ -171,7 +171,7 @@
 # by storing both the occupation number and the parity non-locally. In this formalism, even-labelled
 # qubits store the occupation number of orbitals and odd-labelled qubits store parity
 # through partial sums of occupation numbers. The corresponding creation and annihilation operators
-# are defined `here <https://docs.pennylane.ai/en/stable/code/api/pennylane.fermi.bravyi_kitaev.html>`__.
+# are defined `here <https://docs.pennylane.ai/en/stable/code/api/pennylane.bravyi_kitaev.html>`__.
 # Let's use the :func:`~.pennylane.fermi.bravyi_kitaev` function to map our :math:`a_{5}^{\dagger}`
 # operator.
 
diff --git a/demonstrations_v2/tutorial_mapping/metadata.json b/demonstrations_v2/tutorial_mapping/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2024-05-06T00:00:00+00:00",
-    "dateOfLastModification": "2026-05-28T00:00:00+00:00",
+    "dateOfLastModification": "2026-07-23T00:00:00+00:00",
     "categories": [
         "Algorithms",
         "Quantum Computing",
diff --git a/demonstrations_v2/tutorial_quantum_metrology/demo.py b/demonstrations_v2/tutorial_quantum_metrology/demo.py
@@ -151,7 +151,7 @@ def encoding(phi, gamma):
 # We now choose a parametrization for both the probe state and the POVM.
 # To be able to parametrize all possible probe states and all local measurements,
 # we make use of the
-# `ArbitraryStatePreparation <https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.state_preparations.ArbitraryStatePreparation.html>`_
+# `ArbitraryStatePreparation <https://docs.pennylane.ai/en/stable/code/api/pennylane.ArbitraryStatePreparation.html>`_
 # template from PennyLane.
 
 
@@ -269,7 +269,7 @@ def cost(weights, phi, gamma, J, W, epsilon=1e-10):
 
 ##############################################################################
 # We are now ready to perform the optimization. We will initialize the weights
-# at random. Then we make use of the `Adagrad <https://pennylane.readthedocs.io/en/stable/introduction/optimizers.html>`_
+# at random. Then we make use of the `Adagrad <https://docs.pennylane.ai/en/stable/code/api/pennylane.AdagradOptimizer.html>`_
 # optimizer. Adaptive gradient descent methods are advantageous as the optimization
 # of quantum sensing protocols is very sensitive to the step size.
 def opt_cost(weights, phi=phi, gamma=gamma, J=J, W=W):
diff --git a/demonstrations_v2/tutorial_quantum_metrology/metadata.json b/demonstrations_v2/tutorial_quantum_metrology/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2020-06-18T00:00:00+00:00",
-    "dateOfLastModification": "2026-06-19T00:00:00+00:00",
+    "dateOfLastModification": "2026-07-23T00:00:00+00:00",
     "categories": [
         "Optimization"
     ],
diff --git a/demonstrations_v2/tutorial_quantum_natural_gradient/demo.py b/demonstrations_v2/tutorial_quantum_natural_gradient/demo.py
@@ -31,7 +31,7 @@
 of the quantum device. Examples of such algorithms include the :doc:`variational quantum
 eigensolver (VQE) <demos/tutorial_vqe>`, the
 `quantum approximate optimization algorithm (QAOA) <https://arxiv.org/abs/1411.4028>`__,
-and :doc:`quantum neural networks (QNN) <demos/tutorial_quantum_neural_net>`.
+and :doc:`quantum neural networks (QNN) <demos/quantum_neural_net>`.
 
 Most recent demonstrations
 of variational quantum algorithms have used gradient-free classical optimization
diff --git a/demonstrations_v2/tutorial_quantum_natural_gradient/metadata.json b/demonstrations_v2/tutorial_quantum_natural_gradient/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2019-10-11T00:00:00+00:00",
-    "dateOfLastModification": "2026-06-01T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Optimization"
     ],
diff --git a/demonstrations_v2/tutorial_vqe_spin_sectors/demo.py b/demonstrations_v2/tutorial_vqe_spin_sectors/demo.py
@@ -92,7 +92,7 @@
 # creation operators, and
 # :math:`\langle \alpha, \beta \vert \hat{s}_1 \cdot \hat{s}_2 \vert \gamma, \delta \rangle`
 # is the `matrix element of the two-body spin operator
-# <https://pennylane.readthedocs.io/en/stable/code/api/pennylane.qchem.obs.spin2.html>`_
+# <https://docs.pennylane.ai/en/stable/code/api/pennylane.qchem.spin2.html>`_
 # :math:`\hat{s}_1 \cdot \hat{s}_2` in the basis of spin orbitals.
 #
 # We use the :func:`~.pennylane.qchem.obs.spin2` function to build the
diff --git a/demonstrations_v2/tutorial_vqe_spin_sectors/metadata.json b/demonstrations_v2/tutorial_vqe_spin_sectors/metadata.json
@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2020-10-13T00:00:00+00:00",
-    "dateOfLastModification": "2026-06-19T15:48:14+00:00",
+    "dateOfLastModification": "2026-07-23T15:48:14+00:00",
     "categories": [
         "Quantum Chemistry"
     ],

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@`
`107`	`107`	`#`
`108`	`108`	`# Create a layer function which defines one layer of the QONN, consisting of a linear`
`109`	`109`	# `interferometer
`110`		-# <https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.subroutines.Interferometer.html>`__
	`110`	+# <https://docs.pennylane.ai/en/stable/code/api/pennylane.Interferometer.html>`__
`111`	`111`	`# (i.e., an array of beamsplitters and phase shifts) and a non-linear Kerr interaction layer. Both`
`112`	`112`	`# the interferometer and the non-linear layer are applied to all modes. The triangular mesh scheme,`
`113`	`113`	# described in `Reck et al. (1994) <https://dx.doi.org/10.1103/PhysRevLett.73.58>`__ is chosen here
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@`
`229`	`229`	# :class:`~.pennylane.BasisRotation` operation, which implements the unitary transformation
`230`	`230`	# :math:`\exp \left( \sum_{pq}[\log U]_{pq} (a^\dagger_p a_q - a^\dagger_q a_p) \right)`
`231`	`231`	# using the `Givens rotation networks
`232`		-# <https://docs.pennylane.ai/en/stable/code/api/pennylane.qchem.givens_decomposition.html>`_
	`232`	+# <https://docs.pennylane.ai/en/stable/code/api/pennylane.math.decomposition.givens_decomposition.html>`_
`233`	`233`	# that can be efficiently implemented on quantum hardware. The ``leaf_unitary_rotation``
`234`	`234`	`# function below does this for a leaf tensor:`
`235`	`235`	`#`