We just posted a Quantum Computing course on the freeCodeCamp.org YouTube channel. This course, created by Michael from Quantum Soar, is designed to provide a solid foundation in quantum computing, guiding you from the basics to a thorough understanding of popular quantum algorithms.

Unlike classical computers, which use bits as the smallest unit of data (0 or 1), quantum computers use qubits. Qubits can represent and store data in multiple states simultaneously thanks to a property known as superposition. Additionally, quantum entanglement allows qubits that are entangled to be correlated in such a way that the state of one qubit can depend on the state of another, even across large distances. These properties enable quantum computers to solve certain types of problems much more efficiently than classical computers.

Here are some reasons you may want to learn about Quantum Computing:

1. Future Technology: Quantum computing is at the forefront of technological innovation. Learning about it now can place you ahead of the curve as the field grows.

2. Problem-Solving: Quantum computers are capable of solving complex problems in areas such as cryptography, optimization, and simulations, which are currently beyond the reach of classical computers.

3. Career Opportunities: As quantum computing technology evolves, there will be an increasing demand for professionals with expertise in this field.

4. Intellectual Challenge: Understanding quantum computing involves grasping complex mathematical and physical concepts, which could be a rewarding intellectual challenge.

The course is divided into two main sections: foundational mathematics and the mechanics of quantum computers. Here’s what you can expect:

Section 1: Essential Mathematics

• 0.1 Introduction to Complex Numbers

• 0.2 Complex Numbers on the Number Plane

• 0.3 Introduction to Matrices

• 0.4 Matrix Multiplication to Transform a Vector

• 0.5 Unitary and Hermitian Matrices

• 0.6 Eigenvectors and Eigenvalues

Section 2: Mechanics of Quantum Computers

• 1.1 Introduction to Qubits and Superposition

• 1.2 Introduction to Dirac Notation

• 1.3 Representing a Qubit on the Bloch Sphere

• 1.4 Manipulating a Qubit with Single Qubit Gates

• 1.5 Introduction to Phase

• 1.6 The Hadamard Gate and +, -, i, -i States

• 1.7 The Phase Gates (S and T Gates)

Advanced Topics and Algorithms

• 2.1 Representing Multiple Qubits Mathematically

• 2.2 Quantum Circuits

• 2.3 Multi-Qubit Gates

• 2.4 Measuring Singular Qubits

• 2.5 Quantum Entanglement and the Bell States

• 2.6 Phase Kickback

• 3.1 Superdense Coding

• 3.2.A Classical Operations Prerequisites

• 3.2.B Functions on Quantum Computers

• 3.3 Deutsch's Algorithm

• 3.4 Deutsch-Jozsa Algorithm

• 3.5 Bernstein-Vazirani Algorithm

• 3.6 Quantum Fourier Transform (QFT)

• 3.7 Quantum Phase Estimation

• 3.8 Shor's Algorithm

This comprehensive course is a great opportunity to get acquainted with the world of quantum computing. By the end of the course, you will have a strong understanding of both the theoretical and practical aspects of quantum computing.

Watch the full course on the freeCodeCamp.org YouTube channel (2-hour watch).

Google recently released a paper showing that its quantum processor, called Sycamore, solved a computing problem in 200 seconds that would have taken the world's best supercomputer 10,000 years to solve.

And Google says this is just the beginning of what quantum computers will be able to do.

What is quantum computing?

Quantum computing is a theory of how to build computers.

Quantum computers perform operations on data using ideas from quantum mechanics, such as superposition and entanglement.

In quantum computation, quantum properties are used to perform operations on data and represent it. This allows quantum computers to process massive and complex datasets more quickly than classical computers like the one you're reading this article with.

Bits VS Qubits

Classical computers store information in binary. It's always possible to know the exact state of a piece of data, or "bit."

Each bit can be either on or off.

Quantum computing, however, uses qubits instead of bits. Qubits can be either on or off. Or they can be on and off at the same time.

Quantum computation uses probabilities. You don't always know the exact state of the data. This uncertainty is what makes quantum computing so powerful.

Since quantum computers use the fundamentals of quantum mechanics, they can solve complex computations very quickly. While quantum computers are already used for some purposes such as cybersecurity, they have not been able to do much so far.

A lot of the ideas behind quantum computing are theoretical and it has been challenging to implement them on a large scale. However, this is starting to change.

So what did Google actually accomplish?

First of all, this is not necessarily the first sign that robots are about to enslave humanity. The computing problem solved with quantum computing was not actually that useful but it was something that a standard computer could not do in a reasonable period of time.

This is the definition of "quantum supremacy": getting a quantum computer to do something that a standard classical computer cannot reasonably do.

This was basically the quantum computer equivalent to a "Hello World" program to test the capabilities. The Google researchers used their quantum computer to run a random circuit program a million times and record the outputs.

The problem that Google solved with quantum computing was specifically designed to be very difficult for a classical computer to solve. The problem was to determine the likelihood of different possible outcomes from a quantum version of a random-number generator.

Google controlled for errors in their system enough so the outputs were close to the theoretical results. This has been a hard problem to solve with quantum computers and made Google's achievement even more unique.

A part of Google's quantum computer. Source: Google.

IBM on Google's Quantum Supremacy: "Really, though?"

Google competitor IBM wasn't so sure about Google's claims. According to IBM, Google overestimated the difficulty of the task.

While Google said the problem they solved would take 10,000 years on a classical supercomputer, IBM said it could be solved in 2.5 days. That's a pretty big difference.

In a blog post, IBM "urge[d] the community to treat claims that, for the first time, a quantum computer did something that a classical computer cannot with a large dose of skepticism."

Google representatives shot back at IBM with a challenge to prove their claim that the same problem their quantum computer had solved in 200 seconds could indeed be solved by a classical computer in 2.5 days.

What's Next?

This is still only the beginning. As Google said in a blog post, "Achieving the necessary computational capabilities will still require years of hard engineering and scientific work. But we see a path clearly now, and we're eager to move ahead."

It's still difficult to correct for errors in quantum computing. Google's quantum team recently estimated that we still have at least 10 years before there is an error-corrected quantum computer.

In a recent interview, Google CEO Sundar Pichai compared their quantum computing breakthrough to the Wright brothers’ first flight. “To borrow an analogy — the Wright brothers. The first plane flew only for 12 seconds, and so there is no practical application of that. But it showed the possibility that a plane could fly.”

From Schrodinger’s Cat to finding a needle in a haystack

_Source: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Quantum_Computing;_IonTrapping(5941055642).jpg" rel="noopener" target="blank" title=")

With the recent announcement of IBM Q System One — the first fully-integrated commercial quantum computer — by IBM at CES 2019, quantum computing is soon to enter mainstream computing. Housed in a nine-foot-tall, nine-foot-wide case of half-inch thick…

Hi everyone!

The other day, I visited D-Wave Systems in Vancouver, Canada. It’s a company that makes cutting-edge quantum computers.

I got to learn a lot about quantum computers there, so I’d like to share some of what I learned there with you in this article.

The goal of this article is to give you an accurate intuition of what a quantum computer is using a simple example.

This article will not require you to have prior knowledge of either quantum physics or computer science to be able to understand it.

Okay, let’s get started.

Edit (Feb 26, 2019): I recently published a video about the same topic on my YouTube channel. I would recommend watching it (click here) before or after reading this article because I have added some additional, more nuanced arguments in the video.

What is a quantum computer?

Here is a one-sentence summary of what a quantum computer is:

A quantum computer is a type of computer that uses quantum mechanics so that it can perform certain kinds of computation more efficiently than a regular computer can.

There is a lot to unpack in this sentence, so let me walk you through what it is exactly using a simple example.

To explain what a quantum computer is, I’ll need to first explain a little bit about regular (non-quantum) computers.

