Define tJ operators from Hubbard operators

[Yue-Zhengyuan]

We should try to reduce code redundancy by defining t-J operators from their Hubbard counterparts by projection to the no-double-occupancy subspace. Then we only need to test the properties of the Hubbard operators, with a few additional tests ensuring that the projection is done properly.

To be more extreme, we may consider totally remove TJOperators, while adding a kwarg tj::Bool to all Hubbard operators, which controls whether the constructed operator should be projected to the no-double-occupancy t-J subspace.

The slave_fermion = false case is easier to work out. To handle slave_fermion = true, we can also define the parity-flipped version of the Hubbard operators. See this Physics SE post. Only I don't have time to figure out all the details by myself yet. Handling the doubly-occupied state might be a bit cumbersome in the latter case.

[Yue-Zhengyuan]

The projector for each kind of symmetry can be defined as follows:

function get_projector(psymm, ssymm)
    Vhub = Hub.hubbard_space(psymm, ssymm)
    Vtj = tJ.tj_space(psymm, ssymm)
    proj = zeros(Vtj ← Vhub)
    for (f1, f2) in fusiontrees(proj)
        proj[f1, f2][diagind(proj[f1, f2])] .= 1
    end
    return proj
end

Then, for example, S_exchange for the t-J model can simply be obtained as follows:

opHub = Hub.S_exchange(psymm, ssymm);
@tensor optJ[-1 -2; -3 -4] := opHub[1 2; 3 4] * 
    proj[-1; 1] * proj[-2; 2] * proj'[3; -3] * proj'[4; -4];
optJ ≈ tJ.S_exchange(psymm, ssymm) # true

[lkdvos]

I can see why this might be more elegant, but given that the current implementation works and is already done, I'm not sure if this makes such a huge difference? In particular, the projection would necessarily introduce floating point errors, so the tensors you get out then don't have the clean integer values.

Basically, while I'm not against this, I'm not sure this is worth investing too much time in. If it's stupid but it works, it's not stupid?

[Yue-Zhengyuan]

I feel the need to do this since when I make a change in HubbardOperators or its test, a corresponding change is always needed in TJOperators, and I'm kind of tired of this repeated work. In addition, we can actually avoid the floating point errors by directly copying the tensor elements instead of calculating the contraction with projectors.

I agree it does not have any benefit except making the code look better. I just say it here so someone interested can do it in their free time.

[Jutho]

Also, it should be possible to do the projection such that no floating point errors are introduced, since it is just multiplying/contracting with a projection tensor that only has zeros and ones as entries. I would always write it as a multiplication to avoid having to permute legs (which requires F moves and thus floating point numbers)

For one site operators, that is simply:

optJ = proj * opHub * proj'

whereas for two-site operators I would use

proj2 = proj ⊗ proj
optJ2 = proj2 * opHub2 * proj2'