{}
+""".format(self.data)
+
+class Task(WrappedCLRObject):
+ _detailed_repr = False
+
+ @property
+ def _friendly_name(self):
+ return "Asynchronous {} Task".format(
+ self.clr_type.GetGenericArguments()[0]
+ )
+
+ def result(self):
+ # Wait for the response first. This should be implied by self.Result,
+ # but we've seen some bugs occur related to that.
+ self.clr_object.Wait()
+ return wrap_clr_object(self.clr_object.Result)
+
+class Simulator(WrappedCLRObject):
+ _friendly_name = "Simulator"
+
+ def __init__(self, clr_simulator):
+ if isinstance(clr_simulator, CLR_METATYPE):
+ clr_simulator = clr_simulator()
+ super(Simulator, self).__init__(clr_simulator)
+
+ # Register a delegate to handle Message calls.
+ self.clr_object.OnLog += SimulatorOutput.display_output
+
+ def get(self, clr_type):
+ return Callable(self, self.clr_object.Get[clr_type, clr_type]())
+
+ def run(self, clr_type, *args):
+ if isinstance(clr_type, Callable):
+ # Check if the passed in type is already wrapped in a Callable Python
+ # class.
+ return clr_type(*args)
+ else:
+ # We need to get the callable ourselves, then.
+ callable = self.get(clr_type)
+ return callable(*args)
+
+class QuantumSimulator(Simulator):
+ _friendly_name = "Quantum Simulator"
+ def __init__(self):
+ super(QuantumSimulator, self).__init__(mqss.QuantumSimulator)
+
+class Callable(WrappedCLRObject):
+ _detailed_repr = False
+ _parent = None
+ _include_plain_repr = False
+
+ @property
+ def _friendly_name(self):
+ # TODO: extract operation signature!
+ return self.ToString()
+
+ def __init__(self, parent, clr_callable):
+ self._parent = parent
+ super(Callable, self).__init__(clr_callable)
+
+ def __call__(self, *args):
+ output = self.clr_object.Run(
+ unwrap_clr(self._parent),
+ *map(unwrap_clr, args)
+ )
+
+ if isinstance(type(output), CLR_METATYPE):
+ # Try to wrap the output as best as we can.
+ # We provide convienence wrappers for a few, so we call the
+ # single-dispatched convienence function above.
+ return wrap_clr_object(output)
+ else:
+ return output
diff --git a/Interoperability/python/qsharp/__main__.py b/Interoperability/python/qsharp/__main__.py
new file mode 100644
index 000000000000..e9bbfa67a5a4
--- /dev/null
+++ b/Interoperability/python/qsharp/__main__.py
@@ -0,0 +1,19 @@
+#!/bin/env python
+# -*- coding: utf-8 -*-
+##
+# __main__.py: Main script for the Q# interoperability package.
+##
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+##
+
+import qsharp
+
+from qsharp.tomography import single_qubit_process_tomography
+from Microsoft.Quantum.Primitive import I
+
+qsim = qsharp.QuantumSimulator()
+noise_channel = qsim.get(I)
+estimation_results = single_qubit_process_tomography(qsim, noise_channel, n_measurements=2000)
+
+print(estimation_results['est_channel'])
diff --git a/Interoperability/python/qsharp/clr_wrapper.py b/Interoperability/python/qsharp/clr_wrapper.py
new file mode 100644
index 000000000000..1785d26bb3a5
--- /dev/null
+++ b/Interoperability/python/qsharp/clr_wrapper.py
@@ -0,0 +1,190 @@
+
+#!/bin/env python
+# -*- coding: utf-8 -*-
+##
+# clr_wrapper.py: Classes to wrap CLR objects to provide Jupyter integration.
+##
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+##
+
+
+## IMPORTS ###################################################################
+
+# Standard Library Imports #
+
+from abc import ABCMeta, abstractproperty
+from random import randrange
+
+# CLR Imports #
+
+import clr
+import System
+
+# External Python Imports #
+
+try:
+ from IPython.display import display
+except ImportError:
+ def display(value):
+ pass
+
+## STYLESHEETS ###############################################################
+# We load a custom stylesheet into Jupyter Notebook to allow formatting
+# prettier CLR representation tables.
+class Stylesheet(object):
+ def __init__(self, style):
+ self.style = style
+ def _repr_html_(self):
+ return "".format(self.style)
+ def __repr__(self):
+ return "" # We want to be invisible if we're not in Jupyter!
+
+display(Stylesheet("""
+ .clr-repr-table td {
+ text-align: left;
+ }
+
+ div.output_area pre.simulator-output {
+ border-left: solid 12px #409AE1;
+ padding-left: 4px;
+ margin-left: -4px
+ }
+"""))
+
+## CONSTANTS #################################################################
+
+# We find and record the metatype associated with Python representations of
+# CLR types. Since this metatype is not directly exposed by the Python.NET
+# API, we can find it by asking for the type of an Object type that we are
+# guaranteed exists.
+
+#: The metatype common to all Python representations of CLR types.
+CLR_METATYPE = type(System.Object)
+
+## CLASSES ###################################################################
+
+class WrappedCLRObject(object):
+ _detailed_repr = True
+ _friendly_name = "Wrapped CLR Object"
+ _include_plain_repr = True
+
+ def __init__(self, clr_object):
+ self._clr_object = clr_object
+
+ @property
+ def clr_object(self):
+ return self._clr_object
+
+ @property
+ def clr_type(self):
+ return self.clr_object.GetType()
+
+ def __getattr__(self, attr):
+ # Forward upper-cased attributes to the underlying CLR
+ # object.
+ if str.isupper(attr[0]):
+ return getattr(self.clr_object, attr)
+ else:
+ # This is only called on last resort, so we can raise
+ # the exception here without breaking anything.
+ raise AttributeError("{0.__class__} object has no attribute {1}".format(self, attr))
+
+
+ def __repr__(self):
+ try:
+ return "<{ty_self.__name__}({self.clr_type.FullName}) at 0x{id_self:x}>".format(ty_self=type(self), self=self, id_self=id(self))
+ except:
+ return "<{ty_self.__module__}{ty_self.__name__} at 0x{id_self:x}>".format(ty_self=type(self), id_self=id(self))
+
+ def __str__(self):
+ return self.clr_object.ToString()
+
+ def _method_list(self):
+ clr_type = self.clr_type
+ methods = [
+ "{0} {1}({2})".format(
+ method.ReturnType.Name,
+ method.Name,
+ ", ".join(
+ "{param.ParameterType.Name}<{contents}> {param.Name}".format(
+ param=param,
+ contents=', '.join(map(str, param.ParameterType.GenericTypeArguments))
+ )
+ for param in method.GetParameters()
+ )
+ )
+ for method in clr_type.GetMethods()
+ ]
+
+ if methods:
+ return """
+ {}{}| + Python type + | ++ {ty_self.__module__}.{ty_self.__name__} + | +
| + CLR type + | ++ {self.clr_type.FullName} + | +
| + Assembly name + | + ++ {self.clr_type.Assembly.FullName} + | +
{}
+ \n",
+ " Microsoft.Quantum.Simulation.Simulators.QuantumSimulator\n", + " | \n",
+ " |
| \n", + " Python type\n", + " | \n", + "\n", + " qsharp.QuantumSimulator\n", + " | \n", + "
| \n", + " CLR type\n", + " | \n", + "\n", + " Microsoft.Quantum.Simulation.Simulators.QuantumSimulator\n", + " | \n", + "
| \n", + " Assembly name\n", + " | \n", + "\n", + "\n", + " Microsoft.Quantum.Simulation.Simulators, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5\n", + " | \n", + "
| \n", + " Methods\n", + " | \n", + "\n", + "UInt32 get_Seed() | \n",
+ "\n",
+ "
String get_Name() | |
Void Dispose() | |
Void add_OnLog(Action`1 | |
Void remove_OnLog(Action`1 | |
IQubitManager get_QubitManager() | |
I Get() | |
Void Validate(AbstractOperation<> op) | |
Task`1 Run(I<> args) | |
Void CheckQubit(Qubit<> q, String<> qubitName) | |
Void CheckQubits(QArray`1 | |
Void StartOperation(String<> operationName, OperationFunctor<> functor, Object<> inputValue) | |
Void EndOperation(String<> operationName, OperationFunctor<> functor, Object<> resultValue) | |
Void Register(Type<> original, Type<> replace, Type<> signature) | |
Object GetInstance(Type<> t) | |
Boolean CanCache(AbstractOperation<> obj) | |
String ToString() | |
Boolean Equals(Object<> obj) | |
Int32 GetHashCode() | |
Type GetType() |
| \n", + " Python type\n", + " | \n", + "\n", + " qsharp.Callable\n", + " | \n", + "
| \n", + " CLR type\n", + " | \n", + "\n", + " Microsoft.Quantum.Samples.Python.HelloWorld\n", + " | \n", + "
| \n", + " Assembly name\n", + " | \n", + "\n", + "\n", + " PythonInterop, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\n", + " | \n", + "
Hello, world! PauliZ\n" + ], + "text/plain": [ + "'Hello, world! PauliZ'" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qsim.run(hello_world, qsharp.Pauli.Z).Wait()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To obtain the output from a Q# operation or function, we must use the `result` function, since outputs are wrapped in .NET asynchronous tasks.\n", + "These tasks are wrapped in a future-like object for convienence." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " Wrapped CLR Object\n", + "
\n",
+ " Microsoft.Quantum.Samples.Python.NoisyHadamardChannelImpl((0.1,_))\n", + " | \n",
+ " |
| \n", + " Python type\n", + " | \n", + "\n", + " qsharp.clr_wrapper.WrappedCLRObject\n", + " | \n", + "
| \n", + " CLR type\n", + " | \n", + "\n", + " Microsoft.Quantum.Simulation.Core.PartialUnitary`2[[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5],[System.ValueTuple`2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5]], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]\n", + " | \n", + "
| \n", + " Assembly name\n", + " | \n", + "\n", + "\n", + " Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5\n", + " | \n", + "
| \n", + " Methods\n", + " | \n", + "\n", + "Type[] get_Dependencies() | \n",
+ "\n",
+ "
Operation`2 get_BaseOp() | |
Func`2 get_Mapper() | |
Func`2 get_Body() | |
Func`2 get_AdjointBody() | |
Func`2 get_ControlledBody() | |
Func`2 get_ControlledAdjointBody() | |
List`1 GetQubits() | |
String ToString() | |
QVoid Apply(Qubit<> args) | |
Object Partial(Object<> partialTuple) | |
IOperationFactory get_Factory() | |
Boolean Equals(Object<> obj) | |
Int32 GetHashCode() | |
Type GetType() |