Q Sharp

<h2 id="history">History</h2>
<p>Historically, <a href="/facts/Microsoft_Research/04A5LpMI">Microsoft Research</a> had two teams interested in quantum computing: the QuArC team based in Redmond, Washington,<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> directed by <a href="/facts/Krysta_Svore/FIDg3h1N">Krysta Svore</a>, that explored the construction of quantum circuitry, and Station Q initially located in <a href="/facts/Santa_Barbara%2c_California/0LDgyx86">Santa Barbara</a> and directed by <a href="/facts/Michael_Freedman/FxESCuA7">Michael Freedman</a>, that explored <a href="/facts/Topological_quantum_computing/paJBK88q">topological quantum computing</a>.<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a><a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a>
</p><p>During a <a href="/facts/Microsoft_Ignite/shDoM0AY">Microsoft Ignite</a> Keynote on September 26, 2017, Microsoft announced that they were going to release a new programming language geared specifically towards quantum computers.<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> On December 11, 2017, Microsoft released Q# as a part of the Quantum Development Kit.<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a>
</p><p>At <a href="/facts/Build_2019/nVnk6tUD">Build 2019</a>, Microsoft announced that it would be open-sourcing the Quantum Development Kit, including its Q# <a href="/facts/Compiler/WNfCDFJe">compilers</a> and simulators.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a>
</p><p>To support Q#, Microsoft developed Quantum Intermediate Representation (QIR) in 2023 as a common interface between programming languages and target quantum processors. The company also announced a compiler extension that generates QIR from Q#.<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a>
</p><p><a href="/facts/Bettina_Heim/enY4oJY6">Bettina Heim</a> currently leads the Q# language development effort.<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a><a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a>
</p>
<h2 id="usage">Usage</h2>
<p>Q# is available as a separately downloaded extension for <a href="/facts/Visual_Studio/omNe6Lej">Visual Studio</a>,<a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a> but it can also be run as an independent tool from the <a href="/facts/Command_line/R9JpGmXQ">command line</a> or Visual Studio Code. Q# was introduced on Windows and is available on MacOS and Linux.<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a>
</p><p>The Quantum Development Kit includes a <a href="/facts/Quantum_simulator/x5fYot4j">quantum simulator</a> capable of running Q# and simulated 30 logical qubits.<a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a><a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a>
</p><p>In order to invoke the quantum simulator, another <a href="/facts/.NET_Framework/J6QDAUhP">.NET programming language</a>, usually <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, is used, which provides the (classical) input data for the simulator and reads the (classical) output data from the simulator.<a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a>
</p>
<h2 id="features">Features</h2>
<p>A primary feature of Q# is the ability to create and use <a href="/facts/Qubit/WveeEubw">qubits</a> for algorithms. As a consequence, some of the most prominent features of Q# are the ability to <a href="/facts/Quantum_entanglement/afzslwN0">entangle</a> and introduce <a href="/facts/Quantum_superposition/4z1UJg9o">superpositioning</a> to qubits via <a href="/facts/Controlled_NOT_gate/hP1y4K6d">controlled NOT gates</a> and <a href="/facts/Hadamard_gate/JFD5uojA">Hadamard gates</a>, respectively, as well as <a href="/facts/Toffoli_gate/WLaIv0qS">Toffoli Gates</a>, <a href="/facts/Pauli_matrices/BdeC2wos">Pauli X, Y, Z Gate</a>, and many more which are used for a variety of operations (See <a href="/facts/Quantum_logic_gate/EFV5sPCU">quantum logic gates</a>).
</p><p>The hardware stack that will eventually come together with Q# is expected to implement Qubits as <a href="/facts/Topological_quantum_computer/paJBK88q">topological qubits</a>. The quantum simulator that is shipped with the Quantum Development Kit today is capable of processing up to 32 qubits on a user machine and up to 40 qubits on <a href="/facts/Microsoft_Azure/CCnIHTHd">Azure</a>.<a class="footnote-ref" id="fnref:19" href="#fn:19"><sup>19</sup></a>
</p>
<h2 id="documentation-and-resources">Documentation and resources</h2>
<p>Currently, the resources available for Q# are scarce, but the official documentation is published: <a href="https://docs.microsoft.com/en-us/quantum/?view=qsharp-preview">Microsoft Developer Network: Q#</a>. <a href="https://github.com/Microsoft/Quantum/">Microsoft Quantum Github repository</a> is also a large collection of sample programs implementing a variety of Quantum algorithms and their tests.
</p><p>Microsoft has also hosted a Quantum Coding contest on <a href="/facts/Codeforces/CKz7fVI8">Codeforces</a>, called <a href="https://web.archive.org/web/20181119064628/https://codeforces.com/msqs2018">Microsoft Q# Coding Contest - Codeforces</a>, and also provided related material to help answer the questions in the blog posts, plus the detailed solutions in the tutorials.
</p><p>Microsoft hosts a set of learning exercises to help learn Q# on GitHub: <a href="https://github.com/Microsoft/QuantumKatas">microsoft/QuantumKatas</a> with links to resources, and answers to the problems.
</p>
<h2 id="syntax">Syntax</h2>
<p>Q# is syntactically related to both <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> and <a href="/facts/F_Sharp_(programming_language)/jdXHnYz5">F#</a> yet also has some significant differences.
</p>
<h3>Similarities with C#</h3>
<ul><li>Uses namespace for code isolation</li>
<li>All statements end with a ;</li>
<li>Curly braces are used for statements of scope</li>
<li><a href="/facts/Comment_(computer_programming)/Q8hHFq8h">Single line comments</a> are done using //</li>
<li>Variable data types such as Int Double String and Bool are similar, although capitalised (and Int is 64-bit)<a class="footnote-ref" id="fnref:20" href="#fn:20"><sup>20</sup></a></li>
<li>Qubits are allocated and disposed inside a using block.</li>
<li><a href="/facts/Lambda_function_(computer_programming)/2vdyE4zL">Lambda functions</a> are defined using the => operator.</li>
<li>Results are returned using the return keyword.</li></ul>
<h3>Similarities with F#</h3>
<ul><li>Variables are declared using either let or mutable<a class="footnote-ref" id="fnref:21" href="#fn:21"><sup>21</sup></a></li>
<li><a href="/facts/First-order_function/VjnjGbpt">First-order functions</a></li>
<li>Modules, which are imported using the open keyword</li>
<li>The datatype is declared after the variable name</li>
<li>The range operator ..</li>
<li>for … in loops</li>
<li>Every operation/function has a return value, rather than void. Instead of void, an empty <a href="/facts/Tuple/BI1HIxL8">Tuple</a> () is returned.</li>
<li>Definition of record datatypes (using the newtype keyword, instead of type).</li></ul>
<h3>Differences</h3>
<ul><li>Functions are declared using the function keyword</li>
<li>Operations on the quantum computer are declared using the operation keyword</li>
<li>Lack of multiline comments</li>
<li>Asserts instead of throwing exceptions</li>
<li>Documentation is written in <a href="/facts/Markdown/yAL6qk7M">Markdown</a> instead of <a href="/facts/XML/clNgUfWk">XML</a>-based documentation tags</li></ul>
<h2 id="example">Example</h2>

