Fix structure

.internal/paths_for_docs.yaml

@@ -15,8 +15,8 @@ workshops: tutorials/workshops/
 qmod_core_library: functions/qmod_library_reference/qmod_core_library
 classiq_open_library: functions/qmod_library_reference/classiq_open_library
 whats_classiq.ipynb: tutorials/classiq_101/whats_classiq/whats_classiq.ipynb
-qml_with_classiq_guide.ipynb: tutorials/advanced_tutorials/qml_with_classiq_guide/qml_with_classiq_guide.ipynb
-output_30_0.converted.png: tutorials/advanced_tutorials/qml_with_classiq_guide/output_30_0.converted.png
-hamiltonian_simulation_guide.ipynb: tutorials/advanced_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb
-output_37_0.converted.png: tutorials/advanced_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/output_37_0.converted.png
+qml_with_classiq_guide.ipynb: tutorials/basic_tutorials/qml_with_classiq_guide/qml_with_classiq_guide.ipynb
+output_30_0.converted.png: tutorials/basic_tutorials/qml_with_classiq_guide/output_30_0.converted.png
+hamiltonian_simulation_guide.ipynb: tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb
+output_37_0.converted.png: tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/output_37_0.converted.png
 hadamard_test.ipynb: tutorials/classiq_101/hadamard_test/hadamard_test.ipynb

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.metadata.json

@@ -0,0 +1,7 @@
+{
+  "friendly_name": "Hamiltonian simulation guide: Exponentiation with depth constraint",
+  "description": "A simple implementation of exponentiation with depth constraint",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": [],
+  "level": ["basic", "demos"]
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.qmod

@@ -0,0 +1,17 @@
+qfunc main(output qba: qbit[]) {
+  allocate(2, qba);
+  exponentiation_with_depth_constraint([
+    PauliTerm {
+      pauli=[Pauli::Z, Pauli::Z],
+      coefficient=0.3
+    },
+    PauliTerm {
+      pauli=[Pauli::X, Pauli::I],
+      coefficient=0.7
+    },
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::X],
+      coefficient=0.2
+    }
+  ], 1, 30, qba);
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.synthesis_options.json

@@ -0,0 +1 @@
+{}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.metadata.json

@@ -0,0 +1,7 @@
+{
+  "friendly_name": "Hamiltonian simulation guide: qDRIFT",
+  "description": "A simple implementation of the qDRIFT algorithm",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": [],
+  "level": ["basic", "demos"]
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.qmod

@@ -0,0 +1,17 @@
+qfunc main(output qba: qbit[]) {
+  allocate(2, qba);
+  qdrift([
+    PauliTerm {
+      pauli=[Pauli::Z, Pauli::Z],
+      coefficient=0.3
+    },
+    PauliTerm {
+      pauli=[Pauli::X, Pauli::I],
+      coefficient=0.7
+    },
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::X],
+      coefficient=0.2
+    }
+  ], 1, 288, qba);
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.synthesis_options.json

@@ -0,0 +1 @@
+{}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.metadata.json

@@ -0,0 +1,7 @@
+{
+  "friendly_name": "Hamiltonian simulation guide: Suzuki-Trotter",
+  "description": "A simple Suzuki-Trotter implementation",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": [],
+  "level": ["basic", "demos"]
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.qmod

@@ -0,0 +1,17 @@
+qfunc main(output qba: qbit[]) {
+  allocate(2, qba);
+  suzuki_trotter([
+    PauliTerm {
+      pauli=[Pauli::Z, Pauli::Z],
+      coefficient=0.3
+    },
+    PauliTerm {
+      pauli=[Pauli::X, Pauli::I],
+      coefficient=0.7
+    },
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::X],
+      coefficient=0.2
+    }
+  ], 1.0, 1, 10, qba);
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.synthesis_options.json

@@ -0,0 +1 @@
+{}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qsvt.metadata.json

