Latest Build

Example Scripts

• examples/README show download
This repository contains examples for the SymMPS code, which is included in the SciPAL toolbox.

• examples/create-spin-pb-t-inf.sh show download
# This script serves as automaziation to create an infinite temperature state for a system with restored U(1)-quantum number conservation. Ordering of the lattice sites is by default phys-aux-bath-aux and defines one overall lattice site. Therefore the overall system size is 4*L with L being the number of physical sites. The target state is written into t-inf-paba.symmps into the current working directory
# Input parameter
## $1: path to directory containing symmps-build
## $2: path to directory containing models git
## $3: number of physical lattice sites
## $4: local dimension

export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

EXEC_DIR=$1
PRM_DIR=$2
L=$3
d=$4

LAT="lattice-t-inf.real"
MPS="t-inf-pba.symmps"

# clean-up
rm $LAT
rm $MPS

# abort if error occurs
set -eu

# we need an empty lattice to create initial state
$EXEC_DIR/link/sym-create-lattice -b custom -g Sz -L $(( 4*L )) -d $d -t 0 -o $LAT

# create anti-neel mps
$EXEC_DIR/link/sym-create-mps -i $LAT -t anti-neel -o $MPS

# next flip spins properly to create state of the form \prod_j |\uparrow,\uparrow>_p(j) |\downarrow,\downarrow>_b(j)
FLIPDOWN="Sminus"
FLIPUP="Splus"
for n in $(seq 1 $(( d-2 ))); do FLIPDOWN="${FLIPDOWN}*Sminus"; FLIPUP="${FLIPUP}*Splus"; done
for SITE in $(seq 0 $(( L-1 )))
do
$EXEC_DIR/link/sym-apply-mpo -i $LAT -O $FLIPDOWN@$(( 4*SITE+1 )) -S $MPS -D $MPS -RV 1
$EXEC_DIR/link/sym-apply-mpo -i $LAT -O $FLIPUP@$(( 4*SITE+2 )) -S $MPS -D $MPS -RV 1
done

for SITE in $(seq 0 $(( L-1 )))
do
$EXEC_DIR/link/sym-create-mpo --prm_dir $PRM_DIR -i $LAT -r Tneq0/spin -m gates.prm -M entangle_pb_d${d} -p "j=${SITE}" -n add_bell_pair -o $LAT
$EXEC_DIR/link/sym-apply-mpo -i $LAT -O add_bell_pair -S $MPS -D $MPS -RV 9
done

• examples/create_state_and_apply_perturbation.sh show download
# This script's purpose is to demonstrate and explain the following functionalities of the SciPAL SymMps toolkit
# 1. create a spin-1/2 lattice with L=100 Spins
# 1a. create a fully polarized state |\psi> = |\uparrow \cdots \uparrow>
# 1b. create a random near-vacuum state by repeated application of \sum_{i}c_i S^+_i |\downarrow \cdots \downarrow> with random weights c_i
# 2. apply a local perturbation to a state flipping a spin at lattice site i=50
#
# Dependencies:
# none
#
# Input arguments:
# path to compiled SciPAL-SymMps toolkit
# type of created state (full|vacuum)

# Force OMP-/MKL thread numbers to be one otherwise thread spawning will slow down simulations
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

# clear log folder to avoid unnecessary blow-up of output files (each executable will append its output onto an existing output file)
rm log/*.output

# remove already existing lattice files to avoid loading of lattice data which we may not want to have
rm lattice.*

# We exit script if an executable returns with error code
set -eu

# just define a shortcut for the passed location of the toolbox ($1 must only define a path to the folder of the tool-kit containing bin (compiled binaries) and link (symbolic links with some reasonable names), e.g., in any singularity container you may pass /opt/symmps/gnu or /opt/symmps/mkl
EXEC_DIR=$1

# specify type of created state
# TYPE=full : a fully polarized state |\uparrow \cdots \uparrow>
# TYPE=vacuum : a random near-vacuum state by repeated application of \sum_{i}c_i S^+_i |\downarrow \cdots \downarrow> with random weights c_i
TYPE=$2

# create a lattice file containing defining a subspace of tensor-product Hilbert space with the following shortoptions:
# 1. -L defines number of lattice sites, i.e., copies of local Hilbert spaces
# 2. -F defines fundamental datatype of the Hilbert space to be double
# 3. -b defines used basis set, here we choose 'custom' basis set which contains the Spin-Basis, to get more information on any basis set run sym-create-lattice -b -G
# 4. -d defines dimension of the local Hilbert space, we want to describe S=1/2 degrees of freedom thus d=2
# 5. -g defines local symmetry generator which is used to construct the global symmetry generator in this case S^z=\sum_{i=1}^{L}S^z_i, note that only the local operator needs to be specified and since they all share the same representation in each individual local Hilbert space the index 'i' is dropped
# 6. -t defines target-symmetry sector for the global symmetry generator, in this case S^z=0
# 7. -o defines output filename for the created lattice (there is no particular naming convention, however you may want to encode the fundamental datatype in the filename)
case $TYPE in
full)
${EXEC_DIR}/link/sym-create-lattice -L 100 -F d -b custom -d 2 -g Sz -t 50.0 -o lattice.real
;;
vacuum)
${EXEC_DIR}/link/sym-create-lattice -L 100 -F d -b custom -d 2 -g Sz -t 0.0 -o lattice.real
;;
esac

# create a state with the following shortoptions:
# 1. -i defines lattice input file containing Hilbert space and local basis
# 2. -t defines type of created mps, choose 'full' means that all sites are initialized in eigenstate of the local symmetry generators with maximum eigenvalue, i.e., s_i=1/2
# 3. -o defines dest state filename
${EXEC_DIR}/link/sym-create-mps -i lattice.real -t $TYPE -o state.symmps

# apply local perturbation by flipping spin at site i=50 with the following shortoptions:
# 1. -i defines lattice input file containing Hulbert space and local basis
# 2. -S defines input file for source state
# 3. -D defines output file for target state
# 4. -O defines MPO identifier, in case you want to apply an MPO from passed lattice insert MPO-identifier here, we want to apply only a local perturbation which can be done by specifying the local operator and the lattice on which it should act with syntax @, the MPO is then created automatically
# 5. -m defines application method, here we choose variational application method which first performs a warmup sweep and then variationally minimizes the l2-distance to the target state |\psi>
# 6. -n if type is variational this defines the max. number of sweeps during variational optimization towards the target state
# 7. -e if type is variational this defines the escape precision which is given by the change in the l2-norm || |\psi> - |\phi> || between the two last sweeps where |\phi> is the optimized state
# 8. -d defines the maximum discarded weight for the target state
# 9. -w defines the maximum bond dimension of the target state
${EXEC_DIR}/link/sym-apply-mpo -i lattice.real -S state.symmps -D excited.symmps -O 'Sminus@50' -m variational -n 10 -e '1e-12' -d 1e-12 -w 100

• examples/groundstate.sh show download
# This script's purpose is to demonstrate and explain the following functionalities of the SciPAL SymMps toolkit
# 1. Create a lattice file defining a S=0-subspace of a tensor-product Hilbert space with L=100 Spin-1/2 degrees of freedoms (dimension of each local Hilbert space is d=2)
# 2. Create an MPO from a finite states machine which defines a (generic) Heisenberg model and store the MPO in another lattice file
# 3. Run a ground-state search to find the MPS describing the groundstate of the MPO created above
#
# Dependencies:
# none
#
# Input arguments:
# path to compiled SciPAL-SymMps toolkit
# path to directory containing FSMs

# Force OMP-/MKL thread numbers to be one otherwise thread spawning will slow down simulations
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

# clear log folder to avoid unnecessary blow-up of output files (each executable will append its output onto an existing output file)
rm log/*.output

# remove already existing lattice files to avoid loading of lattice data which we may not want to have
rm lattice.*

# We exit script if an executable returns with error code
set -eu

# just define a shortcut for the passed location of the toolbox ($1 must only define a path to the folder of the tool-kit containing bin (compiled binaries) and link (symbolic links with some reasonable names), e.g., in any singularity container you may pass /opt/symmps/gnu or /opt/symmps/mkl
EXEC_DIR=$1

# just define a shortcut for the passed location of the parameter folder in which the finite states machines are defined
PRM_DIR=$2

# create a lattice file containing defining a S=0-subspace of tensor-product Hilbert space with the following shortoptions:
# 1. -L defines number of lattice sites, i.e., copies of local Hilbert spaces
# 2. -F defines fundamental datatype of the Hilbert space to be double
# 3. -b defines used basis set, here we choose 'custom' basis set which contains the Spin-Basis, to get more information on any basis set run sym-create-lattice -b -G
# 4. -d defines dimension of the local Hilbert space, we want to describe S=1/2 degrees of freedom thus d=2
# 5. -g defines local symmetry generator which is used to construct the global symmetry generator in this case S^z=\sum_{i=1}^{L}S^z_i, note that only the local operator needs to be specified and since they all share the same representation in each individual local Hilbert space the index 'i' is dropped
# 6. -t defines target-symmetry sector for the global symmetry generator, in this case S^z=0
# 7. -o defines output filename for the created lattice (there is no particular naming convention, however you may want to encode the fundamental datatype in the filename)
${EXEC_DIR}/link/sym-create-lattice -L 100 -F d -b custom -d 2 -g Sz -t 0.0 -o lattice.real

# create another lattice file containing heisenberg hamiltonian from a finite states machine (FSM) with the following
# longoptions:
# 1. --prm_dir defines root directory of the parameter folder in which finite size machines are defined
# shortoptions:
# 1. -i defines lattice input file specifying the Hilbertspace on which the MPO is constructed
# 2. -r defines relative path of the file containing the FSM with respect to the value set in prm_dir
# 3. -m defines model filename cpontaining the desired FSM (default value is models.prm so collecting FSMs in files with these names you can drop this option)
# 4. -M defines FSM identifier in model file from which MPO is constructed
# 5. -p sets parameter for FSM used to create MPO
# 6. -o defines output filename for a lattice containing the created MPO
# 7. -n defines identifier of created MPO under which it is stored in output lattice-file
${EXEC_DIR}/link/sym-create-mpo --prm_dir $PRM_DIR -i lattice.real -r Teq0/spin/1D/ -m models.prm -M heisenberg -p 'J=1.0|Jz=1.0' -o lattice.mpo.real -n H

# perform groundstate search where a warmup sweep is employed to create an MPS (you can also define MPS input file which will cause the groundstate search to start running on this state) with the following shortoptions:
# 1. -i defines lattice input file containing MPO whose groundstate is to be determined
# 2. -s defines maximally permitted number of sweeps (a single left-to-right or right-to-left sweep counts as one full sweep) after which groundstate search is cancelled if not converged
# 3. -d defines maximally permimtted discarded weight during groundstate search, can be specified for each sweep individually by passing comma-separated list, last value in list is used for the remaining sweeps
# 4. -w defines maximally permitted number of bond states kept during groundstate search, can be specified for each sweep individually by passing comma-separated list, last value in list is used for the remaining sweeps
# 5. -e defines global convergence threshold ε, if relative overall energy gain during in last completed sweep is below ε than groundstate search is exited
# 6. -N defines maximally permitted Krylov basis size in local Lanczos-Solver, can be specified for each sweep individually by passing comma-separated list, last value in list is used for the remaining sweeps
# 7. -E defines local convergence threshold of local Lanczos-Solver, can be specified for each sweep individually by passing comma-separated list, last value in list is used for the remaining sweeps
# 8. -W this flag activates output of states after every sweep into files gs/state_after_sweep_.symmps
# 9. -V increases verbosity level to also get some timing as well as convergence information during the local Lanczos-optimizations
${EXEC_DIR}/link/sym-groundstate-search -i lattice.mpo.real -s 20 -e 1e-08 -d 1e-08 -E 1e-10 -S "-s 2 -w 10 -N 3 | -s 10 -w 40 -N 5 -e 1e-04 | -w 200 -N 7" -c SDD -WV 11

• examples/meas_groundstate.sh show download
# This script's purpose is to demonstrate and explain the following functionalities of the SciPAL SymMps tool-kit
# 1. Perform measurements of local and global observables on states that have been created during a groundstate search
# 2. Employ functionality of sym-info executable to extract entanglement entropy of states that have been created during a groundstate search
#
# Dependencies:
# run demonstration script 'groundstate.sh' in same directory in first place to create MPS files, lattice and MPO
#
# Input arguments:
# path to compiled SciPAL-SymMps toolkit
#
# General remarks on called executables
#
# sym-scalar-product:
# datafiles generated by this executable always contain the tag in its first column and the states norm in its second column


# Force OMP-/MKL thread numbers to be one otherwise thread spawning will slow down simulations
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

# clear log files to avoid unnecessary blow-up of output files (each executable will append its output onto an existing output file)
rm log/sym-scalar-product.output
rm log/sym-info.output

# We exit script if an executable returns with error code
set -eu

# just define a shortcut for the passed location of the toolbox ($1 must only define a path to the folder of the tool-kit containing bin (compiled binaries) and link (symbolic links with some reasonable names), e.g., in any singularity container you may pass /opt/symmps/gnu or /opt/symmps/mkl
EXEC_DIR=$1

# We do a while loop increasing a counter variable $N_SWEEP and looping through all files $GS_DIR/state_after_sweep_${N_SWEEP}.symmps
N_SWEEP=0
SRC_FILE=gs/state_after_sweep_${N_SWEEP}.symmps
while [ -f $SRC_FILE ]
do
# we distinguish between the situation of reading the first MPS datafile (N_SWEEP=0) of any other, in the first case we reset all output files by adding -r shortoption
if [[ $N_SWEEP -eq 0 ]]
then
# calculate van-Neumann entanglement entropy for current MPS datafile, create datafile entanglement.symmps and write results into it using shortoptions:
# 1. -r force recreation of output file
# 2. -i define input file on which sym-info operates
# 3. -I define info type which is to be extracted from input file, in this case set to entanglement, note that by default van-Neumann entropy is calculated (1st Renyi entropy), if you want to access other renyi entropies set the longoption n_renyi to any value, e.g.: add longoption '--n_renyi 2' for calculating second renyi entropy
# 4. -O define output type of info executable, in this case dump output to file
# 5. -o define output file in which data is written
$EXEC_DIR/link/sym-info -ri $SRC_FILE -I entanglement -O file -o entanglement
# measure , and of current MPS datafile, recreating datafiles using shortoptions:
# 1. -r force recreation of output files
# 2. -n normalize scalarproduct by current MPS norm, in this case this is not absolutely necessary since states are proper normalized during Lanczos groundstate search
# 3. -i define lattice file which needs to contain tensor product Hilbert space (and thereby also local basis operators) and MPO with which groundstate search was performed
# 4. -t define a tag which is used to label dataset in datafile, here we label the data by the value of N_SWEEP
# 5. -O define MPO(s) whose expectation value(s) is/are to be calculated, can be comma-separated list, specified MPO(s) must have been created into passed lattice input-file before
# 6. -o define local operator(s) whose expectations value(s), can be comma-separated list with entries being arbitrary products of local operators
# 7. -k define MPS file which is used to calculate expectation value, if shortoption bra is also passed scalar product is performed with bra/ket being obtained from MPS being passed in shortoptions b/k respectively
# 8. -d define output directory, global observables (MPO expectation values) are written into file global_operators_* while local observables with id are written into files local_operators/_* and * is wildcard for real/imag
$EXEC_DIR/link/sym-scalar-product -rni lattice.mpo.real -t $N_SWEEP -O 'H' -o 'Sz,Sz*Sz' -k $SRC_FILE -d gs
else
# calculate van-Neumann entanglement entropy for current MPS datafileand append results to datafile entanglement.symmps it using shortoptions:
# 1. -i define input file on which sym-info operates
# 2. -I define info type which is to be extracted from input file, in this case set to entanglement, note that by default van-Neumann entropy is calculated (1st Renyi entropy), if you want to access other renyi entropies set the longoption n_renyi to any value, e.g.: add longoption '--n_renyi 2' for calculating second renyi entropy
# 3. -O define output type of info executable, in this case dump output to file
# 4. -o define output file in which data is written
$EXEC_DIR/link/sym-info -i $SRC_FILE -I entanglement -O file -o entanglement
# measure , and of current MPS datafile, recreating datafiles using shortoptions:
# 1. -n normalize scalarproduct by current MPS norm, in this case this is not absolutely necessary since states are proper normalized during Lanczos groundstate search
# 2. -i define lattice file which needs to contain tensor product Hilbert space (and thereby also local basis operators) and MPO with which groundstate search was performed
# 3. -t define a tag which is used to label dataset in datafile, here we label the data by the value of N_SWEEP
# 4. -O define MPO(s) whose expectation value(s) is/are to be calculated, can be comma-separated list, specified MPO(s) must have been created into passed lattice input-file before
# 5. -o define local operator(s) whose expectations value(s), can be comma-separated list with entries being arbitrary products of local operators
# 6. -k define MPS file which is used to calculate expectation value, if shortoption bra is also passed scalar product is performed with bra/ket being obtained from MPS being passed in shortoptions b/k respectively
# 7. -d define output directory, global observables (MPO expectation values) are written into file global_operators_* while local observables with id are written into files _* and * is wildcard for real/imag
$EXEC_DIR/link/sym-scalar-product -ni lattice.mpo.real -t $N_SWEEP -O 'H' -o 'Sz,Sz*Sz' -k $SRC_FILE -d gs
fi

# increase counter variable and set next filename
N_SWEEP=$(( N_SWEEP+1 ))
SRC_FILE=gs/state_after_sweep_${N_SWEEP}.symmps
done

• examples/meas_teo.sh show download
# This script can be run in parallel to the time-evolution script (run_teo.sh) in the symmps-example repository
# Input parameter is the directory to the path where the executables are located

EXEC_DIR=$1

DT=0.1
T_START=0
T_END=20

# do some cleanups
rm log/sym-scalar-product.*

#measure Sz-expectation values, waiting until the next time-step has been written
for TIME in $(LANG=en seq -f %f $( echo ${T_START}+${DT} | bc ) ${DT} ${T_END})
do
STATE="teo/state."${TIME}
while [ ! -e ${STATE} ]
do
echo "waiting for file ${STATE}"
sleep 5
done
${EXEC_DIR}/link/sym-scalar-product -i lattice.complex -t ${TIME} -O '' -o 'Sz' -k "${STATE}" -d teo
done

• examples/run_teo.sh show download
# This is an example script for calculating the time-evolution of an anti-neel state (|down,up,down,up,...>) under XXZ-Heisenberg Hamiltonian using W-II stepper for initial growth of bond dimension and then switching over to a tdvp 2-site stepper
# Input parameter are
# $1: path to executable directory
# $2: path to model directory (use path to your models-git which is at the same location as the executables) containing besides others a model-file which declares a Heisenberg Hamiltonian
# $3: system size, default value is 40
# $4: value of anisotropy parameter J, default is J=1.0
# $5: value of sz-interaction Jz, default is Jz=1.0
# $6: value of longitudinal magn. field hz, default is hz=0.0

# at first initialize default values
L=40
J=1.0
Jz=1.0
hz=0.0

# read input and update model parameters if passed
case $# in
3)
L=$3
;;
4)
L=$3
J=$4
;;
5)
L=$3
J=$4
Jz=$5
;;
6)
L=$3
J=$4
Jz=$5
hz=$6
;;
0|1)
echo "invalid number of input parameter, at least path to executable directory and model-file must be specified"
exit 1
;;
*)
echo "max. number of interpreted input parameters is 6, I'm going to ignore the remaining" $(( $#-6 )) "parameters"
esac

EXEC_DIR=$1
PRM_DIR=$2

# force to use only one thread
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

# do some clean-ups
rm -rf log/*
rm -rf teo/*
rm lattice.*
rm *.symmps

# now create two lattices with real as well as complex fundamental datatype
# short option -F defines fundamental datatype of lattice
# short option -b defines basis system used for this lattice (default is custom, containing all basis sets with only one conserved quantum number)
# short option -g defines symmetry generator for this lattice (default is Sz but can be set to any set of local operators, consistent with the number of conserved quantities supprted by the chosen basis type. Note, that in order to get information about the common symmetry generators for each basis type by running sym-create-lattice with short-options -b BASISTYPE -G where BASISTYPE is a valid local basis)
# short option -L specifies the numebr of lattice sites
# short option -d specifies the dimension of the local operators generating the basis at each lattice site (default is 2, but can be set to larger values which then are combined properly with the chosen local basis type, for instance S=1 systems can be realized by setting local dim to 3)
# short option -o defines output file in which lattice is stored
$EXEC_DIR/link/sym-create-lattice -F d -b custom -g Sz -L $L -d 2 -o lattice.real
$EXEC_DIR/link/sym-create-lattice -F c -b custom -g Sz -L $L -d 2 -o lattice.complex

# we proceed by constructing the Heisenberg hamiltonian into the complex lattice (we use the complex latticee because the time-evolution is complex for obvious reasons)
# short option -i defines lattice input file specifying the Hilbertspace on which the MPO is constructed
# short option -r defines relative path of the file containing the FSM with respect to the value set in prm_dir
# short option -m defines model filename cpontaining the desired FSM (default value is models.prm so collecting FSMs in files with these names you can drop this option)
# short option -M defines FSM identifier in model file from which MPO is constructed
# short option -p sets parameter for FSM used to create MPO
# short option -o defines output filename for a lattice containing the created MPO
# short option -n defines identifier of created MPO under which it is stored in output lattice-file
$EXEC_DIR/link/sym-create-mpo --prm_dir $PRM_DIR -i lattice.complex -r Teq0/spin/1D/ -m models.prm -M heisenberg -p "J=${J}|Jz=${Jz}|hz=${hz}" -o lattice.complex -n H

# now create anti-neel state, we do this as MPS with real fundamental datatype to demonstrate how such MPS are automatically converted into complex MPS when they are loaded into an executable with complex lattice
# short option -i defines lattice input file containing Hilbert space and local basis
# short option -t defines type of created mps, choice 'anti-neel' means that sites are initialized alternatively in eigenstate of the local symmetry generators with minimum/maximum eigenvalue, i.e., s_i=-0.5/+0.5 in our case
# short option -o defines dest state filename
$EXEC_DIR/link/sym-create-mps -i lattice.real -t anti-neel -o anti-neel.symmps

# to test if we everything worked so far we measure the Sz expectation value of the fresh state
# short option -r is a boolean flag which, if set, resets the generated datafile erasing all content which may previously have been written into
# short option -n is a boolean flag which, if set, normalizes the expectation value(s) calculated with the states norm/overlap sqrt()
# short option -i defines lattice input file containing Hilbert space and local basis
# short option -k defines ket state of scalar-product (if bra is not specified it is set to the value of ket)
# short option -o defines a set of local operators for which the scalar product is to be evaluated
# short option -t defines a tag which is used to label the obtained expectation values in the output file (we set it to 0.000000 for reasons which become clear later)
$EXEC_DIR/link/sym-scalar-product -rni lattice.real -o 'Sz' -k anti-neel.symmps -t 0.000000 -d teo
# Note, that now there is a directory teo which contains a folder local_operators in which two files: Sz_real, Sz_imag are placed containing the real and imaginary part of the evaluated scalar product. For each local operator specifed via the -o short option a new file is created, if it does not already exists. If the file already exists the behaviour of the output is controlled by the -r flag. If set then the file's content will be removed, otherwise the data will be appended where in the first column the passed value for the tag is written and the second column is reserved for the norm/overlap of the input bra/ket-states

# Now comes the tricky part, we want to a time-evolution of this state which is a product state. Therefore, we can not begin the time-evolution using single-site TDVP-solver. However, as the problem has only nearest neighbor interactions we could in principle use 2-site TDVP solver which treats nearest neighbor interactions exactly and therefore does not pickup a projection error. This changes drastically if we have longer ranged interactions. To demonstrate a way around this problem we start the time-evolution employing an MPO stepper to grow the bond-dimension before switching to 2-site TDVP

# start with MPO time-evolution using W-II MPO stepper in a second order decomposition scheme
# short option -i defines lattice input file containing Hilbert space and local basis
# short option -w defines permitted maximum bond dimension of MPS-site tensors during time-evolution
# short option -d defines truncated weight threshold of MPS-site tensors
# short option -k defines data-type of time-argument \tau: c(omplex) means real-time evolution \tau= \delta t, d(ouble) means imaginary time-evolution \tau= \mathrm i \delta t
# short option -t defines initial time of time evolution
# short option -D defines time-step size |\delta t|
# short option -T defines final time of time evolution
# short option -I defines initial state for time evolution
# short option -O defines MPO used to construct time-stepper MPO loaded from input lattice
# short option -n defines max. number of sweeps during variational application of MPO-stepper
# short option -e defines escape precision for variational application of MPO-stepper
# short option -o defines checkpoint directory in which calculated time steps (MPS) are written
# short option -X is a flag which, if set, stores the constructed time stepper MPO(s) into the lattice, can be usefull if the lattice may be re-used later to save stepper construction time
# short option -V defines output verbosity (values > 7 also yield debug outputs) which we decrease to reduce runtime-information output
$EXEC_DIR/link/sym-time-evol-WII -i lattice.complex -w 100 -d 1e-10 -k c -t 0.0 -D 0.05 -T 1.0 -I anti-neel.symmps -O H -n 10 -e 1e-10 -o teo -XV 1
# If you check the output you might notice, that the norm of the time evolved states change during time-evolution. This is an artefact of the time-stepper being non-unitary and can be compensated for by passing the flag -z which forces renormalization after evolving the state by a time step \delta T

# Finally we switch to the 2-site TDVP solver, note that the arguments are merely the same except for those specifying the local krylov solver. Note, that we can choose a larger time-step \delta t since 2-site tdvp has no Trotter error
# short option -i defines lattice input file containing Hilbert space and local basis
# short option -w defines permitted maximum bond dimension of MPS-site tensors during time-evolution
# short option -d defines truncated weight threshold of MPS-site tensors
# short option -k defines data-type of time-argument \tau: c(omplex) means real-time evolution \tau= \delta t, d(ouble) means imaginary time-evolution \tau= \mathrm i \delta t
# short option -t defines initial time of time evolution
# short option -D defines time-step size |\delta t|
# short option -T defines final time of time evolution
# short option -I defines initial state for time evolution, here we pass the last checkpoint from the prev. MPO time-evolution
# short option -O defines MPO used to perform time evolution loaded from input lattice
# short option -s defines the TDVP stepper-type, can be choosen as single site (1site) or two site (2site) stepper, note that 1site is by a factor of the local dimensionoi faster but unable to increase bond dimension of MPS and may have larger projection error if, in particular if MPS bond-dimension is small
# short option -n defines minimal number of Krylov vectors used to construct Krylov subspace when solving the local Schrödinger equation
# short option -N defines maximal number of Krylov vectors used to construct Krylov subspace when solving the local Schrödinger equation
# short option -E defines escape precision for the local Krylov solver obtained by calculating the error described by Hochbruck and Lubich
# short option -V defines output verbosity (values > 7 also yield debug outputs) which we increase it a bit to obtain more runtime-information output
$EXEC_DIR/link/sym-time-evol-tdvp -i lattice.complex -w 100 -d 1e-10 -k c -t 1.0 -D 0.1 -T 20.0 -I teo/state.1.000000 -O H -s 2site -n 3 -N 10 -E 1e-08 -o teo -V 9

# Now the time evolution with TDVP 2-site solver is running. While waiting for it to return you can launch the script meas_teo.sh in the examples directory of your symmps folder.
# This script waits for the next checkpoint to be finished and performs a scalar-product to measure the Sz-expectation values after each time-step.
# Since we have already reset the data-files above by measuring the initial anit-neel state passing the short option -r, the measure script will only append new expectation values to the existing file yielding a matrix of datasets which can be plotted, for instance, in gnuplot via the command: "p 'teo/local_operators/Sz_real' matrix u 1:(0.1*$2):w ev ::2 w image".
# You obtain an image of the total time evolution of the expectation value <ψ|S^z|ψ> where |ψ> is the initial anti-neel state

Commit History

Publications that used SymMPS

• Matrix-product-state-based band-Lanczos solver for quantum cluster approaches
• Lifshitz transition in the phase diagram of two-leg t-J ladder systems at low filling
• Solving 2D and 3D lattice models of correlated fermions -- combining matrix product states with mean field theory
• PhD thesis: Matrix Product State Approaches to Non-equilibrium Spectral Quantities of Strongly Correlated Fermions in One Dimension
• In-Gap Band Formation in a Periodically Driven Charge Density Wave Insulator
• Superconducting pairing from repulsive interactions of fermions in a flat-band system
• Symmetry-protected Bose-Einstein condensation of interacting hardcore Bosons
• Formation of spinful dark excitons in Hubbard systems with magnetic superstructures
• Quantum dynamics simulation of intramolecular singlet fission in covalently linked tetracene dimer
• Comparative Study of State-of-the-Art Matrix-Product-State Methods for Lattice Models with Large Local Hilbert Spaces
• Efficient and flexible approach to simulate low-dimensional quantum lattice models with large local Hilbert spaces
• PhD thesis: Topological and non-equilibrium superconductivity in low-dimensional strongly correlated quantum systems
• Detecting superconductivity out-of-equilibrium
• Time-evolution methods for matrix-product states
• PhD thesis: Photoexcitations of Model Manganite Systems using Matrix-Product States
• Formation of spatial patterns by spin-selective excitations of interacting fermions
• Relaxation of photoexcitations in polaron-induced magnetic microstructures
• Automated construction of U(1)-invariant matrix-product operators from graph representations

Relevant links

• Wiki containing an Java applet demonstrating the density matrix renormalization group
• Alternative software package SYTEN, written by Claudius Hubig
• Unofficial DMRG Homepage
• Other Resources and links