# Qsymm workflow

Qsymm is a great tool, developed here in the group, but not everyone is very familiar with it. This is a Qsymm tutorial designed to change that. Qsymm already has extensive documentation and a few tutorials on read the docs, but this tutorial shows a start-to-finish workflow. It covers using the nonhermitian branch of qsymm to create real-space Hamiltonians, saving and loading models, how to test our models for various symmetries, and how to use our models in kwant systems.

import qsymm
import numpy as np


In order to use the nonhermitian branch of qsymm, clone that branch into your environment, navigate into the directory and do pip install .

### Making a real-space model for kwant to use

We want to make a hamiltonian matrix that we can supply to hopping and onsite functions when constructing our system in kwant. We want this matrix to obey certain symmetries that we're interested in. This hamiltonian will be defined in real space, and will vary based on the bond length between sites d rather than the wave vector k.

#### Step 1: defining symmetries and generating a model

For nonhermitian models, we need to modify the actions of our symmetries accordingly.

• particle-hole and time-reversal symmetries send $H(k)$ to -H*(-k) or H*(-k) respectively. In real space, we write them such that we end up with -H*(k) and H*(k) respectively.
• we have to supply a modified hermiticity condition. Here reversing the bond means hopping in the opposite direction, so it is equal to the hermitian conjugate of the hopping. This translates to H(-d)=H^+(d).
herm = qsymm.PointGroupElement(
R = -np.eye(2), # 2 spatial dimensions
conjugate = True,
antisymmetry = False,
U = np.eye(2), # unitary part of the symmetry
transpose = True, #for hemitian conjugate, have to conjugate and transpose
)

family = qsymm.continuum_hamiltonian(
[herm], #the generating symmetries
dim=2, #spatial dimension
hermitian = False, #raises an error if you're not on the nonhermitian branch of qsymm
total_power=1, #maximum power of k we want to appear in our model
)
h_=qsymm.hamiltonian_generator.hamiltonian_from_family(family,  tosympy=False)
h_.tosympy()


$$\left[\begin{matrix} 1.0 c_{2} + 1.0 i c_{4} k_{x} + 1.0 i c_{8} k_{y} & 1.0 i c_{0} - 1.0 c_{1} + 1.0 i c_{10} k_{y} - 1.0 c_{11} k_{y} + 1.0 i c_{6} k_{x} - 1.0 c_{7} k_{x} \\ - 1.0 i c_{0} - 1.0 c_{1} + 1.0 i c_{10} k_{y} + 1.0 c_{11} k_{y} + 1.0 i c_{6} k_{x} + 1.0 c_{7} k_{x} & - 1.0 c_{3} + 1.0 i c_{5} k_{x} + 1.0 i c_{9} k_{y} \end{matrix}\right]$$

We can check symmetries of our Hamiltonian model

M1 = qsymm.groups.mirror([0, 1])
M2 = qsymm.groups.mirror([1, 0])
TR = qsymm.time_reversal(2)
PH = qsymm.particle_hole(2)
C = qsymm.groups.chiral(2)
gens = {
M1, M2, C, TR, PH}

candidates = qsymm.groups.generate_group(gens)
sg, cg = qsymm.symmetries(
h_, candidates=candidates,
continuous_rotations=True,
prettify=True,
sparse_linalg=True
)
sg, cg

([1], [])


No symmetries, since we didn't specify any. Let's now specify some.

When supplying symmetries to qsymm to build a model, we have to supply the unitary part. Part of it is easy to deduce, for example if the symmetry squares to -1, it will contain sigma_y. Other than that, you have to ensure that the symmetry operation does what you expect it to in the basis you choose.

S = 2*qsymm.groups.spin_matrices(1/2)

P_1 = qsymm.PointGroupElement(np.eye(2), conjugate=True, antisymmetry=True, U = S[0]) #particle-hole symmetry
M_y = qsymm.PointGroupElement(np.diag([1,-1]), False, False, S[0]) #mirror symmetry in y
rot = qsymm.ContinuousGroupGenerator(R = S[1], U = 0.5*S[2]) #continuous rotation symmetry

family = qsymm.continuum_hamiltonian(
[herm,P_1,M_y,rot],
dim=2,
hermitian = False,
total_power=1,
)
len(family)

0


No terms allowed it seems. This means either we have to go to 4x4, or that the unitary parts of our symmetries aren't consistent within the basis.

family = qsymm.continuum_hamiltonian(
[herm, M_y, rot],
dim=2,
hermitian = False,
total_power=1,
)
h_=qsymm.hamiltonian_generator.hamiltonian_from_family(family,  tosympy=False)
sg, cg = qsymm.symmetries(
h_, candidates=candidates,
continuous_rotations=True,
prettify=True,
sparse_linalg=True
)
sg, cg

([1, R(π), M([-1  0]), M([ 0 -1]), T, R(π) T, M([-1  0]) T, M([ 0 -1]) T],
[exp(-i ϕ L)⋅H(k)⋅exp(i ϕ L) = H(R_ϕ⋅k)
R_ϕ = R(ϕ)
L = [[ 0.5+0.j  0. +0.j]
[ 0. +0.j -0.5+0.j]]
])


You can also get additional symmetries you didn't intend in your model, like the time-reversal symmetry we see above, even though we didn't ask for it. You have to try out different unitary parts to get the result you want.

Once you have a hamiltonian, you make it into a model with:

model = qsymm.Model(h_, momenta=["k_x", "k_y"])
# sometimes the coefficients get freaky so we can round them.
rounded_model = dict()
for a,b in model.items():
rounded_model[a]=np.round(b,2)
model = rounded_model
qsymm.Model(model).tosympy()


#### Step 2: saving and loading a model

Here we show how we can move between a qsymm Model, a json serialization, then to a set of numpy arrays.

##### Encoding
import json
from astropy.utils.misc import JsonCustomEncoder

def pickle_this(model, name):
'''model is a qsymm.Model
'''
#name
name = name + '.json'
model_dict = { str(key) : model[key].tolist() for key in model.keys() }
with open(name, 'w') as fp:
json.dump(model_dict, fp, cls = JsonCustomEncoder)

##### Decoding

To load it, you have to use a custom decoder, that's not part of a package.

class JsonCustomDecoder(json.JSONDecoder):
"""
A decoder function tailored specifically to our purposes: take a dictionary of strings,
output a dictionary of symbolic keys (Mul types etc.) and arrays.
"""

def __init__(self, *args, **kwargs):
json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)

def object_hook(self, obj):
new_dict = dict()
for key in obj.keys():
# have to back-convert the key from string to symbols
symbolic = []
split_key = key.split("*")

if str() in set(split_key):
# there's a power: proceed with caution. This procedure is also valid for
# only one single power being present.
power_location = np.where(np.array(split_key) == str())[0][0]
split_key_power = [
split_key[power_location - 1],
split_key[power_location + 1],
]
key_1 = split_key[: power_location - 1]
key_2 = split_key[power_location + 2 :]
split_key = key_1 + key_2  # key terms without the power
# split key power is of the form ['k', 'x' ]
symbolic.append(
sympy.Pow(Symbol(split_key_power[0]), int(split_key_power[1]))
)
# now add the rest
for term in split_key:
symbolic = [sympy.Mul(symbolic[-1], Symbol(term))]
else:
# no power, proceed normally
for term in split_key:
if symbolic == []:
symbolic = [Symbol(term)]
else:
symbolic = [sympy.Mul(symbolic[-1], Symbol(term))]
symbolic_key = symbolic[0]
array = []
for line in obj[key]:
lineski = []
for entry in line:
lineski.append(entry[0] + 1j * entry[1])
array.append(lineski)
new_dict[symbolic_key] = np.array(array)
return new_dict


To unpickle, do something like

with open('filename.json', 'r') as fp:
unpickled_dictionary = json.load(fp, cls = JsonCustomDecoder)


#### Step 3: using our model as a value function in a kwant system

While building a kwant system, you do something like

syst[lat.shape(shape_edge, (0, 0))] = onsite
syst[lat.neighbors(n=1)] = hopping


for example.

onsite() and hopping() and value functions that take each site and each pair of sites connected by a bond in the system respectively, and return either an onsite or a hopping value for this site or bond.

We can use load our models into the function that builds our kwant system before calling onsite and hopping, and define the latter as:

def onsite(
site,
omodel,
model_parameters
**kwargs
):
"""
Value function used in the creation of the kwant FiniteSystem instances.
Determines the onsite values.

:param Site site: A kwant Site instance
:param Model omodel: A qsymm lambdified Model
:param dict omodel_parameters: the parameters to be used by omodel

:rtype: valueFunction
"""
k_and_r = dict(k_x=0, k_y=0, r=0, os=1)

return omodel(site, **omodel_parameters, **k_and_r)

def hopping(
site1,
site2,
hmodel,
hmodel_paramters,
**kwargs,
):
"""
Value function used in the creation of the kwant FiniteSystem instances.
Determines the hopping values based on the distance between the two sites
to be connected. Periodicity determines how distances are treated.

:param Site site1,2: kwant Site instances
:param Model hmodel: A qsymm lambdified Model
:param dict hmodel_parameters: the parameters to be used by hmodel

:rtype: valueFunction
"""
#extracting the bond length
delta = site2.pos - site1.pos
if la.norm(delta) != 0:
d = delta / la.norm(delta)
else:
d = delta

k_and_r = dict(k_x=d[0], k_y=d[1], r=1, os=0)  # set onsite to 0

return hmodel(site1, site2, **hmodel_parameters, **k_and_r)


You see that we have to be able to turn off the onsite part of the model when we return the hopping value function, and vice versa for the onsite. We can do this by either adding additional coefficients to our models like so:

onsite_coeffs = ['mu1','lam1','lam2','mu2',0,0,0,0]
hopping_coeffs = [0,0,0,0,'t1','o1','o2','t2']

h_os=qsymm.hamiltonian_generator.hamiltonian_from_family(
family, coeffs = onsite_coeffs, tosympy=False
)
h_hop=qsymm.hamiltonian_generator.hamiltonian_from_family(
family, coeffs = hopping_coeffs, tosympy=False
)
h_=h_os+h_hop


Or by saving the two different models h_os and h_hop separately.

You also notice that we provide "lambdified" models to kwant. What this means is that we are preparing the model to behave like a value function. It's important to note that this lambdification takes a bit of time, which adds up over all the sites and bonds of a lattice, so best to do it once at the beginning.

You'll also notice that onsite() gets omodel and hopping gets hmodel. These aren't two distinct qsymm models, they're just the same qsymm model lambdified two different ways:

with open("filename.json", "r") as fp:
model = json.load(fp, cls=JsonCustomDecoder)
model = qsymm.Model(model, momenta=["k_x", "k_y"])
omodel = model.lambdify(onsite=True)
hmodel = model.lambdify(hopping=True)


And there you have it.