How a regular computer stores information

Now, a regular computer stores information in a series of 0’s and 1’s.

Different kinds of information, such as numbers, text, and images can be represented this way.

Each unit in this series of 0’s and 1’s is called a bit. So, a bit can be set to either 0 or 1.

Now, what about quantum computers?

A quantum computer does not use bits to store information. Instead, it uses something called qubits.

Each qubit can not only be set to 1 or 0, but it can also be set to 1 and 0. But what does that mean exactly?

Let me explain this with a simple example. This is going to be a somewhat artificial example. But it’s still going to be helpful in understanding how quantum computers work.

A simple example for understanding how quantum computers work

Now, suppose you’re running a travel agency, and you need to move a group of people from one location to another.

To keep this simple, let’s say that you need to move only 3 people for now — Alice, Becky, and Chris.

And suppose that you have booked 2 taxis for this purpose, and you want to figure out who gets into which taxi.

Also, suppose here that you’re given information about who’s friends with who, and who’s enemies with who.

Here, let’s say that:

• Alice and Becky are friends
• Alice and Chris are enemies
• Becky and Chris are enemies

And suppose that your goal here is to divide this group of 3 people into the two taxis to achieve the following two objectives:

• Maximize the number of friend pairs that share the same car
• Minimize the number of enemy pairs that share the same car

Okay, so this is the basic premise of this problem. Let’s first think about how we would solve this problem using a regular computer.

Solving this problem with a regular computer

To solve this problem with a regular, non-quantum computer, you’ll need first to figure out how to store the relevant information with bits.

Let’s label the two taxis Taxi #1 and Taxi #0.

Then, you can represent who gets into which car with 3 bits.

For example, we can set the three bits to 0, 0, and 1 to represent:

• Alice gets into Taxi #0
• Becky gets into Taxi #0
• Chris gets into Taxi #1

Since there are two choices for each person, there are 222 = 8 ways to divide this group of people into two cars.

Here’s a list of all possible configurations:

A | B | C
0 | 0 | 0
0 | 0 | 1
0 | 1 | 0
0 | 1 | 1
1 | 0 | 0
1 | 0 | 1
1 | 1 | 0
1 | 1 | 1

Using 3 bits, you can represent any one of these combinations.

Computing the score for each configuration

Now, using a regular computer, how would we determine which configuration is the best solution?

To do this, let’s define how we can compute the score for each configuration. This score will represent the extent to which each solution achieves the two objectives I mentioned earlier:

• Maximize the number of friend pairs that share the same car
• Minimize the number of enemy pairs that share the same car

Let’s simply define our score as follows:

