Add a very basic implementation of Grover's algorithm #224

thomashaener · 2019-09-04T13:16:22Z

This PR adds a new sample that shows how to implement Grover's algorithm in Q#. The sample is supposed to be as simple as possible (e.g., for use in beginner tutorials).
The marking oracle uses a bit-flip oracle (as opposed to using a phase-flip directly) to better align with textbook descriptions and to make it easier to experiment with. E.g., one could combine it with the OracleSynthesis sample.

msoeken

Hi @thomashaener, thanks for your pull request. I think this is an interesting example and especially good for beginners. The code is very concise. I have a few comments.

Samples/src/SimpleGrover/README.md

Samples/src/SimpleGrover/SimpleGrover.qs

msoeken · 2019-09-04T14:03:23Z

Samples/src/SimpleGrover/SimpleGrover.qs

+    open Microsoft.Quantum.Arithmetic;
+
+    // This operation adds a (-1)-phase to the marked state(s)
+    operation ReflectMarked (inputQubits : Qubit[]) : Unit is Adj + Ctl {


You never call the adjoint or a controlled version of the function, so Adj + Ctl could be removed.

msoeken · 2019-09-04T14:04:03Z

Samples/src/SimpleGrover/SimpleGrover.qs

+                // Flip the outputQubit for marked states.
+                // Here: For the state with alternating 0s and 1s
+                within {
+                    ApplyToEachCA(X, inputQubits[0..2..Length(inputQubits)-1]);


Considering to drop Adj + Ctl from this operation, this can become ApplyToEach

Support for Adjoint is required for operations called inside a within block, but I agree that controlled shouldn't be required. It may be at the moment, though, as I'm not sure that microsoft/qsharp-compiler#152 is included in the 0.9 release.

msoeken · 2019-09-04T14:04:15Z

Samples/src/SimpleGrover/SimpleGrover.qs

+    }
+
+    // This operation adds a (-1)-phase to the uniform superposition
+    operation ReflectUniform (inputQubits : Qubit[]) : Unit is Adj + Ctl {    


msoeken · 2019-09-04T14:04:32Z

Samples/src/SimpleGrover/SimpleGrover.qs

+    operation ReflectUniform (inputQubits : Qubit[]) : Unit is Adj + Ctl {    
+        within {
+            // Transform the uniform superposition to all-zero
+            ApplyToEachCA(H, inputQubits);


This could be simplified to ApplyToEachA.

msoeken · 2019-09-04T14:05:11Z

Samples/src/SimpleGrover/SimpleGrover.qs

+            return IntAsBoolArray(measuredInt, numQubits);
+        }
+    }
+}


Please add an empty line to the end of the file.

cgranade

This looks really good, @thomashaener! I've left a few comments here and there, but thanks for adding this!

cgranade · 2019-09-04T16:42:04Z

Samples/src/SimpleGrover/README.md

+## Running the Sample in Visual Studio ##
+
+Open the `QsharpSamples.sln` solution in Visual Studio and set the .csproj file in the manifest as the startup project.
+Press Start in Visual Studio to run the sample.


I'd suggest adding a host.py along with instructions on how to run the sample from the command line using either Python or the .NET Core SDK:

Suggested change

Press Start in Visual Studio to run the sample.

Press Start in Visual Studio to run the sample.

## Running the Sample from the Command Line ##

This sample can also be run from the command line, including from the integrated terminal in Visual Studio Code.

To run the C# host program for this sample, use the `dotnet` command:

```bash

dotnet run

```

To run this sample from Python:

```bash

python host.py

```

cgranade · 2019-09-04T16:44:07Z

Samples/src/SimpleGrover/SimpleGrover.qs

+                // Flip the outputQubit for marked states.
+                // Here: For the state with alternating 0s and 1s
+                within {
+                    ApplyToEachCA(X, inputQubits[0..2..Length(inputQubits)-1]);


Support for Adjoint is required for operations called inside a within block, but I agree that controlled shouldn't be required. It may be at the moment, though, as I'm not sure that microsoft/qsharp-compiler#152 is included in the 0.9 release.

cgranade · 2019-09-04T16:45:08Z

Samples/src/SimpleGrover/SimpleGrover.qs

+            apply {
+                // Flip the outputQubit for marked states.
+                // Here: For the state with alternating 0s and 1s
+                within {


Would it make sense to remove a level of nesting here?

The outer level turns the bit-flip oracle into a phase-flip oracle, and the inner within-apply is the bit-flip oracle itself, so I left the two levels for illustration. Should I put an additional note there or similar?

cgranade · 2019-09-04T16:45:18Z

Samples/src/SimpleGrover/SimpleGrover.qs

+    open Microsoft.Quantum.Arithmetic;
+
+    // This operation adds a (-1)-phase to the marked state(s)
+    operation ReflectMarked (inputQubits : Qubit[]) : Unit is Adj + Ctl {


Suggested change

operation ReflectMarked (inputQubits : Qubit[]) : Unit is Adj + Ctl {

operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit is Adj + Ctl {

cgranade · 2019-09-04T16:45:32Z

Samples/src/SimpleGrover/SimpleGrover.qs

+    }
+
+    // This operation adds a (-1)-phase to the uniform superposition
+    operation ReflectUniform (inputQubits : Qubit[]) : Unit is Adj + Ctl {    


Suggested change

operation ReflectUniform (inputQubits : Qubit[]) : Unit is Adj + Ctl {

operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {

cgranade · 2019-09-04T16:46:55Z

Samples/src/SimpleGrover/SimpleGrover.qs

+                ReflectUniform(qubits);
+            }
+            // measure the answer
+            let measuredInt = MeasureInteger(LittleEndian(qubits));


It feels a little funny to me to measure an integer, then immediately convert it to a Bool[]. Would it make sense to either return the Int directly, or to use return ForEach(MResetZ, qubits) here?

alan-geller · 2019-09-04T18:28:02Z

How does this sample relate to the Grover Kata, https://github.com/microsoft/QuantumKatas/tree/master/GroversAlgorithm?

thomashaener · 2019-09-05T06:47:49Z

How does this sample relate to the Grover Kata, https://github.com/microsoft/QuantumKatas/tree/master/GroversAlgorithm?

In my opinion, the purpose of the Katas is to teach programmers (in this particular case how to implement Grover), whereas samples illustrate how concise complete applications can be because of the language features that Q# provides (such as, e.g., within-apply in this sample).

thomashaener · 2019-09-05T07:31:41Z

@cgranade @msoeken Thanks a lot for the feedback! I've addressed all comments & suggestions in the newest commit.

msoeken

Thanks for addressing all comments, just got one last small comment.

Samples/src/SimpleGrover/Program.cs

cgranade · 2019-09-06T19:09:44Z

Thanks for adding this sample, @thomashaener!

Added Validation to the Monomorphization transformation.

thomashaener added 2 commits September 4, 2019 14:39

Add a simple version of Grover's algorithm.

3d6a0c4

Tab vs spaces.

9f6ba30

thomashaener requested review from cgranade and msoeken September 4, 2019 13:16

msoeken self-assigned this Sep 4, 2019

msoeken suggested changes Sep 4, 2019

View reviewed changes

cgranade reviewed Sep 4, 2019

View reviewed changes

Add python host and address reviews.

43ee234

Newline at EOF.

68c526c

msoeken approved these changes Sep 5, 2019

View reviewed changes

Samples/src/SimpleGrover/Program.cs Outdated Show resolved Hide resolved

Remove System. for consistency.

3fd1512

cgranade merged commit 714ca3e into master Sep 6, 2019

jwittner pushed a commit to jwittner/Quantum that referenced this pull request Dec 16, 2019

Sccarda/generic resolution validation (microsoft#224)

c7bec0d

Added Validation to the Monomorphization transformation.

cgranade deleted the thhaner/simple-grover branch February 3, 2020 18:51

-Press Start in Visual Studio to run the sample.
+Press Start in Visual Studio to run the sample.
+## Running the Sample from the Command Line ##
+This sample can also be run from the command line, including from the integrated terminal in Visual Studio Code.
+To run the C# host program for this sample, use the `dotnet` command:
+```bash
+dotnet run
+```
+To run this sample from Python:
+```bash
+python host.py
+```

	operation ReflectMarked (inputQubits : Qubit[]) : Unit is Adj + Ctl {
	operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit is Adj + Ctl {

	operation ReflectUniform (inputQubits : Qubit[]) : Unit is Adj + Ctl {
	operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {

Add a very basic implementation of Grover's algorithm #224

Add a very basic implementation of Grover's algorithm #224

Uh oh!

Conversation

thomashaener commented Sep 4, 2019

Uh oh!

msoeken left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cgranade left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alan-geller commented Sep 4, 2019

Uh oh!

thomashaener commented Sep 5, 2019

Uh oh!

thomashaener commented Sep 5, 2019

Uh oh!

msoeken left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

cgranade commented Sep 6, 2019

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants