From bc3598b1cda3f06ade8285510edfa8c56580f63e Mon Sep 17 00:00:00 2001 From: Alex Hansen Date: Thu, 14 Nov 2024 13:20:21 -0800 Subject: [PATCH] [qsharp/en] update (#5177) --- qsharp.html.markdown | 205 ++++++++++++++++++++++--------------------- 1 file changed, 105 insertions(+), 100 deletions(-) diff --git a/qsharp.html.markdown b/qsharp.html.markdown index 04e697a4..8f3fff8c 100644 --- a/qsharp.html.markdown +++ b/qsharp.html.markdown @@ -4,6 +4,7 @@ contributors: - ["Vincent van Wingerden", "https://github.com/vivanwin"] - ["Mariia Mykhailova", "https://github.com/tcNickolas"] - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"] + - ["Alex Hansen", "https://github.com/sezna"] filename: LearnQSharp.qs --- @@ -16,35 +17,36 @@ Q# is a high-level domain-specific language which enables developers to write qu ///////////////////////////////////// // 1. Quantum data types and operators -// The most important part of quantum programs is qubits. +// The most important part of quantum programs is qubits. // In Q# type Qubit represents the qubits which can be used. // This will allocate an array of two new qubits as the variable qs. -using (qs = Qubit[2]) { +operation QuantumDataTypes() : Unit { + use qs = Qubit[2]; // The qubits have internal state that you cannot access to read or modify directly. - // You can inspect the current state of your quantum program + // You can inspect the current state of your quantum program // if you're running it on a classical simulator. // Note that this will not work on actual quantum hardware! - DumpMachine(); + Std.Diagnostics.DumpMachine(); // If you want to change the state of a qubit // you have to do this by applying quantum gates to the qubit. - H(qs[0]); // This changes the state of the first qubit - // from |0⟩ (the initial state of allocated qubits) - // to (|0⟩ + |1⟩) / sqrt(2). + H(qs[0]); // This changes the state of the first qubit + // from |0⟩ (the initial state of allocated qubits) + // to (|0⟩ + |1⟩) / sqrt(2). // qs[1] = |1⟩; - this does NOT work, you have to manipulate a qubit by using gates. // You can apply multi-qubit gates to several qubits. CNOT(qs[0], qs[1]); - // You can also apply a controlled version of a gate: + // You can also apply a controlled version of a gate: // a gate that is applied if all control qubits are in |1⟩ state. - // The first argument is an array of control qubits, + // The first argument is an array of control qubits, // the second argument is the target qubit. - Controlled Y([qs[0]], qs[1]); + Controlled Y([qs[0]], qs[1]); - // If you want to apply an anti-controlled gate - // (a gate that is applied if all control qubits are in |0⟩ state), + // If you want to apply an anti-controlled gate + // (a gate that is applied if all control qubits are in |0⟩ state), // you can use a library function. ApplyControlledOnInt(0, X, [qs[0]], qs[1]); @@ -58,96 +60,101 @@ using (qs = Qubit[2]) { ///////////////////////////////////// // 2. Classical data types and operators -// Numbers in Q# can be stored in Int, BigInt or Double. -let i = 1; // This defines an Int variable i equal to 1 -let bi = 1L; // This defines a BigInt variable bi equal to 1 -let d = 1.0; // This defines a Double variable d equal to 1 +function ClassicalDataTypes() : Unit { + // Numbers in Q# can be stored in Int, BigInt or Double. + let i = 1; // This defines an Int variable i equal to 1 + let bi = 1L; // This defines a BigInt variable bi equal to 1 + let d = 1.0; // This defines a Double variable d equal to 1 -// Arithmetic is done as expected, as long as the types are the same -let n = 2 * 10; // = 20 -// Q# does not have implicit type cast, -// so to perform arithmetic on values of different types, -// you need to cast type explicitly -let nd = IntAsDouble(2) * 1.0; // = 20.0 + // Arithmetic is done as expected, as long as the types are the same + let n = 2 * 10; // = 20 + // Q# does not have implicit type cast, + // so to perform arithmetic on values of different types, + // you need to cast type explicitly + let nd = Std.Convert.IntAsDouble(2) * 1.0; // = 20.0 -// Boolean type is called Bool -let trueBool = true; -let falseBool = false; + // Boolean type is called Bool + let trueBool = true; + let falseBool = false; -// Logic operators work as expected -let andBool = true and false; -let orBool = true or false; -let notBool = not false; + // Logic operators work as expected + let andBool = true and false; + let orBool = true or false; + let notBool = not false; -// Strings -let str = "Hello World!"; + // Strings + let str = "Hello World!"; -// Equality is == -let x = 10 == 15; // is false + // Equality is == + let x = 10 == 15; // is false -// Range is a sequence of integers and can be defined like: start..step..stop -let xi = 1..2..7; // Gives the sequence 1,3,5,7 + // Range is a sequence of integers and can be defined like: start..step..stop + let xi = 1..2..7; // Gives the sequence 1,3,5,7 -// Assigning new value to a variable: -// by default all Q# variables are immutable; -// if the variable was defined using let, you cannot reassign its value. + // Assigning new value to a variable: + // by default all Q# variables are immutable; + // if the variable was defined using let, you cannot reassign its value. -// When you want to make a variable mutable, you have to declare it as such, -// and use the set word to update value -mutable xii = true; -set xii = false; + // When you want to make a variable mutable, you have to declare it as such, + // and use the set word to update value + mutable xii = true; + set xii = false; -// You can create an array for any data type like this -let xiii = new Double[10]; + // You can create an array for any data type like this + let xiii = [0.0, size = 10]; -// Getting an element from an array -let xiv = xiii[8]; + // Getting an element from an array + let xiv = xiii[8]; -// Assigning a new value to an array element -mutable xv = new Double[10]; -set xv w/= 5 <- 1; + // Assigning a new value to an array element + mutable xv = [0.0, size = 10]; + set xv w/= 5 <- 1.0; +} ///////////////////////////////////// // 3. Control flow -// If structures work a little different than most languages -if (a == 1) { - // ... -} elif (a == 2) { - // ... -} else { - // ... -} +operation ControlFlow() : Unit { + let a = 1; + // If expressions support a true branch, elif, and else. + if (a == 1) { + // ... + } elif (a == 2) { + // ... + } else { + // ... + } + use qubits = Qubit[2]; -// Foreach loops can be used to iterate over an array -for (qubit in qubits) { - X(qubit); -} + // For loops can be used to iterate over an array + for qubit in qubits { + X(qubit); + } -// Regular for loops can be used to iterate over a range of numbers -for (index in 0 .. Length(qubits) - 1) { - X(qubits[index]); -} + // Regular for loops can be used to iterate over a range of numbers + for index in 0..Length(qubits) - 1 { + X(qubits[index]); + } -// While loops are restricted for use in classical context only -mutable index = 0; -while (index < 10) { - set index += 1; -} + // While loops are restricted for use in classical context only + mutable index = 0; + while (index < 10) { + set index += 1; + } -// Quantum equivalent of a while loop is a repeat-until-success loop. -// Because of the probabilistic nature of quantum computing sometimes -// you want to repeat a certain sequence of operations -// until a specific condition is achieved; you can use this loop to express this. -repeat { - // Your operation here + let success_criteria = true; + // Quantum equivalent of a while loop is a repeat-until-success loop. + // Because of the probabilistic nature of quantum computing sometimes + // you want to repeat a certain sequence of operations + // until a specific condition is achieved; you can use this loop to express this. + repeat { + // Your operation here + } until (success_criteria) // This could be a measurement to check if the state is reached + fixup { + // Resetting to the initial conditions, if required + } } -until (success criteria) // This could be a measurement to check if the state is reached -fixup { - // Resetting to the initial conditions, if required -} - ///////////////////////////////////// // 4. Putting it all together @@ -157,11 +164,11 @@ operation ApplyXGate(source : Qubit) : Unit { X(source); } -// If the operation implements a unitary transformation, you can define -// adjoint and controlled variants of it. -// The easiest way to do that is to add "is Adj + Ctl" after Unit. +// If the operation implements a unitary transformation, you can define +// adjoint and controlled variants of it. +// The easiest way to do that is to add "is Adj + Ctl" after Unit. // This will tell the compiler to generate the variants automatically. -operation ApplyXGateCA (source : Qubit) : Unit is Adj + Ctl { +operation ApplyXGateCA(source : Qubit) : Unit is Adj + Ctl { X(source); } @@ -169,20 +176,21 @@ operation ApplyXGateCA (source : Qubit) : Unit is Adj + Ctl { // To run Q# code, you can put @EntryPoint() before the operation you want to run first -@EntryPoint() operation XGateDemo() : Unit { - using (q = Qubit()) { - ApplyXGate(q); - } + use q = Qubit(); + ApplyXGate(q); } -// Here is a simple example: a quantum random number generator. +// Here is a simple example: a quantum random number generator. // We will generate a classical array of random bits using quantum code. -@EntryPoint() -operation QRNGDemo() : Unit { - mutable bits = new Int[5]; // Array we'll use to store bits - using (q = Qubit()) { // Allocate a qubit - for (i in 0 .. 4) { // Generate each bit independently +// Callables (functions or operations) named `Main` are used as entry points. +operation Main() : Unit { + mutable bits = [0, size = 5]; // Array we'll use to store bits + use q = Qubit(); + { + // Allocate a qubit + for i in 0..4 { + // Generate each bit independently H(q); // Hadamard gate sets equal superposition let result = M(q); // Measure qubit gets 0|1 with 50/50 prob let bit = result == Zero ? 0 | 1; // Convert measurement result to integer @@ -196,9 +204,6 @@ operation QRNGDemo() : Unit { ## Further Reading -The [Quantum Katas][1] offer great self-paced tutorials and programming exercises to learn quantum computing and Q#. +The Quantum Katas ([repo](https://github.com/microsoft/qsharp/tree/main/katas) [hosted tutorials](https://quantum.microsoft.com/en-us/tools/quantum-katas) offer great self-paced tutorials and programming exercises to learn quantum computing and Q#. -[Q# Documentation][2] is official Q# documentation, including language reference and user guides. - -[1]: https://github.com/microsoft/QuantumKatas -[2]: https://docs.microsoft.com/quantum/ +[Q# Documentation](https://docs.microsoft.com/quantum/) is official Q# documentation, including language reference and user guides.