Format code examples in docs

Author: mtfishman

docs/src/computing_properties.md

@@ -7,12 +7,12 @@ using ITensors: Op
 using LinearAlgebra: norm
 using NamedGraphs.NamedGraphGenerators: named_grid
 
-g   = named_grid((4,))
-s   = siteinds("S=1/2", g)
+g = named_grid((4,))
+s = siteinds("S=1/2", g)
 phi = normalize(random_ttn(s; link_space = 2))
 psi = normalize(random_ttn(s; link_space = 2))
-x   = normalize(random_ttn(s; link_space = 2))
-y   = normalize(random_ttn(s; link_space = 2))
+x = normalize(random_ttn(s; link_space = 2))
+y = normalize(random_ttn(s; link_space = 2))
 v = first(vertices(psi))
 ```
 
@@ -24,23 +24,23 @@ contracting the combined bra–ket network. The default algorithm is **belief pr
 exact contraction (only practical for small networks or trees).
 
 ```@example main
-z = inner(phi, psi)               # ⟨ϕ|ψ⟩
-n = norm(psi)                     # √⟨ψ|ψ⟩
+z = inner(phi, psi)  # ⟨ϕ|ψ⟩
+n = norm(psi)  # √⟨ψ|ψ⟩
 ```
 
 For numerically large tensor networks where the inner product would overflow, use the
 logarithmic variant:
 
 ```@example main
-logz = loginner(phi, psi)         # log(⟨ϕ|ψ⟩) (numerically stable)
+logz = loginner(phi, psi)  # log(⟨ϕ|ψ⟩) (numerically stable)
 ```
 
 For `TreeTensorNetwork`, specialised exact methods exploit the tree structure directly
 without belief propagation:
 
 ```@example main
-z = inner(x, y)      # ⟨x|y⟩ via DFS contraction
-n = norm(psi)        # uses ortho_region if available for efficiency
+z = inner(x, y)  # ⟨x|y⟩ via DFS contraction
+n = norm(psi)  # uses ortho_region if available for efficiency
 ```
 
 ```@docs; canonical=false
