Update qmods

algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod

@@ -3,10 +3,6 @@ qfunc qsct_2d(xy_variable: qnum[2]) {
   qct_type2(xy_variable[1]);
 }
 
-qfunc powered_hamiltonian_evolution(hamiltonian: PauliTerm[], scaling: real, p: int, qba: qbit[]) {
-  suzuki_trotter(hamiltonian, p * ((-6.28318530718) * scaling), 1, 1, qba);
-}
-
 qfunc inverse_amplitude_load(prefactor: real, phase: qnum, ind: qbit) {
   ind *= prefactor / phase;
 }
@@ -22,6 +18,10 @@ qfunc matrix_inversion_HHL(prefactor: real, my_unitary: qfunc (int, qbit[]), sta
   }
 }
 
+qfunc powered_hamiltonian_evolution(hamiltonian: PauliTerm[], scaling: real, p: int, qba: qbit[]) {
+  suzuki_trotter(hamiltonian, p * ((-6.28318530718) * scaling), 1, 1, qba);
+}
+
 qfunc main(output x_variable: qnum<3, False, 0>, output y_variable: qnum<3, False, 0>, output phase: qnum, output indicator: qbit) {
   xy_variable: qnum<3, False, 0>[2];
   prepare_amplitudes([

algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod

@@ -1,3 +1,20 @@
+qfunc check_block(b: qnum, res: qbit) {
+  res ^= b == 0;
+}
+
+qfunc oblivious_amplitude_amplification(reps: int, block_encoding: qfunc (qnum, qbit[]), block: qnum, data: qbit[]) {
+  block_encoding(data, block);
+  repeat (index: reps) {
+    grover_operator(lambda(b) {
+      phase_oracle(lambda(x, res) {
+        check_block(x, res);
+      }, b);
+    }, lambda(b) {
+      block_encoding(data, b);
+    }, block);
+  }
+}
+
 qfunc apply_pauli_term(pauli_string: Pauli[], x: qbit[]) {
   repeat (index: x.len) {
     switch(pauli_string[index], [lambda() {
@@ -24,23 +41,6 @@ qfunc block_encode(pauli_list: Pauli[][], data: qbit[], block: qnum) {
   }
 }
 
-qfunc check_block(b: qnum, res: qbit) {
-  res ^= b == 0;
-}
-
-qfunc oblivious_amplitude_amplification(reps: int, block_encoding: qfunc (qnum, qbit[]), block: qnum, data: qbit[]) {
-  block_encoding(data, block);
-  repeat (index: reps) {
-    grover_operator(lambda(b) {
-      phase_oracle(lambda(x, res) {
-        check_block(x, res);
-      }, b);
-    }, lambda(b) {
-      block_encoding(data, b);
-    }, block);
-  }
-}
-
 qfunc main(output data: qnum, output block: qnum) {
   allocate(2, block);
   prepare_amplitudes([

algorithms/simon/simon_example.qmod

@@ -1,14 +1,14 @@
-qfunc simon_qfunc_simple(s: int, x: qnum, output res: qnum) {
-  res = min(x, x ^ s);
-}
-
 qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) {
   res: qnum;
   hadamard_transform(x);
   f_qfunc(x, res);
   hadamard_transform(x);
 }
 
+qfunc simon_qfunc_simple(s: int, x: qnum, output res: qnum) {
+  res = min(x, x ^ s);
+}
+
 qfunc main(output x: qnum) {
   allocate(5, x);
   simon_qfunc(lambda(x, res) {

algorithms/simon/simon_shallow_example.qmod

@@ -1,3 +1,10 @@
+qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) {
+  res: qnum;
+  hadamard_transform(x);
+  f_qfunc(x, res);
+  hadamard_transform(x);
+}
+
 qfunc simon_qfunc_with_bipartite_s(partition_index: int, x: qbit[], output res: qbit[]) {
   allocate(x.len, res);
   repeat (i: x.len - partition_index) {
@@ -9,13 +16,6 @@ qfunc simon_qfunc_with_bipartite_s(partition_index: int, x: qbit[], output res:
   }
 }
 
-qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) {
-  res: qnum;
-  hadamard_transform(x);
-  f_qfunc(x, res);
-  hadamard_transform(x);
-}
-
 qfunc main(output x: qnum) {
   allocate(6, x);
   simon_qfunc(lambda(x, res) {

algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod

@@ -1,3 +1,11 @@
+qfunc block_encoding_vqls(ansatz: qfunc (), block_encoding: qfunc (), prepare_b_state: qfunc ()) {
+  ansatz();
+  block_encoding();
+  invert {
+    prepare_b_state();
+  }
+}
+
 qfunc apply_ry_on_all(params: real[], io: qbit[]) {
   repeat (index: io.len) {
     RY(params[index], io[index]);
@@ -60,14 +68,6 @@ qfunc prepare_ca(pauli_terms_list: PauliTerm[], system_qubits: qbit[], ancillary
   }
 }
 
-qfunc block_encoding_vqls(ansatz: qfunc (), block_encoding: qfunc (), prepare_b_state: qfunc ()) {
-  ansatz();
-  block_encoding();
-  invert {
-    prepare_b_state();
-  }
-}
-
 qfunc main(params: real[9], output ancillary_qubits: qnum, output system_qubits: qnum) {
   allocate(2, ancillary_qubits);
   allocate(3, system_qubits);

applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod

@@ -3,8 +3,9 @@ qfunc my_sp(x: qnum, y: qnum) {
   hadamard_transform(y);
 }
 
-qfunc my_predicate(x: qnum, y: qnum, res: qbit) {
-  res ^= ((x + y) < 9) and (((x * y) % 4) == 1);
+qfunc my_grover_operator(oracle_operand: qfunc (), diffuser_operand: qfunc ()) {
+  oracle_operand();
+  diffuser_operand();
 }
 
 qfunc prep_minus(output out: qbit) {
@@ -22,6 +23,10 @@ qfunc my_oracle(predicate: qfunc (qbit)) {
   }
 }
 
+qfunc my_predicate(x: qnum, y: qnum, res: qbit) {
+  res ^= ((x + y) < 9) and (((x * y) % 4) == 1);
+}
+
 qfunc zero_predicate(x: qnum, y: qnum, res: qbit) {
   joined: qnum<x.size + y.size, False, 0>;
   {x, y} -> joined;
@@ -43,11 +48,6 @@ qfunc my_diffuser(sp_operand: qfunc (qnum, qnum), x: qnum, y: qnum) {
   }
 }
 
-qfunc my_grover_operator(oracle_operand: qfunc (), diffuser_operand: qfunc ()) {
-  oracle_operand();
-  diffuser_operand();
-}
-
 qfunc main(output x: qnum, output y: qnum) {
   allocate_num(6, False, 0, x);
   allocate_num(6, False, 0, y);

applications/finance/option_pricing/option_pricing.qmod

@@ -3,6 +3,13 @@ qstruct OptionPricingState {
   ind: qbit;
 }
 
+qfunc iqae_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) {
+  sp_operand(x);
+  power (k) {
+    grover_operator(oracle_operand, sp_operand, x);
+  }
+}
+
 qfunc iqae_oracle(state: OptionPricingState) {
   Z(state.ind);
 }
@@ -59,13 +66,6 @@ qfunc european_call_state_preparation(state: OptionPricingState) {
   payoff(state.asset, state.ind);
 }
 
-qfunc iqae_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) {
-  sp_operand(x);
-  power (k) {
-    grover_operator(oracle_operand, sp_operand, x);
-  }
-}
-
 qfunc main(k: int, output ind: qbit) {
   state: OptionPricingState;
   asset: qbit[];

tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod

@@ -1,13 +1,3 @@
-qfunc quantum_step_clockwise(x: qbit[]) {
-  within {
-    qft(x);
-  } apply {
-    repeat (i: x.len) {
-      PHASE(((2 * pi) * (2 ** i)) / (2 ** x.len), x[i]);
-    }
-  }
-}
-
 qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) {
   power (time) {
     coin_flip_qfunc(coin_state);
@@ -19,6 +9,16 @@ qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfun
   }
 }
 
+qfunc quantum_step_clockwise(x: qbit[]) {
+  within {
+    qft(x);
+  } apply {
+    repeat (i: x.len) {
+      PHASE(((2 * pi) * (2 ** i)) / (2 ** x.len), x[i]);
+    }
+  }
+}
+
 qfunc main(t: int, output x: qnum) {
   coin: qbit;
   allocate_num(floor(log(128, 2)), True, 0, x);

tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod

@@ -1,7 +1,3 @@
-qfunc moving_one_hamming_dist(pos: int, x: qbit[]) {
-  X(x[pos]);
-}
-
 qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) {
   power (time) {
     coin_flip_qfunc(coin_state);
@@ -13,6 +9,10 @@ qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfun
   }
 }
 
+qfunc moving_one_hamming_dist(pos: int, x: qbit[]) {
+  X(x[pos]);
+}
+
 qfunc main(t: int, output x: qbit[]) {
   allocate(4, x);
   coin: qbit[];

tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod

@@ -1,3 +1,18 @@
+qfunc lcu_cheb(coef: real[], generalized_signs: int[], walk_operator: qfunc (qnum, qbit[]), walk_block: qnum, walk_data: qbit[], cheb_block: qnum) {
+  within {
+    inplace_prepare_state(coef, 0.0, cheb_block);
+  } apply {
+    repeat (k: generalized_signs.len) {
+      control (cheb_block == k) {
+        U(0, 0, 0, (pi / 2) * generalized_signs[k], walk_data[0]);
+        power (k) {
+          walk_operator(walk_block, walk_data);
+        }
+      }
+    }
+  }
+}
+
 qfunc apply_pauli_term(pauli_string: PauliTerm, x: qbit[]) {
   repeat (index: x.len) {
     switch(pauli_string.pauli[index], [lambda() {
@@ -52,21 +67,6 @@ qfunc my_walk_operator(block: qbit[], data: qbit[]) {
   RY(2 * pi, block[0]);
 }
 
-qfunc lcu_cheb(coef: real[], generalized_signs: int[], walk_operator: qfunc (qnum, qbit[]), walk_block: qnum, walk_data: qbit[], cheb_block: qnum) {
-  within {
-    inplace_prepare_state(coef, 0.0, cheb_block);
-  } apply {
-    repeat (k: generalized_signs.len) {
-      control (cheb_block == k) {
-        U(0, 0, 0, (pi / 2) * generalized_signs[k], walk_data[0]);
-        power (k) {
-          walk_operator(walk_block, walk_data);
-        }
-      }
-    }
-  }
-}
-
 qfunc main(output ham_block: qnum, output data: qnum, output exp_block: qnum) {
   allocate(4, exp_block);
   allocate(2, ham_block);