Add a `Replacement(simulator, operation)` attribute

[Strilanc]

Sometimes, you want different implementations of an operation for different simulators. For example, when computing resource estimates, you may want to omit operations that are only present to verify correct behavior (such as a measurement which is asserted to be zero). As another example, you may want to use a less efficient implementation in order to be compatible with a simulator as in https://quantumcomputing.stackexchange.com/questions/14659/simulator-dependent-implementations-in-q .

** Describe the solution you'd like **

Currently, to override an operation conditional on a simulator, you have to write C# code. It would be convenient to be able to specify the entire process inside of Q#, for example by annotating the operation with an attribute that says "if using simulator X, my implementation is specified by operation Y".

    @Replacement("ToffoliSimulator", _init_and_for_tof_sim)
    operation init_and(a: Qubit, b: Qubit, target: Qubit) : Unit is Adj {
        body(...) {
            CCNOT(a, b, target);
        }
        adjoint(...) {
            H(target);
            if (M(target) == One) {
                CZ(a, b);
            }
        }
    }
    operation _init_and_for_tof_sim(a: Qubit, b: Qubit, target: Qubit) : Unit is Adj {
        check_is_zero(target);
        CCNOT(a, b, target);
    }

[bettinaheim]

@Strilanc Thanks for the suggestion! We have indeed been discussing releasing something like this. Let me get back to you when I have more clarity regarding when and how we would want to do that.

[Strilanc]

For reference, here is my current workaround, which feels pretty good to me:

C-sharp setup:

#nullable enable

using System;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;

namespace XXX {
    public partial class is_toffoli_simulator {
        public class Native : is_toffoli_simulator {
            private Func<QVoid, bool> _body;

            public Native(IOperationFactory m) : base(m) {
                var b = m is ToffoliSimulator;
                _body = args => b;
            }

            public override Func<QVoid, bool> __Body__ => _body;
        }
    }
}

Q-sharp setup:

    operation is_toffoli_simulator() : Bool {
        // HACK: magic happens in `quol.cs` native override.
        return false;
    }

Example usage:

    operation init_and(a: Qubit, b: Qubit, target: Qubit) : Unit is Adj {
        body(...) {
            if (is_toffoli_simulator()) {
                check_is_zero(target);
            }
            CCNOT(a, b, target);
        }
        adjoint(...) {
            if (is_toffoli_simulator()) {
                CCNOT(a, b, target);
                check_is_zero(target);
            } else {
                H(target);
                if (M(target) == One) {
                    CZ(a, b);
                }
            }
        }
    }

The only downside is that is_toffoli_simulator prevents the creation of an automatic adjoint.

[msoeken]

@Strilanc A prototype for such an automatic rewrite step can currently be found here. But please be aware that we are currently discussing the details and that whole implementation is subject to change before it gets merged into the main branch.

[msoeken]

This feature has been addressed by #514