summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--qsharp.html.markdown70
1 files changed, 42 insertions, 28 deletions
diff --git a/qsharp.html.markdown b/qsharp.html.markdown
index f778aea7..409eac4a 100644
--- a/qsharp.html.markdown
+++ b/qsharp.html.markdown
@@ -3,6 +3,7 @@ language: Q#
contributors:
- ["Vincent van Wingerden", "https://github.com/vivanwin"]
- ["Mariia Mykhailova", "https://github.com/tcNickolas"]
+ - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"]
filename: LearnQSharp.qs
---
@@ -13,6 +14,11 @@ This is the new outline
```C#
// Single-line comments start with //
+/
+Multi-line comments
+like so
+\
+
/////////////////////////////////////
// 1. Quantum data types and operators
@@ -22,27 +28,33 @@ This is the new outline
using (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 if you're running it on a classical simulator.
+ // 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();
- // If you want to change the state of a qubit, you have to do this by applying quantum gates to the qubit.
- H(q[0]); // This changes the state of the first qubit from |0⟩ (the initial state of allocated qubits) to (|0⟩ + |1⟩) / sqrt(2).
+ // If you want to change the state of a qubit
+ // you have to do this by applying quantum gates to the qubit.
+ H(q[0]); // This changes the state of the first qubit
+ // from |0⟩ (the initial state of allocated qubits) to (|0⟩ + |1⟩) / sqrt(2).
// q[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: a gate that is applied if all control qubits are in |1⟩ state.
- // The first argument is an array of control qubits, the second argument is the target qubit.
+ / 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 second argument is the target qubit.
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), you can use a library function.
+ / 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]);
- // To read the information from the quantum system, you use measurements.
- // Measurements return a value of Result data type: Zero or One.
- // You can print measurement results as a classical value.
+ / To read the information from the quantum system, you use measurements.
+ Measurements return a value of Result data type: Zero or One.
+ \ You can print measurement results as a classical value.
Message($"Measured {M(qs[0])}, {M(qs[1])}");
}
@@ -57,7 +69,8 @@ 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
+// 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
// Boolean type is called Bool
@@ -78,9 +91,9 @@ 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
-// 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
@@ -126,9 +139,10 @@ 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.
+/ 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
}
@@ -146,10 +160,10 @@ 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.
-// This will tell the compiler to generate the variants automatically.
+/ 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 {
X(source);
}
@@ -169,16 +183,16 @@ operation XGateDemo() : Unit {
// 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
- H(q); // Apply Hadamard gate to prepare equal superposition
- let result = M(q); // Measure the qubit to get Zero or One with 50/50 probability
- let bit = result == Zero ? 0 | 1; // Convert measurement result to an integer
- set bits w/= i <- bit; // Write generated bit to an array
+ 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
+ H(q); / Apply Hadamard gate prepares equal superposition
+ let result = M(q); / Measure the qubit to get 0 or 1 with 50/50 prob
+ let bit = result == Zero ? 0 | 1; / Convert measurement result to an integer
+ set bits w/= i <- bit; / Write generated bit to an array
}
}
- Message($"{bits}"); // Print the result
+ Message($"{bits}"); / Print the result
}
```