Add conversions between Jeff and arith, math, and tensor

[denialhaag]

This PR adds conversions between Jeff and the built-in arith, math, and tensor dialects. The conversions can round-trip all Int_Ops, IntArray_Ops, Float_Ops, and FloatArray_Ops.

[denialhaag]

Apart from the tests and the linter errors, this is practically ready.

Unfortunately, the testing is giving me quite a headache. I really wanted to reuse the .jeff files and implement round-trip tests. However, this is currently forcing quite some less-than-ideal workarounds to prevent constant folding. At this point, I feel like we might need to write string-based unit tests that test each conversion individually.

@burgholzer, do you see any alternative? 🤔

[burgholzer]

Thanks @denialhaag for working on this. Gave this a quick review and, as always, you will find some comments inline. I hope these make sense. Some might require a bit of discussion.

[burgholzer]

I just gave this another (very quick) round of review. All of the comments are minor. Once addressed, this is good to go from my side.
Maybe @dime10 wants to have a quick look as well?

[denialhaag]

After a discussion in munich-quantum-toolkit/core#1565 (comment), we have decided to make some more changes to the native-to-Jeff conversion:

• Cast operations are now removed during the conversion. This should always be fine because the conversion creates Jeff operations with the correct type. The cast operations should thus only be artifacts that made the native program valid.

• The native-to-Jeff conversion seems very clean to me now because the arith, math, and tensor dialects are marked illegal without exceptions. In general, the conversion logic is very straightforward now.

• It became necessary to convert arith.constant operations of type index to jeff.int_const_32 operations. If I'm not completely mistaken, this is in the spirit of the Jeff specification because arrays are indexed using int(32): https://github.com/unitaryfoundation/jeff/blob/main/impl/capnp/jeff.capnp#L964-L972

• Unfortunately, the change broke four round-trip tests because the IR is no longer identical (but still equivalent, of course):

  Input:

  func.func @main() {
    %0 = jeff.int_const32(2) : i32
    %1 = jeff.int_array_const32([1, 2, 3]) : tensor<?xi32>
    %2 = jeff.int_array_get_index(%0) %1 : i32, tensor<?xi32> -> i32
    return
  }
  

  Output:

  func.func @main() {
    %0 = jeff.int_array_const32([1, 2, 3]) : tensor<?xi32>
    %1 = jeff.int_const32(2) : i32
    %2 = jeff.int_array_get_index(%0) %1 : i32, tensor<?xi32> -> i32
    return
  }
  

  I'm leaning toward living with this and skipping these tests, but I'm open to being convinced.

If both @burgholzer and @dime10 agree, I'd say we can merge this later today.

[dime10]

Thank you for the updates @denialhaag! In terms of round-tripping, I would say as long as the jeff mlir dialect and the jeff format round-trip, that's the most important. From other dialects to the jeff dialect I would expect some (non-meaningful) loss because there are different abstractions involved.

[dime10]

Excellent work 🙌

[burgholzer]

Looks like this is ready to be merged. 🚀
Let's go.