Tutorial: tensor network basics

[EmilianoG-byte]

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.

• Remember to do a grammar check of the content you include.

• All tutorials conform to
  PEP8 standards.
  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:

[sc-66746]

---

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)

• Tutorial
• Demo
• How-to

[github-actions]

👋 Hey, looks like you've updated some demos!

🐘 Don't forget to update the dateOfLastModification in the associated metadata files so your changes are reflected in Glass Onion (search and recommendations).

Please hide this comment once the field(s) are updated. Thanks!

[Qottmann]

Great skeleton @EmilianoG-byte @Shiro-Raven !

Mainly minor suggestions, and one bigger one towards the last section for quantum circuit applications

[Qottmann]

timeit is a good idea, could also print out dimensions at different steps along a contraction path

[EmilianoG-byte]

good idea!

[EmilianoG-byte]

Coming back to this, I printed the dimensions locally but I don't quite get what insight we get from this. Since we only have three tensors, the dimensions of intermediate tensors (AB) and (BC) are actually exactly the same. This also by construction to get the expected scaling in the computational cost.

I could come up with an example where the dimensions vary between contraction paths but probably would have to be more complex and not just a "triangle-like" tensor network

[Qottmann]

Yeah sounds like the example is too simple to show the desired property

I could come up with an example where the dimensions vary between contraction paths

💯

[Qottmann]

just to be sure, I guess also the timing is the same in the situation you describe rn?

[EmilianoG-byte]

Well the timing varies and that is what I was trying to convey here, as the timing scales exactly as we would expect it from the complexity analysis I discussed some lines before. What would you like to show with the dimensions? That some paths result in tensors of larger intermediate size?

[Qottmann]

What would you like to show with the dimensions? That some paths result in tensors of larger intermediate size?

exactly :)

[Qottmann]

I would suggest to do concrete examples of gates already above, e.g. single qubit gates = matrices, 2 qubit gates like CNOT = 4 leg tensor with 2 "in" and 2 "out" legs etc.

and then focus here on how e.g. an expectation value $\langle \psi_0 | U^\dagger H U |\psi_0\rangle$ is a tensor network contraction of the initial state - unitary circuit - hamiltonian unitary circuit and initial state again. From the above we should be able to understand all the sub-components and here we are fusing them together

there are some subtleties here:

• While in priciple a n-qubit state is a n-legged (=2^n sized) tensor, $\psi_0$ is often a product state, so it is just n independent vectors.
• H is often the sum of multiple operators. It is beyond the scope of this tutorial to go in depth, but there are ways to efficiently represent such a sum of tensors (e.g. MPOs and generalizations thereof). The "naive" thing to do for a sum of operators $H = \sum_i h_i$ is to do separate evaluations for each $\langle \psi_0 | U^\dagger h_i U |\psi_0\rangle$ and sum them in the end.
• $\langle \psi_0 | U^\dagger$ and $U |\psi_0\rangle$ appear twice in the equation, if one can represent their result efficiently we can re-use it (not a given as it may result in a large 2^n tensor)

[EmilianoG-byte]

Great suggestions! Do you think is worth going into the details of boolean tensor networks when talking about the CNOT (for instance):

[EmilianoG-byte]

While in priciple a n-qubit state is a n-legged (=2^n sized) tensor, $\psi_0$
is often a product state, so it is just n independent vectors.

doesn't this go more into the direction of MPS (which is out of the scope of this tutorial)?

The "naive" thing to do for a sum of operators

If I am not mistaken, since we are assuming an exact contraction of the tensor network without approximating it as an MPS, this naive way is the only option, no? Or is it possible to use the Hamiltonian as an MPO and contract it with the state vector even tho this is not in MPS form?

if one can represent their result efficiently we can re-use it (not a given as it may result in a large 2^n tensor)