@@ -0,0 +1,7 @@
+{
+  "friendly_name": "Hamiltonian Simulation with QSVT",
+  "description": "Hamiltonian Simulation with QSVT",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": [],
+  "level": ["advanced", "demos"]
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qsvt.qmod

@@ -0,0 +1,116 @@
+qstruct BlockEncodedState {
+  block: qnum<2, False, 0>;
+  data: qnum<2, False, 0>;
+}
+
+qfunc identify_block(state: BlockEncodedState, qubit: qbit) {
+  qubit ^= state.block == 0;
+}
+
+qfunc apply_pauli_term(pauli_string: PauliTerm, x: qbit[]) {
+  repeat (index: x.len) {
+    switch(pauli_string.pauli[index], [lambda() {
+      IDENTITY(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      X(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      Y(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      Z(x[(pauli_string.pauli.len - index) - 1]);
+    }]);
+  }
+}
+
+qfunc lcu_paulis(pauli_terms_list: PauliTerm[], probs: real[], block: qnum, data: qbit[]) {
+  within {
+    inplace_prepare_state(probs, 0.0, block);
+  } apply {
+    repeat (i: pauli_terms_list.len) {
+      control (block == i) {
+        apply_pauli_term(pauli_terms_list[i], data);
+      }
+    }
+  }
+}
+
+qfunc block_encode_hamiltonian(state: BlockEncodedState) {
+  lcu_paulis([
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::I],
+      coefficient=0.4
+    },
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::Z],
+      coefficient=0.1
+    },
+    PauliTerm {
+      pauli=[Pauli::X, Pauli::X],
+      coefficient=0.05
+    },
+    PauliTerm {
+      pauli=[Pauli::Z, Pauli::Z],
+      coefficient=0.2
+    }
+  ], [
+    0.533333333333,
+    0.133333333333,
+    0.066666666667,
+    0.266666666667
+  ], state.block, state.data);
+}
+
+qfunc my_qsvt(phases: real[], qsvt_aux: qbit, state: BlockEncodedState) {
+  qsvt(phases, identify_block, identify_block, block_encode_hamiltonian, state, qsvt_aux);
+}
+
+qfunc main(output qsvt_aux: qbit, output block_exp: qbit, output state: BlockEncodedState) {
+  allocate(1, qsvt_aux);
+  allocate(1, block_exp);
+  allocate(state.size, state);
+  inplace_prepare_amplitudes([
+    0.548063060386,
+    0.373438339534,
+    0.383413436945,
+    0.642778985948
+  ], 0.0, state.data);
+  within {
+    H(block_exp);
+  } apply {
+    control (block_exp == 0) {
+      my_qsvt([
+        2.094521581996,
+        2.664844298205,
+        4.315664742842,
+        3.670436747336,
+        2.683901151266,
+        3.263633853659,
+        6.246929002407,
+        3.263633854137,
+        2.683901151506,
+        (-2.612748559821),
+        4.315664742816,
+        8.948029605379,
+        (-38.746182914658)
+      ], qsvt_aux, state);
+    }
+    control (block_exp == 1) {
+      U(0, 0, 0, pi / 2, qsvt_aux);
+      my_qsvt([
+        1.624980886905,
+        2.939347810592,
+        4.533568111607,
+        2.735661892352,
+        4.801425200666,
+        3.552958819867,
+        0.720706433696,
+        7.003891739734,
+        (-2.730226488722),
+        4.801425200564,
+        2.735661892496,
+        4.533568111705,
+        2.939347810798,
+        (-42.357316263308)
+      ], qsvt_aux, state);
+    }
+  }
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qsvt.synthesis_options.json

@@ -0,0 +1 @@
+{}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.metadata.json

@@ -0,0 +1,7 @@
+{
+  "friendly_name": "Hamiltonian Simulation with Qubitization",
+  "description": "Hamiltonian Simulation with Qubitization",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": [],
+  "level": ["advanced", "demos"]
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod

@@ -0,0 +1,111 @@
+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() {
+      IDENTITY(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      X(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      Y(x[(pauli_string.pauli.len - index) - 1]);
+    }, lambda() {
+      Z(x[(pauli_string.pauli.len - index) - 1]);
+    }]);
+  }
+}
+
+qfunc lcu_paulis(pauli_terms_list: PauliTerm[], probs: real[], block: qnum, data: qbit[]) {
+  within {
+    inplace_prepare_state(probs, 0.0, block);
+  } apply {
+    repeat (i: pauli_terms_list.len) {
+      control (block == i) {
+        apply_pauli_term(pauli_terms_list[i], data);
+      }
+    }
+  }
+}
+
+qfunc my_walk_operator(block: qbit[], data: qbit[]) {
+  lcu_paulis([
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::I],
+      coefficient=0.4
+    },
+    PauliTerm {
+      pauli=[Pauli::I, Pauli::Z],
+      coefficient=0.1
+    },
+    PauliTerm {
+      pauli=[Pauli::X, Pauli::X],
+      coefficient=0.05
+    },
+    PauliTerm {
+      pauli=[Pauli::Z, Pauli::Z],
+      coefficient=0.2
+    }
+  ], [
+    0.533333333333,
+    0.133333333333,
+    0.066666666667,
+    0.266666666667
+  ], block, data);
+  reflect_about_zero(block);
+  RY(2 * pi, block[0]);
+}
+
+qfunc main(output ham_block: qnum, output data: qnum, output exp_block: qnum) {
+  allocate(4, exp_block);
+  allocate(2, ham_block);
+  prepare_amplitudes([
+    0.548063060386,
+    0.373438339534,
+    0.383413436945,
+    0.642778985948
+  ], 0.0, data);
+  lcu_cheb([
+    0.066463021055,
+    0.067500417785,
+    0.1149259307,
+    0.128794247492,
+    0.011890532707,
+    0.141477482379,
+    0.176746110466,
+    0.141316294366,
+    0.087044305684,
+    0.044378224427,
+    0.01946343294,
+    0,
+    0,
+    0,
+    0,
+    0
+  ], [
+    0.0,
+    1.0,
+    0.0,
+    1.0,
+    0.0,
+    1.0,
+    2.0,
+    3.0,
+    0.0,
+    1.0,
+    2.0
+  ], lambda(x, y) {
+    my_walk_operator(x, y);
+  }, ham_block, data, exp_block);
+}

tutorials/basic_tutorials/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.synthesis_options.json

@@ -0,0 +1 @@
+{}