<p>The following source code is a <a href="/facts/Multiplexer/lVro0Sfz">multiplexer</a> from the official Microsoft Q# library repository.
</p>
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

namespace Microsoft.Quantum.Canon {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Arithmetic;
    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Math;

/// # Summary
    /// Applies a multiply-controlled unitary operation $U$ that applies a
    /// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
    ///
    /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
    ///
    /// # Input
    /// ## unitaryGenerator
    /// A tuple where the first element `Int` is the number of unitaries $N$,
    /// and the second element `(Int -> ('T => () is Adj + Ctl))`
    /// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
    /// operation $V_j$.
    ///
    /// ## index
    /// $n$-qubit control register that encodes number states $\ket{j}$ in
    /// little-endian format.
    ///
    /// ## target
    /// Generic qubit register that $V_j$ acts on.
    ///
    /// # Remarks
    /// `coefficients` will be padded with identity elements if
    /// fewer than $2^n$ are specified. This implementation uses
    /// $n-1$ auxiliary qubits.
    ///
    /// # References
    /// - [ *Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su*,
    ///      arXiv:1711.10980](https://arxiv.org/abs/1711.10980)
    operation MultiplexOperationsFromGenerator<'T>(unitaryGenerator : (Int, (Int -> ('T => Unit is Adj + Ctl))), index: LittleEndian, target: 'T) : Unit is Ctl + Adj {
        let (nUnitaries, unitaryFunction) = unitaryGenerator;
        let unitaryGeneratorWithOffset = (nUnitaries, 0, unitaryFunction);
        if Length(index!) == 0 {
            fail "MultiplexOperations failed. Number of index qubits must be greater than 0.";
        }
        if nUnitaries > 0 {
            let auxiliary = [];
            Adjoint MultiplexOperationsFromGeneratorImpl(unitaryGeneratorWithOffset, auxiliary, index, target);
        }
    }

