The ITensor Software Library for Tensor Network Calculations

1. The Julia version is easier for users to get started than the C++ version.
2. Good documentation and user guide.

This paper is basically a documentation/user guide for the Juila port of ITensor library; therefore plenty of examples are given. However, the technical details and benchmarks are not clearly presented in the document. In particular, a simple benchmark against the C++ version will provide crucial information for future users' decision.

1) Paper is well written and very useful as a first introduction with this library, as it gradually builds up complexity
2) The software discussed in this paper is easy to install and intuitive to use
3) The paper illustrated the most relevant/useful aspects of this software library using clear and instructive examples
4) Paper also discusses parts of the design philosophy and some aspects of the underlying implementation without becoming a complete implementation reference
5) The C++ version of the software is well accepted within the computation physics community for performing DMRG calculations

1) The paper is sometimes a bit one-sided; e.g. while the intelligent indices certainly have many advantages, as advertised in the paper, there can also be downsides which are not at all addressed.
2) In a similar vain, there is sometimes little context (e.g. a discussion of similar or related software) or a lack of references to underlying theory (e.g. the use of quantum numbers or symmetries in tensor networks)
3) There are no benchmarks or other illustrations to substantiate claims of high efficiency, i.e. neither with respect to alternative libraries (TenPy, Uni10, ... ), nor between the Julia and C++ version of this library

This manuscript provides a user introduction to the ITensor(s.jl) library, a library for using existing tensor network algorithms (mostly DMRG) or on top of which new tensor network algorithms can be developed. The main text focusses on the recently developed Julia version of the library in the examples, but the C++ version is briefly discussed in the appendix. The latter has already a long history and is well accepted within the community, this is also explicitly discussed in Section 11 of the manuscript. As indicated in the "strengths" bullet points, the paper is well written and provides a useful introduction to the library for new users, while at the same time discussing some of the underlying design philosophy, both in the user interface and the implementation.

The use of intelligent indices which are hidden from the user after the construction phase of the tensor is strongly advertised because of its benefits, namely its robustness against programming errors and the easy of specifying tensor contractions. However, there can also be downsides in comparison to alternative interfaces (the Einstein summation convention used in many libraries among which Numpy's einsum, or the more specific NCON convention that is popular among certain tensor network groups), which are not at all discussed. I think about the fact that the specific contraction that a certain block of code computes (e.g. a typical tensor network diagram in a PEPS or MERA simulation) is completely dependent on the specific input arguments and hard/impossible to assess from the contraction code itself. Furthermore, it is not clear if the intelligent index convention provides flexibility towards specifying the contraction order? The importance of contraction order and the many recent developments thereof are also completely glossed over.

Furthermore, to meet the acceptance criteria of SciPost Physics Codebases, it seems the following aspects should be addressed:
1) "...and highlight its added value as compared to existing software"
2) "Benchmarking tests must be provided."
Currently, no discussion of alternative software nor any absolute or relative benchmarks are provided in the manuscript.

A final smaller comment is that, unlike most of the rest of the manuscript, section 9.3 is somewhat fuzzy and hard to parse. This section seems to go into specific technical details (names of data structures etc) of the implementation which are mostly skimmed over throughout the rest of the manuscript.

Address the specific acceptance criteria of SciPost Physics Codebases ( https://scipost.org/SciPostPhysCodeb/about#criteria)

1) "...and highlight its added value as compared to existing software"
2) "Benchmarking tests must be provided."

If possible

3) Provide some discussion on alternative interface or design choices and their pros and cons.
4) Improve clarity of Section 9.3

1. Easy to install.
2. Well documented.
3. The userguide is easy to read and provides the background and examples necessary to get started.
3. The abstract high-level interface for contracting tensors is very intuitive and easy to use and already field-tested from the C++ version of the library.
4. The library makes good and proper use of Julia language features, in particular multiple-dispatch.

This work introduces the port of the ITensor Software library to the Julia programming language. The C++ version is already well established in the community and has been used in many works, some of which are highlighted in the presented userguide. With the rising popularity of the Julia programming language, I have no doubt that the Julia version of ITensor will also find many applications.
As illustrated by the strenght list aboce, the ITensor Software libary is of excellent quality and this work is basically ready for publication.

Personally, I would love to see some more higher-level algorithms like infinite DMRG/VUMPS/TEBD/TDVP/... for MPS and/or even PEPS codes, but (at least right now) this seems to go beyond the scope of the library. (To be fair, as developer of TeNPy I might also be a bit biased...). Given the plethora of such algorithms, it is essential to have a library like ITensor defining the basic tensor network tools, such that these individual algorithms can easily be coded up and new approaches can be tried.

Before fully recommending the publication, I have only a minor concern: benchmark tests are listed in the acceptance criteria for Scipost Physics Codebases. The folder /benchmarks of the code seems to include benchmark tests, and I even found a github action running them, but I can't find where the results are collected? Alternatively, could you provide a little bit of information how to run those benchmarks?
I would also be curious to see a speed comparison of the C++ vs. Julia version.

1. Can the authors provide a bit of information how to run the benchmark or provide results?
2. The /examples folder of the repository is somewhat hidden if the users ends up installing ITensor with the julia package manager (as recommended) and only reads the online documentation. I think just including those examples to the online documentation would benefit their use.
3. Two minor corrections in the user guide:
- second-to-last paragraph of Sec. 7.2:
"... orthogonal *these* previous ones"
- Second paragraph of Sec. 8.2:
"where note that ..."
The whole sentence is somewhat redundant, as this has already been mentioned in Sec. 2.3.