[WIP] Partial equivalence checking

[reb-ddm]

Description

Added functionality for partial equivalence checking as described in the paper "Partial Equivalence Checking of Quantum Circuits" by Chen et al. It uses the decision diagram representation of the quantum circuit to check the equivalence conditions as described in the paper.

Some helper functions are in the file Package.hpp and the main partial equivalence checking function is in Verification.hpp.

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 👋🏼

Sorry for the long wait on the review.
This is just a first pass through the changes. I haven't really managed to look through the methods themselves in detail. I'll do that in a follow-up review.
However, this should un-stall your progress and give you some pointers on aspects that might still need some improvement.
Let me know if anything is unclear 👍🏼

[burgholzer]

Ah, and btw., that remaining clang-tidy warning is a frequent false positive that should hopefully be resolved by now if you rebase your changes on the main branch or merge the main branch in.

[reb-ddm]

I noticed that I needed to use static_cast very often in my code, mainly because dd::Qubit is defined as uint16_t and it often needs to be compared to variables of type size_t. But then I found out that there is a type qc::Qubit, which is defined as uint32_t. Changing my code to utilize qc::Qubit instead of dd::Qubit made me remove most of the casts. Is there a reason that these two types with the same name are different? And which one is supposed to be used when?

[burgholzer]

I noticed that I needed to use static_cast very often in my code, mainly because dd::Qubit is defined as uint16_t and it often needs to be compared to variables of type size_t. But then I found out that there is a type qc::Qubit, which is defined as uint32_t. Changing my code to utilize qc::Qubit instead of dd::Qubit made me remove most of the casts. Is there a reason that these two types with the same name are different?

Yeah and it's kind of implied by the different namespace. In the general qc:: namespace, we want to be able to represent rather large circuits and space is not really too much of a concern. Thus, we use unsigned 32bit integers there, which allows for up to roughly 4 billion qubits.
In the dd:: namespace we want to be as efficient as possible since a variable of that Qubit type is part of every single DD Node. In the past, we used to define that qubit type as int8_t, which would actually limit us to 128 qubits. Since there was some demand for realizing larger simulations than that, we decided to with uint16_t for the DD Qubit type.

And which one is supposed to be used when?

Any code that is part of mqt-core and does not concern DDs should be using the wider qc::Qubit type. Everything that involves DDs can/should be using the narrower dd::Qubit type. However, that's not really dogmatic.

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 91.1%. Comparing base (8c199aa) to head (72e1e7c).
Report is 3 commits behind head on main.

Additional details and impacted files

@@          Coverage Diff          @@
##            main    #487   +/-   ##
=====================================
  Coverage   91.1%   91.1%           
=====================================
  Files        132     132           
  Lines      13794   13809   +15     
  Branches    2166    2176   +10     
=====================================
+ Hits       12575   12589   +14     
- Misses      1219    1220    +1     

Flag	Coverage Δ		*Carryforward flag
cpp	90.8% <100.0%> (+<0.1%)	⬆️	Carriedforward from 38f4b46
python	99.5% <ø> (ø)		Carriedforward from 38f4b46

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

Files	Coverage Δ
include/mqt-core/QuantumComputation.hpp	91.8% <100.0%> (+0.1%)	⬆️
include/mqt-core/dd/FunctionalityConstruction.hpp	100.0% <ø> (ø)
src/QuantumComputation.cpp	81.9% <100.0%> (+0.1%)	⬆️
src/dd/FunctionalityConstruction.cpp	96.8% <100.0%> (+<0.1%)	⬆️

... and 2 files with indirect coverage changes

[burgholzer]

Closing this in favor of #563 for now. We can always re-open if necessary.