(the score of a given configuration) = (# friend pairs sharing the same car) - (# enemy pairs sharing the same car)

For example, suppose that Alice, Becky, and Chris all get into Taxi #1. With three bits, this can be expressed as 111.

In this case, there is only one friend pair sharing the same car — Alice and Becky.

However, there are two enemy pairs sharing the same car — Alice and Chris, and Becky and Chris.

So, the total score of this configuration is 1-2 = -1.

Solving the problem

With all of this setup, we can finally go about solving this problem.

With a regular computer, to find the best configuration, you’ll need to essentially go through all configurations to see which one achieves the highest score.

So, you can think about constructing a table like this:

A | B | C | Score
0 | 0 | 0 | -1
0 | 0 | 1 | 1 <- one of the best solutions
0 | 1 | 0 | -1
0 | 1 | 1 | -1
1 | 0 | 0 | -1
1 | 0 | 1 | -1
1 | 1 | 0 | 1 <- the other best solution
1 | 1 | 1 | -1

As you can see, there are two correct solutions here — 001 and 110, both achieving the score of 1.

This problem is fairly simple. It quickly becomes too difficult to solve with a regular computer as we increase the number of people in this problem.

We saw that with 3 people, we need to go through 8 possible configurations.

What if there are 4 people? In that case, we’ll need to go through 222*2 = 16 configurations.

With n people, we’ll need to go through (2 to the power of n) configurations to find the best solution.

So, if there are 100 people, we’ll need to go through:

• 2¹⁰⁰ ~= 10³⁰ = one million million million million million configurations.

This is simply impossible to solve with a regular computer.

Solving this problem with a quantum computer

How would we go about solving this problem with a quantum computer?

To think about that, let’s go back to the case of dividing 3 people into two taxis.

As we saw earlier, there were 8 possible solutions to this problem:

A | B | C
0 | 0 | 0
0 | 0 | 1
0 | 1 | 0
0 | 1 | 1
1 | 0 | 0
1 | 0 | 1
1 | 1 | 0
1 | 1 | 1

With a regular computer, using 3 bits, we were able to represent only one of these solutions at a time — for example, 001.

However, with a quantum computer, using 3 qubits, we can represent all 8 of these solutions at the same time.

There are debates as to what it means exactly, but here’s the way I think about it.

First, examine the first qubit out of these 3 qubits. When you set it to both 0 and 1, it’s sort of like creating two parallel worlds. (Yes, it’s strange, but just follow along here.)

In one of those parallel worlds, the qubit is set to 0. In the other one, it’s set to 1.

Now, what if you set the second qubit to 0 and 1, too? Then, it’s sort of like creating 4 parallel worlds.

In the first world, the two qubits are set to 00. In the second one, they are 01. In the third one, they are 10. In the fourth one, they are 11.

Similarly, if you set all three qubits to both 0 and 1, you’d be creating 8 parallel worlds — 000, 001, 010, 011, 100, 101, 110, and 111.

This is a strange way to think, but it is one of the correct ways to interpret how the qubits behave in the real world.

Now, when you apply some sort of computation on these three qubits, you are actually applying the same computation in all of those 8 parallel worlds at the same time.

So, instead of going through each of those potential solutions sequentially, we can compute the scores of all solutions at the same time.

With this particular example, in theory, your quantum computer would be able to find one of the best solutions in a few milliseconds. Again, that’s 001 or 110 as we saw earlier:

A | B | C | Score
0 | 0 | 0 | -1
0 | 0 | 1 | 1 <- one of the best solutions
0 | 1 | 0 | -1
0 | 1 | 1 | -1
1 | 0 | 0 | -1
1 | 0 | 1 | -1
1 | 1 | 0 | 1 <- the other best solution
1 | 1 | 1 | -1

In reality, to solve this problem, you would need to give your quantum computer two things:

• All potential solutions represented with qubits
• A function that turns each potential solution into a score. In this case, this is the function that counts the numbers of friend pairs and enemy pairs sharing the same car.

Given these two things, your quantum computer will spit out one of the best solutions in a few milliseconds. In this case, that’s 001 or 110 with a score of 1.

Now, in theory, a quantum computer is able to find one of the best solutions every time it runs.

However, in reality, there are errors when running a quantum computer. So, instead of finding the best solution, it might find the second-best solution, the third best solution, and so on.

These errors become more prominent as the problem becomes more and more complex.

So, in practice, you will probably want to run the same operation on a quantum computer dozens of times or hundreds of times. Then pick the best result out of the many results you get.

How a quantum computer scales

Even with the errors I mentioned, the quantum computer does not have the same scaling issue a regular computer suffers from.

When there are 3 people we need to divide into two cars, the number of operations we need to perform on a quantum computer is 1. This is because a quantum computer computes the score of all configurations at the same time.

When there are 4 people, the number of operations is still 1.

When there are 100 people, the number of operations is still 1. With a single operation, a quantum computer computes the scores of all 2¹⁰⁰ ~= 10³⁰ = one million million million million million configurations at the same time.

As I mentioned earlier, in practice, it’s probably best to run your quantum computer dozens of times or hundreds of times and pick the best result out of the many results you get.

However, it’s still much better than running the same problem on a regular computer and having to repeat the same type of computation one million million million million million times.

Wrapping up

Special thanks to everyone at D-Wave Systems for patiently explaining all of this to me.

D-Wave recently launched a cloud environment for interacting with a quantum computer.

If you’re a developer and would like actually to try using a quantum computer, it’s probably the easiest way to do so.

It’s called Leap, and it’s at https://cloud.dwavesys.com/leap. You can use it for free to solve thousands of problems, and they also have easy-to-follow tutorials on getting started with quantum computers once you sign up.

Footnote:

• In this article, I used the term “regular computer” to refer to a non-quantum computer. However, in the quantum computing industry, non-quantum computers are usually referred to as classical computers.

In this article, I’ll introduce you to Q# — the new programming language from Microsoft for quantum computing. We will cover Q# data types, expressions, and statements with the help of code snippets.

Prerequisites

For an overview of quantum computing, please visit my earlier article: An Introduction To Quantum Computing. There, I also describe how to install Quantum Development Kit (QDK) in Visual Studio 2017.

What is Q#?

According to Microsoft:

Q# is a scalable, multi-paradigm, domain-specific programming language for quantum computing.

So, what do these terms actually mean? Let us dive into the details.

• Scalable
  Q# allows us to write code that can be executed on machines of varying computing abilities. We can use it to simulate a few Qubits on our local machine, or even thousands of Qubits for an enterprise level application.
• Multi-paradigm
  Q# is a multi-paradigm programming language. It supports both functional and imperative programming styles. If you are new to programming paradigms, I suggest you refer here.
• Domain-specific
  Q# is a programming language for quantum computing. It is to be used for writing algorithms and code snippets that are executed on quantum processors.

Getting started with Q# development

This article will assume you have already installed QDK for Visual Studio 2017. If not, then you can check my earlier article for instructions.

After you have successfully installed QDK, we need to verify if Visual Studio 2017 has all the required dependencies installed for Q# development. For this, we will clone and execute the quantum sample programs from GitHub provided by Microsoft.

Open VS 2017 and navigate to Team >> Manage Connections.

Select Clone under Local Git Repositories and enter the URL: https://github.com/Microsoft/Quantum.git and click “Clone”.

The repository will be cloned on your local computer and Visual Studio will switch to the Solution Explorer. It will display all the cloned libraries and samples.

Now, open QsharpLibraries.sln solution.

If you are prompted with the “Install Missing Features” popup box, click “Install” to allow the installation of the necessary features. This will download and install F# and other tools used by some of the samples. Make sure that you are connected to the internet.

To execute a sample program, right-click on the TeleportationSample project in “Samples > 0.Introduction folder” _of QsharpLibrari_es solution, and then click on “Set as Startup Project” and press F5.

If you can see an output screen similar to the one shown below, then congratulations, your VS 2017 is ready for Q# development.

Note that your output screen may vary because the data being teleported is random. But it should send 8 rounds of data, with all being successfully teleported.

Q# Type model

Let us understand what are the various type models provided by Q#:

Primitive Type

• Int: — It represents the 64 -bit signed integer. Notice the upper case ‘I’. This is in contrast to int in C# with lower case ‘i’.
• Double: — It represents double-precision floating point number. This also has a upper case ‘D’ in contrast to double in C#.
• Bool: — It represents the Boolean type and can take two values — true or false.
• Qubit: — This represents the Quantum bit. Qubit is the fundamental unit of processing information in quantum computers, similar to a bit in classical computers.
• Pauli: — This type is used to denote the base operation for rotations and to specify the basis of a measurement.
• Result: — This represents the result of a measurement. This can take two possible values Zero or One
• Range: — This represents a sequence of integers.
• String: — It represents a sequence of Unicode characters.

Array Type

We can create an array type of any valid Q# primitive type. Q# does not support rectangular multi-dimensional arrays. Instead, it supports only jagged arrays.

Int[], Qubit[][]

By default, all variables in Q# are immutable. Their values cannot be changed after they are bound. So, to create an array whose values can be set, we will use the mutable keyword:

mutable myArr = new Int [5];

This will create an integer array myArr of size 5. The elements of a new array are initialized to a type-dependent default value. In this case it will be 0, the default value for an integer type.

Arrays passed as arguments are immutable. All arrays in Q# are zero-based. That is, the first element of an array arr is always arr[0].

Tuple Type

The tuple type represents a tuple of values of any given primitive type. It is represented as (T1, T2, T3,…) where T1, T2, T3 are primitive types. The Q# tuple is immutable. We cannot change the contents of the tuple once it has been created.

A tuple expression can contain values of multiple primitive types. So, a tuple of type (Int, Double, Result) is a valid tuple.

We can create a tuple with single element also, like (2). This is known as a singleton tuple, and it is considered equal to the value of the enclosed type. This property is called singleton tuple equivalence.

For example, (2) is a singleton tuple of type Int, but it is considered equivalent to an integer 2.

We can create a user defined type of any primitive type. We can also create an array of user defined types or can also include it in a tuple. User defined types cannot have cyclic dependency on each other. So, it is not possible to create a recursive type structure.

A user-defined type is a subtype of the base type. This means it can be used anywhere a value of the base type is expected.

Operation Type

A Q# operation is a callable routine, which contains Q# code to carry out a quantum operation. An operation is the basic unit of quantum execution in Q#. The operation can only take single value as input in the form of a tuple. It returns a single value as output, specified after a colon, and may be a tuple.

An operation has a body section which contains the implementation of the operation. It can also have adjoint, controlled, and controlled adjoint sections. These are used to specify specific variants of appropriate operations. The arguments to an operation are specified as a tuple, within parentheses. The return type of the operation is specified after the colon.

Refer to a sample operation below:

operation AddInteger(a: Int, b: Int): Int {  
    body {  
        mutable c = 0;  
        set c = a + b;  
        return (c);  
    }  
}

Here, we have an operation AddInteger which takes a tuple (Int, Int) as input. It returns an output of type Int after performing addition operations on input integers.

Function Type

A Q# Function is classical subroutine used within a Quantum algorithm and can only contain classical code (but no quantum operations). Similar to Q# operations, a function will also take a single value as input and returns a single value as output. Both of them can be a tuple. Functions cannot allocate qubits or call operations.

Let’s look at a sample function.

function ProductNumber(a: Double, b: Double): Double {  
    mutable c = 0.0;  
    set c = a * b;  
    return (c);  
}

Here, we have defined a function ProductNumber, which takes a tuple (Double, Double) as input and returns an output of type Double after performing the product of input values. Also, notice that a function does not have a body section, as in the case of an operation.

Expressions in Q

Let’s take a look at various expressions provided in Q#.

Numeric Expressions

There are two types of numeric expressions provided by Q#:

• Integer numbers: these are represented by Int
• Floating point numbers: represented by Double

To represent a hexadecimal integer, we use the “0x” prefix.

We can also perform binary operations on numeric expressions to form a new numeric expression. The type of the new expression will be Double if both input expressions are floating point numbers, or will be an Int if both are integers.

Apart from binary operations, the numeric expressions also support modulus, power, bitwise AND, bitwise OR, bitwise XOR, and bitwise complement operations.

Qubit Expressions

Qubit expressions are the symbols that are bound to qubit values or the elements of a qubit array. Q# does not provide any support for qubit literals.

Pauli Expressions

As we have discussed earlier, the primitive type Pauli can take four possible values: PauliI, PauliX, PauliY and PauliZ. These all are valid Pauli expressions. We can also create an array of Pauli types, and the array elements are considered as valid Pauli expressions.

The two possible result values Zero and One are valid Result expressions. One important point to note is that One is not the same as integer 1, and Zero is not same as integer 0. Also, there is no direct conversion between them.

This is in contrast to C# where, boolean true is considered the same as integer 1 and boolean false is considered the same as integer 0.

Range Expressions

A range expression is represented as start..step..stop where start, step, stop are all integers. The range expression can take values as start, start+step, start+step+step and so on until stop is passed.

If only start and stop are mentioned in a range expression, then it will take the value of the step as set to 1 implicitly.

Let’s understand this with the help of an example:

• 1..3 — this indicates the range 1,2,3. This gives 1, 1+1, 1+1+1
• 1..2..6 indicates the range 1,3,5, or 1, 1+2,1+2+2
• 8..-2..3 indicates the range 8,6,4 or 8, 8+(-2), 8+(-2)+(-2)

Array Expressions

In Q# an array can be represented as a set of element expressions separated by semicolons and enclosed within square brackets. Similar to C#, all elements of an array in Q# should have the same type.

So, [1;2;3] is a valid array, but [1;2.5;Zero] is an invalid array.

We can also use the ‘+’ operator to concatenate two arrays of the same type.

So, [2;4;6] + [8;10;12] will give [2;4;6;8;10;12] as output.

To find the length of an array, we use the Length built-in function.

As an example, if myArr is an integer array having 5 elements, then Length(myArr) will return 5 as the output.

Q# Statements

Symbols in Q# can be mutable or immutable.

An immutable symbol cannot be changed after it has been bound. We use the let keyword to define and bind an immutable symbol.

let i=8;

This will bind the symbol i as an integer with value 8. If we try to reset the value of an immutable expression, we will get a compile time error.

Hence set i=10; will give an error in this case.

A mutable symbol value can be changed after it has been bound. We use the mutable keyword to define and bind a mutable symbol.

mutable i=8;

This will bind the symbol i as an integer with value 8.

To change the value of a mutable symbol, we use the set keyword:

set i=10;

This will update the value of variable i to 10

for-loops

Q# allows a for-loop to iterate over an integer range. The for statement consists of the keyword for, followed by an identifier, the keyword in, a Range expression, and a statement block.

A range is specified by the first and last integers in the range, for example: 1..5 represents the range 1, 2, 3, 4, and 5. If a step other than +1 is needed, then three integers with .. between them are used.

So, 1..2..10 is the range 1, 3, 5, 7, and 9. The range is inclusive at both ends.

for(num in 1..2..10)  
{  
   //Do something  
}

As the name suggests, this loop will repeat until successful operation occurs. This loop is based on the quantum “repeat until success” pattern. It consists of the keyword repeat and its statement block, the keyword until, a Boolean expression, the keyword fixup, and its statement block .

The statement inside the repeat block is executed, and then the boolean condition is evaluated. If the boolean condition evaluates to true, then the loop terminates. Otherwise, the fixup block is executed and the loop repeats once again.

The fixup block is always required — even if there is no fixup to be done — in which case it will be empty.

repeat {  
    //do something  
}  
until boolean condition  
fixup {  
    // do something  
}

Q# supports if statements for conditional execution, similar to C#. The if statement consists of the keyword if, followed by a Boolean expression and the statement block. An if block may have an optional else block, which is represented by the keyword else.

if (num % 2 == 0) {  
    return true;  
} else {  
    return false;  
}

A conditional statement can consist of a series of if-elseif-else chains. The else-if clause is represented by the keyword elif.

if (num == 1) {  
    //do something  
}  
elif(num == 2) {  
    //do something  
}  
else {  
    //do something  
}

Conclusion

In this article, we have learned the basics of the Q# programming language. We also installed QDK and verified the Q# execution environment with Visual Studio 2017. Please post your valuable feedback in the comments section and stay tuned for more on Quantum Computing.

You can always refer to my previous articles here.

You can also find this article at C# Corner

Originally published at ankitsharmablogs.com on Jan 16, 2018.

Disclaimer: This is a hypothetical think piece. It is a personal opinion and doesn’t represent the opinion of any of the companies (or secret societies) I may (..or may not) be involved with. If you tear a hole through space-time after reading this article… that’s your own fault.

If you haven’t heard, a research team out of China just made a huge leap with respect to realization of using Quantum Entanglement as a valid communication vessel. Their process was to use a low-earth satellite to create a pair of entangled photons and then send them to locations very far apart from each other. Even at never-before-done distances, the photons retained their entanglement, which has set the internet a buzz about the future of communication, and when the new quantum internet will happen.

Now, looking at the math, I’m still a bit dubious that quantum entanglement could be viably used for communication. This math person explains it a bit better than I ever could. However, there’s lots of people hypothesizing that this is the first steps in a new quantum internet where things like Entanglement Swapping and Twisted Light could bridge those gaps.

Then let’s propose a thought experiment: let’s assume there’s future where an internet exists, whose technology is based on quantum entanglement. This means that data can be transmitted between two locations, at close to speed-of-light without a physical connecting medium between the locations.

In such a world, does data compression matter any more?

A small idea on how a QE internet would work

We have to assume that due to current technology, the first realization of a QE Internet (QEI) would be very similar to the telegraph systems of the past. The cost to maintain and run these early QEI sites would limit their availability, meaning that communication could only occur between a handful of sites.

These sites would require two primary features:

1. A non-centralized system which can distribute entangled photon pairs to the sites (a low-orbit satellite, for example).
2. A recording system which logs the results of the entanglement tests and can store / retrieve them.

#2 would be most likely built on today’s modern technology. So you can expect a situation where a billion photon pairs are sent to a site, and sampled in unison, and stored as binary data at the location.

From that point, the data would be most likely distributed to it’s final destination using more conventional methods (e.g. fiber connection).

Limitations of a first generation QEI

Obviously, we still end up with some data-based bottlenecks here:

1. There is a physical limit to how many entangled pairs can be stored at a site, thus limiting it’s total bandwidth.
2. There is a physical limit to the speed in which entangled pairs can be sent from the distributor to the sites on a regular basis, thus limiting total system bandwidth.
3. Environmental factors will cause loss of data in the transfer of photons to the sites from the distributor system. Thus, there will be a need for redundancy in the process, limiting total system bandwidth.

When observing the above, you can quickly seen that the overall bandwidth of a QEI would be limited by the above systems, regardless of the ability for information to travel between sites through quantum means. So obviously, reducing the size of the data being sent through the sites will be important, but will today’s data compression algorithms make sense?

Data compression for a QEI

There’s a few definitions of “data” which represents it as a physical entity, and as the (potential) realization of a Quantum Internet is realized, the need for photon transferal makes this concept even more real.

In fact, that may be the largest ramification of a quantum entangled internet: your data now has a very physical manifestation and cost involved with it.

So it’s obvious that data compression, as a science, will still be needed in a QEI future, but the real question we should be asking ourselves is: Are today’s compression algorithms good enough to support a quantum internet?

My opinion? Not even close.

As explained in “Understanding Compression” today’s systems are still grounded around Shannon’s basic architecture of ‘the most frequent symbol gets the smallest bits.’ There’s a lot of power in this process, but until we move out of symbol space, and start gaining the computational power to handle compression entirely in bit-vector space, we’re going to be leaving a lot of information on the table. (But that’s my own unpopular opinion...)

Let’s look beyond that. Are there potential systems where, rather than applying Brotli to a data set, we instead can apply in to entangled photons directly? Will we start talking about algorithms to do diff’s against the photons on a site, and the data being transmitted, so we can reduce the number of updated pairs? What happens when we start thinking in terms of qubits, rather than just bits? Do we have to start thinking about LZ encoding in 8 dimensional space?

Obviously, the realization and standardization of Quantum Computing will create a massive technological shift in how our world works. And I’ve got every reason to believe that Data Compression will be right there, too.