How to define composite Hamiltonian in composite Hilbert space

[Jachi9]

I want to define an Hamiltonian of the type $$H = A \otimes \mathcal{1}_b + \mathcal{1}_a \otimes B $$
where A and B are operators acting respectively on the subspaces A and B in the Hilbert space $\mathcal{H} = \mathcal{A} \otimes \mathcal{B}$.

Let's say the spaces are 2 Fock spaces. Then

     A = nk.hilbert.Fock(n_max=Lambda-1, N=n_modes_A)
     B = nk.hilbert.Fock(n_max=Lambda-1,N=n_modes_B)
     H = A*B

and I now define the 2 Hamiltonians

for i in range(0,n_modes_A):
    ham_A += Delta*adag(A,i) * a(A,i)  
for r in range(0,n_modes_B):
    ham_B += epsilon*r* adag(B,r) * c(B,r) 

To my understanding in order to create the Hamiltonian I need to define the 2 identity matrices, which, in a tricky way, can be defined

Id_A = 1 + adag(A,1) - adag(A,1)
Id_B = 1 + adag(B,1) - adag(B,1)

and then

ham = ham_A * Id_B + ham_B*Id_A

Here I get the error TypeError: unsupported operand type(s) for +: 'type' and 'type'.
Am I doing it in a correct way or am I missing something ?

Thank you for any help

[PhilipVinc]

Two things

• can you provide a MWE that I can copy paste and check for and that 'runs' until the error?

Ok, the error is because our operators must be defined over the total Hilbert space. You cannot compose operators on different subspaces (we technically don't have the kronecker product between operators) but only allow multiplication/addition between operators on the same space.

So to properly implement your example you need to define your hamiltonian with adag which I assume is just nk.operator.boson.create not by passing it A but by passing it H.
You need to carefully shit the sites in partition B. For example I'd change your code to

for i in range(0,n_modes_A):
    ham_A += Delta*adag(H,i) * a(H,i)  
for r in range(n_modes_A,n_modes_A+n_modes_B):
    ham_B += epsilon*r* adag(H,r) * c(H,r) 

ham = ham_A + ham_B

[Jachi9]

Actually I was trying with fermions and a Fock space, but the error is the same. Here is my code:

import netket as nk
from netket.operator.boson import (create as adag, destroy as a)
import netket.experimental as kx
from openfermion import FermionOperator
from netket.experimental.operator.fermion import (create as cdag, destroy as c, number as nc)
import numpy as np
import igraph as ig

Lambda = 4  
n_modes = 6  
n_levels = 5

hi = nk.hilbert.Fock(n_max=Lambda-1, N=n_modes) * kx.hilbert.SpinOrbitalFermions(n_levels, s= None, n_fermions = 1)                   

hi_at = kx.hilbert.SpinOrbitalFermions(n_levels, s= None, n_fermions = 1)
hi_mod = nk.hilbert.Fock(n_max=Lambda-1,N=n_modes)
hi = hi_at*hi_mod

print(hi.size)

Delta = 0.5

epsilon = 0.1

ham_at = 0.0 
ham_mod = 0.0 
Id_at = 1 + cdag(hi_at,1) - cdag(hi_at,1)
Id_mod = 1 + adag(hi_mod,1) - adag(hi_mod,1)


for i in range(0,n_modes):
    ham_mod += Delta*adag(hi_mod,i) * a(hi_mod,i)  #free mode hamiltonian 
for r in range(0,n_levels):
    ham_at += epsilon*r*cdag(hi_at,r) * c(hi_at,r) 

ham = ham_at * Id_mod + ham_mod*Id_at

[PhilipVinc]

So you are getting an imperscrutable error message, which I'm fixing. After the fix you'll see this error

TypeError: unsupported operand type(s) for *: 'FermionOperator2nd' and 'LocalOperator'

which is telling you exactly that: you can't as of now mix and match operators of two different kinds.
In short, it means you cannot combine fermions with bosons because we have not implemented the logic for it... yet.
It's possible to implement it with some care but requires getting your hands dirty