**Q 샤프**(Q#)는 양자 알고리즘을 표현하기 위해 사용되는 도메인 특화 언어이다.

## 예시
다음의 소스 코드는 공식 마이크로소프트 Q# 라이브러리 저장소에서 가져온 멀티플렉서이다.

// 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 Unit is Adj + Ctl))), index: LittleEndian, target: 'T) : Unit is Ctl + Adj {
 let  = unitaryGenerator;
 let unitaryGeneratorWithOffset = ;
 if Length(index!) == 0 {
 fail "MultiplexOperations failed. Number of index qubits must be greater than 0.";
 if nUnitaries > 0 {
 let auxiliary = [];
 Adjoint MultiplexOperationsFromGeneratorImpl;

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

 let  = unitaryGenerator;

 let nUnitariesLeft = MinI;
 let nUnitariesRight = MinI;

 let leftUnitaries = ;
 let rightUnitaries = ;

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

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

 (Controlled Adjoint (unitaryFunction(unitaryOffset)));
 // Start case
 let newauxiliary = Tail(index!);
 if nUnitariesRight > 0 {
 MultiplexOperationsFromGeneratorImpl;
 within {
 X(newauxiliary);
 MultiplexOperationsFromGeneratorImpl;
 // 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;
 if nUnitariesRight > 0 {
 MultiplexOperationsFromGeneratorImpl;
 within {
 (Controlled X);
 MultiplexOperationsFromGeneratorImpl;
 adjoint auto;
 controlled  {
 MultiplexOperationsFromGeneratorImpl;
 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 Unit is Adj + Ctl))), index: LittleEndian, target: 'T)
 let nIndex = Length(index!);
 let nStates = 2^nIndex;
 let  = unitaryGenerator;
 for idxOp in 0..MinI - 1 {
 (ControlledOnInt(idxOp, unitaryFunction(idxOp)));

 /// # 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)))) : ( => Unit is Adj + Ctl) {
 return MultiplexOperationsFromGenerator;

 /// # 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)))) : ( => Unit is Adj + Ctl) {
 return MultiplexOperationsBruteForceFromGenerator;

 /// # 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
 if Length(ctrlRegister) == 0 {
 X(target);
 CNOT(Head(ctrlRegister), target);
 EqualityFactI(Length(auxRegister), Length(ctrlRegister) - 2, "Unexpected number of auxiliary qubits");
 let controls1 = ctrlRegister[0..0] + auxRegister;
 let controls2 = Rest(ctrlRegister);
 let targets = auxRegister + [target];
 ApplyToEachA(ApplyAnd, Zipped3);