Operators on Doubled hilbert space

[joshuazlin]

Hi! I'm wondering if there are natural ways to lift operators defined on a base hilbert space H to the doubled space H \otimes H. For example, there are a few natural ways an operator on H lifts to an operator on H \otimes H that I can think of

• It can act on the first copy of H in H x H, (so the operator is op \otimes identity)
• It can act on the second copy (so the operator is identity \otimes op)
• You can get a 'doubled' operator (so the operator is op \otimes op)
• You can get commutator/anticommutator (so you can have op \otimes id + id \otimes op or op \otimes id - id \otimes op)

If I understand, I can actually get something like the commutator by .operator.LocalLouivillian with no jump operators. I understand that I can use the same code I use to create the original operator on H, and modify it to create the operator on the doubled space - but I'm wondering if there is any existing API to creating the other types of operators.

[PhilipVinc]

Hey @joshuazlin, and welcome!

If I understand, I can actually get something like the commutator by .operator.LocalLouivillian with no jump operators.

correct

I understand that I can use the same code I use to create the original operator on H, and modify it to create the operator on the doubled space

also correct

but I'm wondering if there is any existing API to creating the other types of operators.

There's no API to do that (yet), but that's mainly because nobody tried to do that (yet). I would be very happy to discuss and then merge some new API points implementing support for the use-case you are describing.

[PhilipVinc]

By the way, I was thinking about it and I realised that actually you can represent super-operators with LocalOperators, you just have to change the Hilbert space to a doubled one.

For example, you can rewrite the Liouvillian to be something like

# lind = LocalLiouvillian construct Lind for example by running Examples/DissipativeIsing1d/ising1d.py
hi = nk.Hilbert.Spin(...)
hi2 = nk.hilbert.DoubledHilbert(hi)

hnh = lind.hamiltonian_nh
hnh_l = nk.operator.LocalOperator(
                 hi2, lind.hamiltonian_nh.operators, lind.hamiltonian_nh.acting_on
              )
hnh_r = nk.operator.LocalOperator(
                hi2, lind.hamiltonian_nh.operators, [tuple(k+hi.size for k in c) for c in lind.hamiltonian_nh.acting_on]
               )

lind_localop = -1j* (hnh_l - hnh_r.H) 
for op in lind.local_op:
      op_l = nk.operator.LocalOperator(hi2, op.operators, op.acting_on)
      op_r = nk.operator.LocalOperator(
                    hi2, op.operators, [tuple(k + ha.hilbert.size for k in c) for c in op.acting_on]
                  )
      lind_localop = ll + op_l * op_r

(There might be some I and signs off in the formula above, but the idea should be correct).

As you see, terms acting to the left of the density matrix are simply constructed as localoperators on the doubled Hilbert space, while those acting on the right of the density matrix are constructed by shifting the acting_on, which are the indices of the sites where they act upon.

You can play around and write a function that does this shifting for you I think.

[PhilipVinc]

@joshuazlin did you manage to get this to work? Can I ask what are you trying to do so that we can try to implement better APIs for this use case?

[joshuazlin]

Hello! I realised in the end that what I was attempting was not a very good idea
My original intent was to prepare a given pure state (e.g. ground state of Hamiltonian) on the mixedstate RBM. My naive idea was that you can minimise H \otimes 1 + 1 \otimes H on the doubled hilbert space, and this does the trick.
However, a cleaner way to do this state preparation is just to learn the ground state on a pure-RBM, and transfer the weights over from the pure RBM into the pure part of the mixed RBM. The only technical difficulty is that right now in netket, the normalisation between the pure/mixed RBMs is off by a factor of two, but seems like I can just get around this by hacking it a bit.

[LionSR]

Could you elaborate why “the normalisation between the pure/mixed RBMs is off by a factor of two”? @joshuazlin