/// # Summary
    /// Implementation step of `MultiplexOperationsFromGenerator`.
    /// # See Also
    /// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
    internal operation MultiplexOperationsFromGeneratorImpl<'T>(unitaryGenerator : (Int, Int, (Int -> ('T => Unit is Adj + Ctl))), auxiliary: Qubit[], index: LittleEndian, target: 'T)
    : Unit {
        body (...) {
            let nIndex = Length(index!);
            let nStates = 2^nIndex;

let (nUnitaries, unitaryOffset, unitaryFunction) = unitaryGenerator;

let nUnitariesLeft = MinI(nUnitaries, nStates / 2);
            let nUnitariesRight = MinI(nUnitaries, nStates);

let leftUnitaries = (nUnitariesLeft, unitaryOffset, unitaryFunction);
            let rightUnitaries = (nUnitariesRight - nUnitariesLeft, unitaryOffset + nUnitariesLeft, unitaryFunction);

let newControls = LittleEndian(Most(index!));

if nUnitaries > 0 {
                if Length(auxiliary) == 1 and nIndex == 0 {
                    // Termination case

(Controlled Adjoint (unitaryFunction(unitaryOffset)))(auxiliary, target);
                } elif Length(auxiliary) == 0 and nIndex >= 1 {
                    // Start case
                    let newauxiliary = Tail(index!);
                    if nUnitariesRight > 0 {
                        MultiplexOperationsFromGeneratorImpl(rightUnitaries, [newauxiliary], newControls, target);
                    }
                    within {
                        X(newauxiliary);
                    } apply {
                        MultiplexOperationsFromGeneratorImpl(leftUnitaries, [newauxiliary], newControls, target);
                    }
                } else {
                    // Recursion that reduces nIndex by 1 and sets Length(auxiliary) to 1.
                    let controls = [Tail(index!)] + auxiliary;
                    use newauxiliary = Qubit();
                    use andauxiliary = Qubit[MaxI(0, Length(controls) - 2)];
                    within {
                        ApplyAndChain(andauxiliary, controls, newauxiliary);
                    } apply {
                        if nUnitariesRight > 0 {
                            MultiplexOperationsFromGeneratorImpl(rightUnitaries, [newauxiliary], newControls, target);
                        }
                        within {
                            (Controlled X)(auxiliary, newauxiliary);
                        } apply {
                            MultiplexOperationsFromGeneratorImpl(leftUnitaries, [newauxiliary], newControls, target);
                        }
                    }
                }
            }
        }
        adjoint auto;
        controlled (controlRegister, ...) {
            MultiplexOperationsFromGeneratorImpl(unitaryGenerator, auxiliary + controlRegister, index, target);
        }
        adjoint controlled auto;
    }

