They are available as library functions; see API documentation for the list of math functions. Usage examples can be found in Microsoft/Quantum repository.

In general, either the target is in a computational basis state, in which case nothing happens (except for the entanglement), or a minus state, in which case the phase is flipped. The thing that is difficult to understand it's what happens after you apply another Hadamard to the input, and the various states are made to interfere with each other. I had to trust Wikipedia for Deutsch-Jozsa and Bernstein-Vazirani, and I tried things almost at random for E2.

The usual ACM ICPC rules: initially the penalty is 0, and for each solved problem it is increased by submission time (since the start of the contest) + 20 minutes for each failed submission.

Indeed, for a four day contest with prices the tasks could have been a bit more challenging. I started 2 and half hours late, and the penalty hit I take is quite severe.

I can only guess that the reason behind measurement returning object of type Result instead of normal boolean is the concept of measurement itself. It is phisically dependent on orthogonal basis you are using to perform such an operation, something like if you were measuring your state in some direction rather than just getting some random 0 or 1. If your measurement basis was |+> and |->, qubit in state |0> now behaves like |->. And now with probability 0.5 you'll measure Zero (and your qubit collapsed to |->) or One (and your qubit is now |+>). Just like Java not having a generic pair class to enforce type safety with you creating your usecase specific class, same way measurement returns Result not Bool.

Edit: Q# operation M seems to measure in computational base (|0> and |1>)

It's not too much of an issue because you can use the BoolFromResult function to convert.

I also wanted to allocate zero qubits; having to special-case this seems like a flaw.

If you think of an allocated array as the pointer to the first element, it makes sense — you can't have a pointer to something that doesn't exist. Okay, you can make it a null pointer, but if the OS doesn't support "allocate me nothing and give me a pointer to that nothing", it'd still need special handling internally, you'd have to watch out not to free it, etc.

The null pointer is special. Ignoring that is often bad design.

Result is probably distinct from Bool because it actually represents two eigenvalues, not 1 and 0 or true and false. Up (Zero) and Down (One) would be even better names.

Custom invocation has C# driver which calls operation RunQsharp and prints its return. Whatever code you need to invoke, you have to call from that operation, creating inputs you need in it. If your code takes qubits as inputs, you have to allocate them in RunQsharp and pass them to your code.

Reserved for C#. There are so many C#-reserved keywords, holy shit.

Does it have break? i think not even that.

Submissions should be open for viewing now.

I tried to simulate your solution for k = 1 (N = 2**1 = 2 qubits), and for such an input code simplifies to:

operation Solve (qs : Qubit[]) : () //qs =  two qubits in state |0>
    {
        body
        {
            let N = 2;
            using (b = Qubit[1])
            {
                H(b[0]);
                X(b[0]);
                CNOT(b[0], qs[0]);
                X(b[0]);
                CNOT(b[0], qs[1]);
                H(b[0]);
                ResetAll(b);
            }
        }
    }

Or maybe I missed something? Otherwise before ResetAll(b) you'd get 1/2 (|001> + |010> + |101> — |110>) — first bit being b[0]. Since ResetAll performs measurement, if you measure One as b[0], your state is now |->. Maybe this is an answer to your question?

I won't bother with writing normalisation factors.

• For N = 2, immediately after using, you have (k = 1 so I'll only use b as the auxiliary qubit):
• Now you apply Hadamard:
• Loop iteration with i = 0:
  • Applying X to b:
  • Applying CX on q₀:
  • Applying X to b:
• Loop iteration with i = 1:
  • Flip does nothing since 1 = 2⁰
  • Applying CX on q₁:
  • Flip does nothing again
• Final Hadamard:

When you reset b, you reach either (measuring Zero) or (measuring One). You made a mistake somewhere or I made a mistake somewhere or both.

I allocate qubits in zero state, apply the participant's solution, then apply the adjoint of the reference solution and check in the end qubits are in zero state again (using AssertAllZero method which has access to the state in the simulator).

I guess you are talking about C2.

If you measure |0> then you get 0. If you measure |+> then you get 50/50. Therefore if you measure and get 1, it was |+>.

Since we need to cover both cases, we can choose to measure "along" |+> and use the same trick. (instead of measuring "along" axis we can perform a rotation a do a normal measurement).

            let r = RandomInt(2);
            if (r == 0) {
                if (M(q) == One) {
                    return 1;
                }
                return -1;
            }
            else {
                if (Measure([PauliX], [q]) == One) {
                    return 0;
                }
                return -1;

            }
      

I think it's this one, and ResearchGate allowed me to download it without logging in.

It specifies that Q# compiler should generate the adjoint (inverse) of this operation automatically, as described here. It is not actually required for the participant's solution, this line sneaked in from reference solution which does need it (the tester code applies adjoint of the reference solution to invert the transformation done by the submission, so it needs to know how to generate adjoint).

Aha this is cool! thank you!

How to pass a C# array int[] to the Q# operation as an input Int[]? Thanks.