Beautify quantum walks qmod's

Author: ori-opher

tutorials/advanced_tutorials/discrete_quantum_walk/discrete_quantum_walk.ipynb

@@ -267,7 +267,6 @@
     "qmod_1 = create_model(\n",
     "    main,\n",
     "    execution_preferences=ExecutionPreferences(num_shots=NUM_SAMPLES),\n",
-    "    out_file=\"quantum_walk_circle\",\n",
     ")\n",
     "\n",
     "qprog_1 = synthesize(qmod_1)\n",
@@ -461,7 +460,6 @@
     "qmod_2 = create_model(\n",
     "    main,\n",
     "    execution_preferences=ExecutionPreferences(num_shots=NUM_SHOTS),\n",
-    "    out_file=\"quantum_walk_circle_balanced_coin\",\n",
     ")"
    ]
   },
@@ -632,7 +630,6 @@
     "    main,\n",
     "    execution_preferences=ExecutionPreferences(num_shots=NUM_SHOTS),\n",
     "    constraints=Constraints(optimization_parameter=\"width\"),\n",
-    "    out_file=\"quantum_walk_hypercube\",\n",
     ")"
    ]
   },

tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle.qmod

@@ -1,3 +1,13 @@
+// Discrete quantum walk on a circle
+
+// Perform a discrete quantum walk on a circle (regular 2**N polygon), for t steps
+
+N: int = 7;
+circle_size: int = 2 ** N;
+
+
+// the coin is represented by a qubit and a "flip" is defined by some unitary operation on it.
+// Choosing the Hadamard gate, which sends the |0> state into an equal superposition of |0> and |1>.
 qfunc quantum_coin_flip(coin: qbit) {
   H(coin);
 }
@@ -12,14 +22,15 @@ qfunc discrete_quantum_walk_circle(time: int, coin: qbit, x: qbit[]) {
     control (coin == 0) {
       quantum_step_clockwise(x);
     } else {
+      // Step counter clock wise (equivalent to x += -1)
       invert {
         quantum_step_clockwise(x);
       }
     }
   }
 }
 
-qfunc main(t: int, output x: qnum<floor(log(128, 2)), SIGNED, 0>, output coin: qbit) {
+qfunc main(t: int,output x: qnum<floor(log(circle_size, 2)), SIGNED, 0>, output coin: qbit) {
   allocate(x);
   allocate(coin);
   discrete_quantum_walk_circle(t, coin, x);

tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod

@@ -1,3 +1,11 @@
+// Discrete quantum walk on a circle with a balanced coin
+
+// Perform a discrete quantum walk on a circle (regular 2**N polygon), with a balanced coin, for t steps
+
+N: int = 7;
+circle_size: int = 2 ** N;
+
+// A generic function for a quantum walk
 qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) {
   power (time) {
     coin_flip_qfunc(coin_state);
@@ -10,21 +18,34 @@ qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfun
 }
 
 qperm quantum_step_clockwise(x: qnum) {
-  x += 1;
+    x += 1;
 }
 
-qfunc main(t: int, output x: qnum<floor(log(128, 2)), SIGNED, 0>, output coin: qbit) {
+qfunc main(t: int, output x: qnum<floor(log(circle_size, 2)), SIGNED, 0>, output coin: qbit) {
   allocate(x);
   allocate(coin);
+  // Apply H and then S for a balanced initial condition for the coin
   H(coin);
   S(coin);
-  discrete_quantum_walk(t, lambda(coin) {
-    H(coin);
-  }, [lambda() {
-    quantum_step_clockwise(x);
-  }, lambda() {
-    invert {
-      quantum_step_clockwise(x);
-    }
-  }], coin);
+
+  discrete_quantum_walk(
+    t,
+    // the coin is represented by a qubit and a "flip" is defined by some unitary operation on it.
+    // Choosing the Hadamard gate, which sends the |0> state into an equal superposition of |0> and |1>.
+    lambda(coin) {
+      H(coin);
+    },
+    // Step clockwise or counter clockwise according the the coin's state
+    [
+      lambda() {
+        quantum_step_clockwise(x);
+      },
+      lambda() {
+        invert {
+          quantum_step_clockwise(x);
+        }
+      }
+    ],
+    coin
+  );
 }

tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod

@@ -1,3 +1,15 @@
+// Discrete quantum walk on a hypercube
+
+// Perform a discrete quantum walk on a 4-dimensional hypercube, for t steps.
+// the coin is represented by a qubit and a "flip" is defined by some unitary operation on it.
+
+// Two nodes in the hypercube are connected to each other if their Hamming distance is 1.
+// Thus, a step along a hypercube is given by moving "1 Hamming distance away".
+// For a d-dimensional hypercube, at each node there are d possible directions to move.
+// Each of them is given by applying a bit flip on one of the bits.
+// This is obtained by applying an X gate on one of the d qubits.
+
+
 qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) {
   power (time) {
     coin_flip_qfunc(coin_state);
@@ -17,17 +29,30 @@ qfunc main(t: int, output x: qbit[4], output coin: qbit[]) {
   allocate(x);
   allocate(2, coin);
   prepare_uniform_trimmed_state(4, coin);
-  discrete_quantum_walk(t, lambda(coin) {
-    grover_diffuser(lambda(coin) {
-      prepare_uniform_trimmed_state(4, coin);
-    }, coin);
-  }, [lambda() {
-    moving_one_hamming_dist(0, x);
-  }, lambda() {
-    moving_one_hamming_dist(1, x);
-  }, lambda() {
-    moving_one_hamming_dist(2, x);
-  }, lambda() {
-    moving_one_hamming_dist(3, x);
-  }], coin);
+  discrete_quantum_walk(
+    t,
+    lambda(coin) {
+      // the coin is represented by a qubit and a "flip" is defined by some unitary operation on it.
+      // Choosing the "Grover diffuser" function refers to a symmetric quantum walk.
+      // The Grover diffuser operator is a reflection around a given state |psi>.
+      grover_diffuser(lambda(coin) {
+        prepare_uniform_trimmed_state(4, coin);
+      }, coin);
+    },
+    [
+      lambda() {
+        moving_one_hamming_dist(0, x);
+      },
+      lambda() {
+        moving_one_hamming_dist(1, x);
+      },
+      lambda() {
+        moving_one_hamming_dist(2, x);
+      },
+      lambda() {
+        moving_one_hamming_dist(3, x);
+      }
+    ],
+    coin
+  );
 }