/// # Summary
    /// Applies multiply-controlled unitary operation $U$ that applies a
    /// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
    ///
    /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
    ///
    /// # Input
    /// ## unitaryGenerator
    /// A tuple where the first element `Int` is the number of unitaries $N$,
    /// and the second element `(Int -> ('T => () is Adj + Ctl))`
    /// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
    /// operation $V_j$.
    ///
    /// ## index
    /// $n$-qubit control register that encodes number states $\ket{j}$ in
    /// little-endian format.
    ///
    /// ## target
    /// Generic qubit register that $V_j$ acts on.
    ///
    /// # Remarks
    /// `coefficients` will be padded with identity elements if
    /// fewer than $2^n$ are specified. This version is implemented
    /// directly by looping through n-controlled unitary operators.
    operation MultiplexOperationsBruteForceFromGenerator<'T>(unitaryGenerator : (Int, (Int -> ('T => Unit is Adj + Ctl))), index: LittleEndian, target: 'T)
    : Unit is Adj + Ctl {
        let nIndex = Length(index!);
        let nStates = 2^nIndex;
        let (nUnitaries, unitaryFunction) = unitaryGenerator;
        for idxOp in 0..MinI(nStates,nUnitaries) - 1 {
            (ControlledOnInt(idxOp, unitaryFunction(idxOp)))(index!, target);
        }
    }

/// # Summary
    /// Returns a multiply-controlled unitary operation $U$ that applies a
    /// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
    ///
    /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
    ///
    /// # Input
    /// ## unitaryGenerator
    /// A tuple where the first element `Int` is the number of unitaries $N$,
    /// and the second element `(Int -> ('T => () is Adj + Ctl))`
    /// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
    /// operation $V_j$.
    ///
    /// # Output
    /// A multiply-controlled unitary operation $U$ that applies unitaries
    /// described by `unitaryGenerator`.
    ///
    /// # See Also
    /// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
    function MultiplexerFromGenerator(unitaryGenerator : (Int, (Int -> (Qubit[] => Unit is Adj + Ctl)))) : ((LittleEndian, Qubit[]) => Unit is Adj + Ctl) {
        return MultiplexOperationsFromGenerator(unitaryGenerator, _, _);
    }

/// # Summary
    /// Returns a multiply-controlled unitary operation $U$ that applies a
    /// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
    ///
    /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
    ///
    /// # Input
    /// ## unitaryGenerator
    /// A tuple where the first element `Int` is the number of unitaries $N$,
    /// and the second element `(Int -> ('T => () is Adj + Ctl))`
    /// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
    /// operation $V_j$.
    ///
    /// # Output
    /// A multiply-controlled unitary operation $U$ that applies unitaries
    /// described by `unitaryGenerator`.
    ///
    /// # See Also
    /// - Microsoft.Quantum.Canon.MultiplexOperationsBruteForceFromGenerator
    function MultiplexerBruteForceFromGenerator(unitaryGenerator : (Int, (Int -> (Qubit[] => Unit is Adj + Ctl)))) : ((LittleEndian, Qubit[]) => Unit is Adj + Ctl) {
        return MultiplexOperationsBruteForceFromGenerator(unitaryGenerator, _, _);
    }

