State Preparation in MQT ✨

[M-J-Hochreiter]

Description

As a part of my bachelor thesis I implemented the Qiskit State Preparation algorithm (https://github.com/Qiskit/qiskit/blob/main/qiskit/circuit/library/data_preparation/state_preparation.py#) in C++ using the MQT Framework.
My advisor Yannick Stade suggested I open a pull request, as it might be interesting to add into MQT.

The state preparation allows a user to create a circuit that initializes a quantum state from a list of complex amplitudes, sometime needed in various quantum algorithms.

I am not sure how/where to add this class, thus I just created a new file.
If you could give me feedback whether this functionality might be interesting to add/what to change I would gladly try my best to fulfill your requests.

I have not yet written any tests, apart from manually comparing outputs of qiskit and my algorithm, and simulating both circuits with qiskit. (can be added in the future)

Checklist:

• The pull request only contains commits that are related to it.
• I have added appropriate tests and documentation.
• I have made sure that all CI jobs on GitHub pass.
• The pull request introduces no new warnings and follows the project's style guidelines.

[burgholzer]

Hey 👋🏼
Many thanks for the initial PR. This is definitely interesting and in scope for mqt-core! Looking forward to having this included.

The best place to put this would probably be in the algorithms submodule of mqt-core (https://github.com/cda-tum/mqt-core/tree/main/include/mqt-core/algorithms).
You can take lots of inspiration from the existing classes there. (https://github.com/cda-tum/mqt-core/blob/main/include/mqt-core/algorithms/Entanglement.hpp as one of the simpler ones, https://github.com/cda-tum/mqt-core/blob/main/include/mqt-core/algorithms/QPE.hpp as one of the more complicated examples).
The goal there would be to just create a new subclass of QuantumComputation called StatePreparation that takes the appropriate input in its constructor and then constructs the respective circuit using your methods. That shouldn't take too much adaptation from your existing code.

I would advise you to also create a .cpp file in the src/algorithms directory and move all the definitions from the header file there (just keeping the declarations themselves in the header). This makes compilation faster and helps to separate the interface of your methods from the implementation itself.
If any method is only ever used in one of your functions internally, you might as well move the declaration to the cpp file so the method is not exposed publicly. (This probably applies to most of the matrix manipulation stuff).

After the initial setup, it would be great to add some tests for the new functionality. These should probably placed here: https://github.com/cda-tum/mqt-core/tree/main/test/algorithms. Again, you can take lots of inspiration from the existing tests and should be able to use our own simulator for some experiments.

Please don't hesitate to ask questions if anything pops up!

[burgholzer]

Closing for now. Please feal free to reopen if you plan to continue working on this.

[codecov]

Codecov Report

Attention: Patch coverage is 96.94656% with 4 lines in your changes missing coverage. Please review.

Project coverage is 92.1%. Comparing base (be2b405) to head (743da30).

Files with missing lines	Patch %	Lines
src/algorithms/StatePreparation.cpp	96.9%	4 Missing ⚠️

Additional details and impacted files

@@          Coverage Diff          @@
##            main    #543   +/-   ##
=====================================
  Coverage   92.1%   92.1%           
=====================================
  Files        125     124    -1     
  Lines      13828   13908   +80     
  Branches    2153    2178   +25     
=====================================
+ Hits       12736   12810   +74     
- Misses      1092    1098    +6     

Flag	Coverage Δ		*Carryforward flag
cpp	91.8% <96.9%> (+<0.1%)	⬆️
python	99.7% <ø> (-0.1%)	⬇️	Carriedforward from f281a75

*This pull request uses carry forward flags. Click here to find out more.

Files with missing lines	Coverage Δ
src/algorithms/StatePreparation.cpp	96.9% <96.9%> (ø)

... and 6 files with indirect coverage changes

[M-J-Hochreiter]

Hi,

sorry for the long wait, I finally got around to working on this again!

I do have a question on the new constructor that should be implemented:
As my previous methods created a QuantumComputation from scratch, do you believe it makes sense to just call the QuantumComputing constructor in my StatePreparation constructor with the QuantumComputation I obtained from my prepareState function?

I do not see any option to reopen this pull request and continue working on it.

[burgholzer]

Hi,

sorry for the long wait, I finally got around to working on this again!

I do have a question on the new constructor that should be implemented: As my previous methods created a QuantumComputation from scratch, do you believe it makes sense to just call the QuantumComputing constructor in my StatePreparation constructor with the QuantumComputation I obtained from my prepareState function?

I do not see any option to reopen this pull request and continue working on it.

Hey 👋🏼

No worries. I just reopened the PR for you.
Have a look at the new versions of the algorithm implementations in MQT Core, e.g.,

• https://github.com/cda-tum/mqt-core/blob/main/include/mqt-core/algorithms/QPE.hpp and
• https://github.com/cda-tum/mqt-core/blob/main/src/algorithms/QPE.cpp.

I'd imagine that your State Preparation functionality code can be implemented and integrated very similarly.

[M-J-Hochreiter]

I refactored both files to match the other algorithms style if you would like to give it a look!

Next step would then be tests from what I can see right?

[burgholzer]

I refactored both files to match the other algorithms style if you would like to give it a look!

Next step would then be tests from what I can see right?

Getting the CI to a state where it is all-green would be desirable.
That includes writing tests that cover all the changes. 👍🏼