@VashisthMalik_twitter The contest announcement has a lot of starting links, two good resources are https://docs.microsoft.com/quantum and https://github.com/Microsoft/QuantumKatas/, the latter have a lot of practice problems with solutions worked out. Enjoy the contest!
@githg22_gitlab: Taking a hint from the problem statement itself, I'd suggest that the last sentence is especially relevant here.
"This operation can be implemented using just the X gate and its controlled variants."
And I can't find a way to test it locally through python
I've got a small question, Can we apply the unwrapping operator on LittleEndian? I don't think we can do that because of the no-clone theorem, I can solve the increment problem with array of qubits, but cannot wrap my mind to do that on LittleEndian. I couldn't find any relevant operation in Microsoft.Quantum.Arithematic to apply X gate on Little Endian either...
Just write
!
Just write
register!
Stupid gitter
LittleEndian is basically a different name for Qubit[], literally no other difference
I mean, I get what you mean, but I still find it a bit uncomfortable without having to use
using()
Also, as a side question, does the changes that we make on the unwrapped array reflected automatically in the user-defined LittleEndian?
So umm
Cam you give a hint as to how you solved the problem?
I've been stuck at this for the past 24 hours
I hope it isn't against the protocol, say you've got N=3. On a paper, write down the values in LittleEndian format from 0 to 7 and then write down the required result, again in LittleEndian format. You'll notice something, one of the qubits will always flip no matter what while the others will flip if a certain condition is satisfied(hence the usage of Controlled X) I hope this will help you.
Also, I tried using the unwrap operator and I got a compilation error saying the expression can only be applied on user-defined type while LittleEndian is a custom user-defined(Microsoft.Quantum.Arithematic.LittleEndian)
Its not against the rules btw, in warmup you're free to discuss hints
like the expression?
For example
Yeah I solved C
Any hints?
C is actually similar to a problem in Quantum Katas
It's kind of a hack-y method
nevermind, I'm stupid.
wasted 24 hours on something this stupid
Were you writing LittleEndian instead of register?
@githg22_gitlab: If you allocate an extra qubit, then it has to be returned to |0⟩ at the end of the
using block. As you note, you can't use measurement to do that in an adjointable operation; given that resetting is a special case of measurement, the Reset operation will also fail to preserve adjointability. The trick is that you need to coherently reset the qubit to |0⟩ without measurement. You can do that because you know exactly what state it's in at the end of the using, and can unprepare it using only unitary operations. The within/apply feature of Q# or the ApplyWithCA operation will be very handy here.
By the way, @crazy4pi314 will be streaming with @bettinaheim about the Q# compiler today in a little under three hours if anyone is interested to join at https://twitch.tv/crazy4pi314. More details at https://twitter.com/crazy4pi314/status/1271837229221101569.
I know the difference between Identity and X gate and there adjoint are they themselves. But i did not understand coding part like this part "operation Solve (unitary : (Qubit => Unit is Adj+Ctl)) : Int " is in this part we are calling qubit to unitary ? Any resource to understand this will be helpful?
@VashisthMalik_twitter: The type of an operation that takes an input of type
'T and that returns an output of type 'U is written as 'T => 'U; thus, unitary : (Qubit = > Unit is Adj + Ctl) indicates that unitary takes a Qubit input and returns Unit. The is Adj + Ctl tells you that unitary is adjointable and controllable (very important for some of the contest problems!). In this case, we can read the signature of Solve as telling us that it takes an adjointable and controllable single-qubit operation, and returns an Int.