Implementing an operator with an absolute value

[waleed-sh]

Hi! This may be a very trivial question, but I am trying to implement an operator which has an absolute value in it and I don't know how to do so.

The exact operator is very complicated to write down here, but the general picture is as follows:

1. I have a spin system on a lattice with allowed spins on every site from -J to J in integer steps, where J is some integer.

2. I have a LocalOperator based operator called N(site) which gives me the spin at a given site (think number operator in the quantum harmonic oscillator). This is just an J x J matrix with a diagonal being -J ... J.

3. I use the N operator to act on different sites in the lattice. Sometimes they (the N operators) are multiplied and sometimes they are added, depending on how the sites are related to each other. This then forms an operator which I call now V

4. My issue is, let's say now my V operator looks like this: N(0)*N(1) - N(2)*N(3) - N(4)*N(5). How would I be able to write an operator which gives me | N(0)*N(1) - N(2)*N(3) - N(4)*N(5) |?

So basically, I need to act with these N operators to get the spins on different sites and get the spins accordingly and then do this sum, which for example can be a negative value, and then get the absolute value of that.

Any help would be tremendously appreciated!

[PhilipVinc]

How is the absolute value of an operator defined exactly?

[waleed-sh]

Well, for implementation purposes I just need to act on the sites and get the quantum numbers on the sites in some specific arrangement and after that, whatever the result is, I need to take the absolute value of that. So for the example definition of V I gave, if I get during the optimisation/ground state search loop a spin configuration which would then give me N(0)*N(1) - N(2)*N(3) - N(4)*N(5) = -2, then I just need it to be 2.

For math purposes this gets more complicated beyond the scope of the question (I think?), and I think it will depend on the operator (e.g. bounded or not, etc). The operator I have is Hermitian though and is diagonal in the basis I have. In any case, the absolute value of an (bounded) operator O would be sqrt(O* O) where O* is the adjoint of O. I am trying to avoid doing V* V because then I may end up with a rather large operator if I allow more spin on the sites...

[PhilipVinc]

I see, so if I understand correctly, in a sense, you have a 'standard' operator $$\hat{V}$$ , and you want to define a new operator $$\tilde V $$ which is defined such that

$$\langle\alpha|\tilde V |\beta\rangle = |\langle\alpha|V |\beta\rangle| $$

Is that correct?

In that case... I'm afraid you won't be able to use built-in netket operators, as they only support standard operator addition and multiplication (by other operators or scalars).

You can hack your way through this, though it won't be trivial.
You need to modify _get_conn_padded, which returns matrix elements and connected elements, such that the matrix elements are the absolute value.

If V had only a single term and was not a sum of different operators, you might get away as easily as adding a np.abs(mels) at this line. However in general this won't work because for a series of reasons we might split one matrix element into multiple entries. In which case you'd have to parse connected elements and mels for identical terms and compute the absolute value accordingly.

[PhilipVinc]

The easiest way to experiment with this, in my opinion, is by subclassing LocalOperator, trying to understand how it works (it won't be easy...) and finding ways to make it work.

[waleed-sh]

Yes, precisely. The desired operator $\tilde{V}$ is just as you described it. So basically I have to modify _get_conn_flattened_kernel (since _get_conn_padded calls the get_conn_flattened which eventually returns that function) or am I mistaken?

If V had only a single term and was not a sum of different operators, you might get away as easily as adding a np.abs(mels) at [this line]

Unfortunately it contains many terms, so it won't be this trivial I guess...

In which case you'd have to parse connected elements and mels for identical terms and compute the absolute value accordingly.

Are we here still talking about the _get_conn_flattened_kernel? What is meant by "identical terms" here and where does the matrix element splitting occur? I'm a little lost at that last part and some clarification if possible would be tremendously helpful so that I know where to start looking to modify what needs to be modified.

Thank you for your reply! This has been helpful! I'm marking your reply as the answer as this is just a follow up

[PhilipVinc]

So basically I have to modify _get_conn_flattened_kernel

yes

Unfortunately it contains many terms, so it won't be this trivial I guess..

No. I had warned you...

Are we here still talking about the _get_conn_flattened_kernel?

yes.

I suggest you try to create a 1-site operator like sigma x and try to understand what get conn flattened does.
Then move to a 2-site operator, and try to understand.
Then consider the sum of two operators, and see what happens.
Then try to implement what you are trying to do.

In any case, if your operator is diagonal as you seem suggesting, I think just putting jnp.abs where I suggested above should work.

--

Something I can quickly tell to point you in the right direction: in short, given a bit string $\langle x |$, H.get_conn(x) will return all bit strings $| y_i\rangle$ and corresponding matrix $\langle x | H | y_i\rangle$ elements such that $\langle x | H | y_i\rangle \neq 0$.
The set of $\{| y_1\rangle, | y_2\rangle, \dots | y_M\rangle \}$ is x_prime in the code and the set of matrix elements $\{\langle x | H | y_1\rangle, \langle x | H | y_2\rangle, \dots, \langle x | H | y_M\rangle\}$ is mels in the code.

(In a sense, this is equivalent to CSR sparse matrix storage format where instead of integer indices we return bit strings).

However... I lied to you! Pretty much like in CSR, there's a slight complication. From the example above you might assume that, given one $x$, $y_1\neq y_2 \neq \dots$. But in practice we might have twice the same element, and their sum will give you the actual matrix element. So in a sense...
x_prime $=\{| y_1\rangle, | y_2\rangle, | y_2\rangle \}$ and

mels $=\{\langle x | H | y_1\rangle, \alpha_2 \langle x | H | y_2\rangle, \beta_2\langle x | H | y_2\rangle\}$ with $\alpha_2 + \beta_2 = 1$

Of course there might be more than two sub-terms. The reason this shows up is because it's not easy to unpack the operator in fast-to-compute perfectly-factored terms. Maybe it's possible but I'm not sure how to do. So hamiltonians of certain forms will have this. (For Ising, for example, this never happens. For diagonal hamiltonians, this never happens).

[waleed-sh]

Wow this was very informative! I think in the general case this would require modifying _get_conn_flattened quite a bit precisely because of what you mentioned. Luckily, the operator I have, even with the many terms in it, is at the end of the day diagonal! So I think np.abs where you specified should do it!

If I happen to find a way to do this for the general case maybe I'll come back here and post it, as it may be of use to others as well.

Thank you once again!!