/// # Summary
    /// Computes a chain of AND gates
    ///
    /// # Description
    /// The auxiliary qubits to compute temporary results must be specified explicitly.
    /// The length of that register is `Length(ctrlRegister) - 2`, if there are at least
    /// two controls, otherwise the length is 0.
    internal operation ApplyAndChain(auxRegister : Qubit[], ctrlRegister : Qubit[], target : Qubit)
    : Unit is Adj {
        if Length(ctrlRegister) == 0 {
            X(target);
        } elif Length(ctrlRegister) == 1 {
            CNOT(Head(ctrlRegister), target);
        } else {
            EqualityFactI(Length(auxRegister), Length(ctrlRegister));
            let controls1 = ctrlRegister[0..0] + auxRegister;
            let controls2 = Rest(ctrlRegister);
            let targets = auxRegister + [target];
            ApplyToEachA(ApplyAnd, Zipped3(controls1, controls2, targets));
        }
    }
}

<h2 id="external-links">External links</h2>
<ul><li><a href="https://docs.microsoft.com/en-us/azure/quantum/">Official website</a></li>
<li><a href="https://github.com/microsoft/qsharp-language">qsharp-language</a> on <a href="/facts/GitHub/n1hNCsc3">GitHub</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>QuantumWriter. "The Q# Programming Language". docs.microsoft.com. Retrieved 2017-12-11. <a href="https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview" target="_blank">https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"Announcing the Microsoft Quantum Development Kit". Retrieved 2017-12-11. <a href="https://cloudblogs.microsoft.com/quantum/2017/12/11/announcing-microsoft-quantum-development-kit/" target="_blank">https://cloudblogs.microsoft.com/quantum/2017/12/11/announcing-microsoft-quantum-development-kit/</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Microsoft makes play for next wave of computing with quantum computing toolkit". Ars Technica. 25 Sep 2017. Retrieved 2024-09-04. <a href="https://arstechnica.com/gadgets/2017/09/microsoft-quantum-toolkit/" target="_blank">https://arstechnica.com/gadgets/2017/09/microsoft-quantum-toolkit/</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"Quantum Computers Barely Exist—Here's Why We're Writing Languages for Them Anyway". MIT Technology Review. 22 Dec 2017. Retrieved 2024-09-04. <a href="https://www.technologyreview.com/2017/12/22/3662/quantum-computers-barely-exist-heres-why-were-writing-languages-for-them-anyway/" target="_blank">https://www.technologyreview.com/2017/12/22/3662/quantum-computers-barely-exist-heres-why-were-writing-languages-for-them-anyway/</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"Solving the quantum many-body problem with artificial neural networks". Microsoft Azure Quantum. 15 February 2017. <a href="https://cloudblogs.microsoft.com/quantum/2017/02/15/solving-the-quantum-many-body-problem-with-artificial-neural-networks/" target="_blank">https://cloudblogs.microsoft.com/quantum/2017/02/15/solving-the-quantum-many-body-problem-with-artificial-neural-networks/</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>Scott Aaronson's blog, 2013, 'Microsoft: From QDOS to QMA in less than 35 years', https://scottaaronson.blog/?p=1471 <a href="/wiki/Scott_Aaronson" target="_blank">/wiki/Scott_Aaronson</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>"What are the Q# programming language & QDK? - Azure Quantum". learn.microsoft.com. 12 January 2024. <a href="https://learn.microsoft.com/en-us/azure/quantum/overview-what-is-qsharp-and-qdk" target="_blank">https://learn.microsoft.com/en-us/azure/quantum/overview-what-is-qsharp-and-qdk</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"Microsoft announces quantum computing programming language". Retrieved 2017-12-14. <a href="https://cloudblogs.microsoft.com/quantum/2017/09/26/microsoft-announces-quantum-computing-programming-language/" target="_blank">https://cloudblogs.microsoft.com/quantum/2017/09/26/microsoft-announces-quantum-computing-programming-language/</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>"Announcing the Microsoft Quantum Development Kit". Retrieved 2017-12-11. <a href="https://cloudblogs.microsoft.com/quantum/2017/12/11/announcing-microsoft-quantum-development-kit/" target="_blank">https://cloudblogs.microsoft.com/quantum/2017/12/11/announcing-microsoft-quantum-development-kit/</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>Microsoft is open-sourcing its Quantum Development Kit <a href="https://venturebeat.com/2019/05/06/microsoft-open-sourcing-quantum-development-kit/" target="_blank">https://venturebeat.com/2019/05/06/microsoft-open-sourcing-quantum-development-kit/</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>Krill, Paul (29 Sep 2020). "Microsoft taps LLVM for quantum computing". InfoWorld. Retrieved 2024-09-04. <a href="https://www.infoworld.com/article/2260508/microsoft-taps-llvm-for-quantum-computing.html" target="_blank">https://www.infoworld.com/article/2260508/microsoft-taps-llvm-for-quantum-computing.html</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>"The Women of QuArC". 30 March 2019. <a href="https://devblogs.microsoft.com/qsharp/the-women-of-quarc/" target="_blank">https://devblogs.microsoft.com/qsharp/the-women-of-quarc/</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>"Intro to Q# - Intro to Quantum Software Development". stem.mitre.org. <a href="https://stem.mitre.org/quantum/software-tools/intro-qsharp.html" target="_blank">https://stem.mitre.org/quantum/software-tools/intro-qsharp.html</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
<li id="fn:14"><p>QuantumWriter. "Setting up the Q# development environment". docs.microsoft.com. Retrieved 2017-12-14. <a href="https://docs.microsoft.com/en-us/quantum/quantum-installconfig?view=qsharp-preview" target="_blank">https://docs.microsoft.com/en-us/quantum/quantum-installconfig?view=qsharp-preview</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li>
<li id="fn:15"><p>Coppock, Mark (26 Feb 2018). "Microsoft's quantum computing language is now available for MacOS". Digital Trends. Retrieved 2024-09-04. <a href="https://www.digitaltrends.com/computing/microsoft-quantum-computing-q-available-macos-linux/" target="_blank">https://www.digitaltrends.com/computing/microsoft-quantum-computing-q-available-macos-linux/</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li>
<li id="fn:16"><p>Akdogan, Erman (23 October 2022). "Quantum computing is coming for finance & crypto". Medium. <a href="https://medium.datadriveninvestor.com/quantum-computing-is-coming-for-finance-crypto-b56c0255cb09" target="_blank">https://medium.datadriveninvestor.com/quantum-computing-is-coming-for-finance-crypto-b56c0255cb09</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li>
<li id="fn:17"><p>Melanson, Mike (16 Dec 2017). "This Week in Programming: Get Quantum with Q Sharp". The New Stack. Retrieved 2024-09-04. <a href="https://thenewstack.io/week-programming-get-quantum-q-sharp/" target="_blank">https://thenewstack.io/week-programming-get-quantum-q-sharp/</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li>
<li id="fn:18"><p>"This Week in Programming: Get Quantum with Q Sharp". The New Stack. 16 December 2017. <a href="https://thenewstack.io/week-programming-get-quantum-q-sharp/" target="_blank">https://thenewstack.io/week-programming-get-quantum-q-sharp/</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li>
<li id="fn:19"><p>"Microsoft previews quantum computing development kit". CIO. <a href="https://www2.cio.com.au/article/631142/microsoft-previews-quantum-computing-development-kit/" target="_blank">https://www2.cio.com.au/article/631142/microsoft-previews-quantum-computing-development-kit/</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></p></li>
<li id="fn:20"><p>"Types in Q# - Microsoft Quantum". docs.microsoft.com. 27 July 2022. <a href="https://docs.microsoft.com/en-us/quantum/user-guide/language/types" target="_blank">https://docs.microsoft.com/en-us/quantum/user-guide/language/types</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></p></li>
<li id="fn:21"><p>QuantumWriter. "The Q# Programming Language". docs.microsoft.com. Retrieved 2017-12-11. <a href="https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview" target="_blank">https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></p></li>
</ol>

Q Sharp open-in-new

Q Sharp