@@ -57,8 +57,8 @@ ITensors.inner(::ITensorNetworks.AbstractTreeTensorNetwork, ::ITensorNetworks.Ab
 For `TreeTensorNetwork`, the normalisation is applied directly at the orthogonality centre.
 
 ```@example main
-psi = normalize(psi)                       # exact (default)
-psi_bp = normalize(psi; alg = "bp")       # belief-propagation (for large loopy networks)
+psi = normalize(psi)  # exact (default)
+psi_bp = normalize(psi; alg = "bp")  # belief-propagation (for large loopy networks)
 ```
 
 ```@docs; canonical=false
@@ -97,8 +97,8 @@ available. The operator name is passed as the **first** argument (note the diffe
 argument order from the general form above):
 
 ```@example main
-sz = expect("Sz", psi)                                  # all sites
-sz = expect("Sz", psi; vertices = [(1,), (3,)])         # selected sites
+sz = expect("Sz", psi)  # all sites
+sz = expect("Sz", psi; vertices = [(1,), (3,)])  # selected sites
 ```
 
 This is more efficient than the belief propagation approach for tree-structured networks

docs/src/itensor_networks.md

@@ -31,7 +31,7 @@ using NamedGraphs.NamedGraphGenerators: named_grid
 
 # 3×3 square-lattice tensor network
 g = named_grid((3, 3))
-s = siteinds("S=1/2", g)            # one spin-½ Index per vertex
+s = siteinds("S=1/2", g)  # one spin-½ Index per vertex
 
 # Zero-initialized, bond dimension 2
 ψ = ITensorNetwork(s; link_space = 2)
@@ -47,12 +47,12 @@ When you already have `ITensor`s in hand, edges are inferred automatically from
 indices:
 
 ```@example main
-i, j, k = Index(2,"i"), Index(2,"j"), Index(2,"k")
-A, B, C  = ITensor(i,j), ITensor(j,k), ITensor(k)
+i, j, k = Index(2, "i"), Index(2, "j"), Index(2, "k")
+A, B, C = ITensor(i, j), ITensor(j, k), ITensor(k)
 
-tn = ITensorNetwork([A, B, C])                     # integer vertices 1, 2, 3
-tn = ITensorNetwork(["A","B","C"], [A, B, C])       # named vertices
-tn = ITensorNetwork(["A"=>A, "B"=>B, "C"=>C])       # from pairs
+tn = ITensorNetwork([A, B, C])  # integer vertices 1, 2, 3
+tn = ITensorNetwork(["A", "B", "C"], [A, B, C])  # named vertices
+tn = ITensorNetwork(["A" => A, "B" => B, "C" => C])  # from pairs
 ```
 
 ```@docs; canonical=false
@@ -63,14 +63,14 @@ ITensorNetworks.ITensorNetwork
 
 ```@example main
 v = (1, 2)
-T = ψ[v]                  # ITensor at vertex (1,2)
-ψ[v] = T                  # replace tensor at a vertex
-vertices(ψ)               # all vertex labels
-edges(ψ)                  # all edges
-neighbors(ψ, v)           # neighbouring vertices of v
-nv(ψ), ne(ψ)             # vertex / edge counts
-siteinds(ψ)               # IndsNetwork of site (physical) indices
-linkinds(ψ)               # IndsNetwork of bond (virtual) indices
+T = ψ[v]  # ITensor at vertex (1,2)
+ψ[v] = T  # replace tensor at a vertex
+vertices(ψ)  # all vertex labels
+edges(ψ)  # all edges
+neighbors(ψ, v)  # neighbouring vertices of v
+nv(ψ), ne(ψ)  # vertex / edge counts
+siteinds(ψ)  # IndsNetwork of site (physical) indices
+linkinds(ψ)  # IndsNetwork of bond (virtual) indices
 ```
 
 ## Adding Two `ITensorNetwork`s
@@ -96,9 +96,9 @@ ITensorNetworks.add(::ITensorNetworks.AbstractITensorNetwork, ::ITensorNetworks.
 A single bond (edge) of any `ITensorNetwork` can be truncated by SVD:
 
 ```@example main
-edge = (1,2) => (1,3)
-ψ12 = truncate(ψ12, (1,2) => (1,3))   # truncate the bond between vertices (1,2) and (1,3)
-ψ12 = truncate(ψ12, edge)              # or pass an AbstractEdge directly
+edge = (1, 2) => (1, 3)
+ψ12 = truncate(ψ12, (1, 2) => (1, 3))  # truncate the bond between vertices (1,2) and (1,3)
+ψ12 = truncate(ψ12, edge)  # or pass an AbstractEdge directly
 ```
 
 Truncation parameters (`cutoff`, `maxdim`, `mindim`, …) are forwarded to `ITensors.svd`.

docs/src/solvers.md

@@ -21,13 +21,13 @@ using ITensors: OpSum
 using NamedGraphs.NamedGraphGenerators: named_comb_tree
 
 # Build a Heisenberg Hamiltonian on a comb tree
-g  = named_comb_tree((3, 2))
-s  = siteinds("S=1/2", g)
+g = named_comb_tree((3, 2))
+s = siteinds("S=1/2", g)
 H = let h = OpSum()
     for e in edges(g)
         h += 0.5, "S+", src(e), "S-", dst(e)
         h += 0.5, "S-", src(e), "S+", dst(e)
-        h +=      "Sz", src(e), "Sz", dst(e)
+        h += "Sz", src(e), "Sz", dst(e)
     end
     ttn(h, s)
 end

docs/src/tree_tensor_networks.md

@@ -29,16 +29,16 @@ using NamedGraphs.NamedGraphGenerators: named_comb_tree
 g = named_comb_tree((3, 2))
 sites = siteinds("S=1/2", g)
 
-psi = ttn(sites)              # zero-initialised
-psi = ttn(v -> "Up", sites)   # product state
+psi = ttn(sites)  # zero-initialised
+psi = ttn(v -> "Up", sites)  # product state
 
 # Random TTN
 psi = random_ttn(sites; link_space = 2)
 
 # 1D MPS
 s1d = siteinds("S=1/2", 6)
-mps_state = mps(v -> "Up", s1d)   # product MPS
-mps_state  = random_mps(s1d; link_space = 2)
+mps_state = mps(v -> "Up", s1d)  # product MPS
+mps_state = random_mps(s1d; link_space = 2)
 ```
 
 ```@docs; canonical=false
@@ -56,8 +56,8 @@ orthogonality region. Use the `TreeTensorNetwork` constructor to convert a plain
 gauge metadata when you need a plain network again.
 
 ```@example main
-itn = ITensorNetwork(psi)                  # TTN → ITensorNetwork
-psi = TreeTensorNetwork(itn)               # ITensorNetwork → TTN
+itn = ITensorNetwork(psi)  # TTN → ITensorNetwork
+psi = TreeTensorNetwork(itn)  # ITensorNetwork → TTN
 ```
 
 ```@docs; canonical=false
@@ -72,9 +72,9 @@ tree edges. Truncation parameters (e.g. `cutoff`, `maxdim`) are forwarded to the
 factorisation step.
 
 ```@example main
-g = named_comb_tree((3,1))
-sites = siteinds("S=1/2",g)
-A  = ITensors.random_itensor(only(sites[(1,1)]), only(sites[(2,1)]), only(sites[(3,1)]))
+g = named_comb_tree((3, 1))
+sites = siteinds("S=1/2", g)
+A = ITensors.random_itensor(only(sites[(1, 1)]), only(sites[(2, 1)]), only(sites[(3, 1)]))
 ttn_A = ttn(A, sites)
 ```
 
@@ -93,13 +93,13 @@ eigenvalue problems numerically efficient and stable.
 The current orthogonality center is tracked by the `ortho_region` field.
 
 ```@example main
-v  = collect(vertices(psi))[1]
+v = collect(vertices(psi))[1]
 v1 = collect(vertices(psi))[1]
 v2 = collect(vertices(psi))[2]
 vs = [v]
-psi = orthogonalize(psi, v)         # QR-sweep to put ortho center at vertex v
+psi = orthogonalize(psi, v)  # QR-sweep to put ortho center at vertex v
 psi = orthogonalize(psi, [v1, v2])  # two-site center (for nsites=2 sweeps)
-ortho_region(psi)                   # query current ortho region (returns an index set)
+ortho_region(psi)  # query current ortho region (returns an index set)
 ```
 
 ```@docs; canonical=false
@@ -137,11 +137,11 @@ dimension equal to the **sum** of the two inputs, and can be recompressed with `
 
 ```@example main
 psi1, psi2 = psi, psi
-psi3 = psi1 + psi2             # or add(psi1, psi2)
+psi3 = psi1 + psi2  # or add(psi1, psi2)
 psi3 = truncate(psi3; cutoff = 1e-10, maxdim = 50)
 
-2.0 * psi                      # scalar multiplication
-psi / norm(psi)                # manual normalisation
+2 * psi  # scalar multiplication
+psi / norm(psi)  # manual normalisation
 ```
 
 ```@docs; canonical=false