DD synthesis of irreversible functions (Encoded to reversible without additional line)

[SmaranTum]

Description

This PR addresses the dd synthesis of irreversible functions which are encoded to reversible without any need of an additional line. For the synthesis, don't care conditions must be taken into consideration. This PR introduces the DC node condition based on which the synthesis can be carried forward. Appropriate tests and benchmarks are included as well.

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.

[codecov]

Codecov Report

Merging #115 (1ef4b39) into main (87959a2) will increase coverage by 0.0%.
The diff coverage is 95.5%.

@@          Coverage Diff          @@
##            main    #115   +/-   ##
=====================================
  Coverage   92.2%   92.2%           
=====================================
  Files         32      33    +1     
  Lines       2233    2287   +54     
=====================================
+ Hits        2059    2109   +50     
- Misses       174     178    +4     

Impacted Files	Coverage Δ
include/algorithms/synthesis/dd_synthesis.hpp	100.0% <ø> (ø)
src/algorithms/simulation/simple_simulation.cpp	82.7% <ø> (ø)
src/algorithms/synthesis/encoding.cpp	98.3% <ø> (+<0.1%)	⬆️
src/core/truthTable/truth_table.cpp	90.9% <80.0%> (-9.1%)	⬇️
include/algorithms/synthesis/encoding.hpp	100.0% <100.0%> (ø)
include/core/truthTable/truth_table.hpp	97.7% <100.0%> (+0.2%)	⬆️
...rc/algorithms/simulation/circuit_to_truthtable.cpp	100.0% <100.0%> (ø)
src/algorithms/synthesis/dd_synthesis.cpp	99.1% <100.0%> (-0.5%)	⬇️
... and 2 more

Help us with your feedback. Take ten seconds to tell us how you rate us. Have a feature suggestion? Share it here.

[burgholzer]

Overall this LGTM. Just a handful suggestions of how to slightly improve this PR.

To be honest I haven't 100% thought through whether this is guaranteed to work. It would be great to have some more tests that ensure it does.

As far as I got it, you are representing a don't care node by having all successors point to the same node. Sounds like a reasonable approach that's fairly easy to check. And I think normalization does not destroy that structure as it just divides every entry by the left-Most maximum value (which is 1).
Please correct me if I got some of that wrong.

[burgholzer]

I am not quite satisfied with the structure here. You can find detailed comments down below.

[burgholzer]

Still not happy, but close to.

[burgholzer]

Hope this will be the final one...