here again you mean efficiently as an MPS? Or do you mean this thing that Quimb does where it reuses contraction paths and other parts of the computation? (I couldn't find the link but I remember seeing something along these lines)

[EmilianoG-byte]

If I am not mistaken, since we are assuming an exact contraction of the tensor network without approximating it as an MPS, this naive way is the only option, no? Or is it possible to use the Hamiltonian as an MPO and contract it with the state vector even tho this is not in MPS form?

Update: Actually I thought more about it, and I think I was wrong on this. I cannot think of a real constraint of why just contracting a general tensor circuit (no MPS) with an MPO would not work.

[Qottmann]

doesn't this go more into the direction of MPS (which is out of the scope of this tutorial)?

A product state is something different. You can interpret it as an MPS with trivial virtual bond dimension 1 but that is not the point

If I am not mistaken, since we are assuming an exact contraction of the tensor network without approximating it as an MPS, this naive way is the only option, no? Or is it possible to use the Hamiltonian as an MPO and contract it with the state vector even tho this is not in MPS form?

MPOs are typically exact and of course you can contract them with something that is not an MPS :)

here again you mean efficiently as an MPS? Or do you mean this thing that Quimb does where it reuses contraction paths and other parts of the computation? (I couldn't find the link but I remember seeing something along these lines)

The latter :) though I am actually not sure what https://github.com/PennyLaneAI/pennylane/blob/master/pennylane/devices/default_tensor.py#L799 does

Do you think is worth going into the details of boolean tensor networks when talking about the CNOT (for instance):

Up to you! I personally dont find that too important but if you like it feel free to include it :)

[EmilianoG-byte]

I have now added a section on tensor networks-quantum computing. Lmk what you think!

[Qottmann]

is the demo overall ready for review?

[EmilianoG-byte]

I would think so @Qottmann :). I can read the whole thing between today and tomorrow to find typos but content-wise, I am happy with what it has.

I just have two TODO's on the script for myself which are to add some details to some figures.

[Qottmann]

Great! Then I'd suggest to do a self-review first, and when it's ready for a full review please tag me in the PR :)

[github-actions]

Thank you for opening this pull request.

You can find the built site at this link.

Deployment Info:

• Pull Request ID: 1193
• Deployment SHA: 83608d4ad199dadee2bcc918ef82a7fd71e8af58
  (The Deployment SHA refers to the latest commit hash the docs were built from)

Note: It may take several minutes for updates to this pull request to be reflected on the deployed site.

[EmilianoG-byte]

Initial draft from last week:

DRAFT:

• Definition of a tensor as an n-dimensional array. Show notation with n indices, stating that it belongs to C^{d1,...,dn}. Define rank, index, dimension (mention how these terms are sometimes used (wrongly?) interchangeably in literature).
• Graphical notation. Mention that there exist certain representations in the literature that allow to represent properties of the tensors (e.g. symmetry, orthogonality). In our case, we can adhere to a general circle.
• Specific examples used in a day-to-day: scalars, vectors, matrices. Mention that for quantum states, we can adopt the convention that the legs in one direction mean that the state belongs to one Hilbert space, and the legs to the other side to the dual space.
• CODE: include code using numpy creating a >2 dimensional array.

• Show the matrix multiplication in terms of summation over indices, then using the diagrammatic representation. This results in another rank 2 tensor (matrix)
• Analagously, we can represent matrix-vector multiplication resulting in a rank 1 tensor (vector). Just as we expected!
• We can generalize this concept to tensors. This is done by summing over repeated indices (just as in einstein convention - external link for it) resulting in another tensor made up of the open legs of all the tensors together.
  In diagrammatic notation, this is simply sticking together legs with same indices! (show nice diagram with >3 tensors). We have just formed a network of tensors, i.e. a Tensor Network!
• CODE: Talking about einstein convetion, we can perform this contraction of tensors using np.einsum.

• Mention that the resulting tensor network doesn't change but the way we arrive to the final tensor affects how expensive it is to get there.
• Show how can we can calculate the complexity of a contraction by means of a simple example using 2 matrices (rank 2 tensors): dimension_contracted x (dimensions_open).
• Intuition behind: we perform one operation (contraction) and repeat many times to "populate" the resulting tensor (dimension_open1 x dimension_open2). Show the equation with indices.
• Show an example with at least three tensors where they all have different dimensions. Walk through it showing that choosing to contract two indices (the ones with lower dimensions) results in a worst computational complexity than contracting other ones (the ones with higher dimensions).

Very nice source with visual explanations that we can cite: https://www.math3ma.com/blog/matrices-as-tensor-network-diagrams

[Qottmann]

hey @EmilianoG-byte @Shiro-Raven how are things coming along? Please let me know when you have a first draft that is ready for review (don't forget to self-review first) :)