In short: If I have access to a real quantum computer, is there a possibility to control it using Q#?
Before you downvote this into nirvana because "there's no quantum computer available yet": I'm a physicist and our group is able to do real gates on real world qubits. I also have some background in programming (mostly C++).
So for the sake of this question, let's pretend someone has access to a real world device which is able to perform certain quantum operations on a number of qubits. Obviously the number of qubits might be limited and so might be the possible operations. Let's also say someone is proficient enough with Q# and if necessary C#. Is it possible to "redirect" the computation from the built in simulator to some real world device? Or would one have to basically rewrite the whole Q# library? Is there some way to define my own QuantumSimulator and how would I start doing that?
I poked around in the object browser a little.
The C# stubs that you use to call Q# operations look like this:
using (var sim = new QuantumSimulator())
{
var res = MyOperation.Run(sim, arg1, arg2).Result;
}
It appears that runtime environment was being passed as an argument to the operation. So I looked at the QuantumSimulator class and then its parent SimulatorBase which had this helpful comment and definition.
//
// Summary:
// A Base class for Simulators. It provides the infrastructure that makes it easy
// for a Simulator to become an OperationFactory (so the execution of an Operation
// can be tied to this simulator) and to manage the allocation of Qubits (via the
// QubitManager).
public abstract class SimulatorBase : AbstractFactory<AbstractOperation>, IOperationFactory
I'm interpreting this to mean anything that implements AbstractFactory<AbstractOperation> could be passed as an argument to an operation - thus tying the language structure to the specific run environment. While implementing a real quantum computer, it might be possible to use QuantumSimulator as an example - it looks like it mostly just implements concrete versions of primitive operations from the Microsoft.Quantum.Primitive namespace. (All the primitive operations appear to be abstract classes).
I think you'll probably have to concretely implement each of the primitives to appropriately control the qubits on your machine, but then you might be able to use the Q# language almost out of the box.
This is pretty speculative on my part, but it might be a good place to start.
EDIT: The four namespaces in the Prelude that will need to be modified are Microsoft.Quantum.Extensions.Bitwise
Microsoft.Quantum.Extensions.Convert
Microsoft.Quantum.Extensions.Math
According to Microsoft QDK, the approach Microsoft has taken is based on a coprocessor scheme. So we can safely assume that it is very similar to how a GPU or a FPGA works:
- the main program runs on main processor under well-familiar .NET framework;
- the coprocessor-specific subroutines are translated to the architecture-specific instructions just the same way as it is done for GPU, wrapped into arbitrary functions, and then uploaded to the physical device;
- and then called like they were normal functions.
The Q# standard library consists of two essential parts: The prelude (machine-specific operations and functions) and The canon (device-independent logic and wrappers).
So your runtime will need implement the types and functions of the Prelude.
In simple terms, yes. Microsoft has made Q# for the exact purpose that when people have access to real life Qubits and Quantum computers they can simply start using Q# as they already have the experience coding with it in the virtual environments. As to how you can do this, I have no idea, I suggest the best thing to do is to email Microsoft themselves they'll be pretty happy to help you out.
来源：https://stackoverflow.com/questions/47801787/is-it-possible-to-use-q-to-control-my-own-quantum-computer