diff --git a/.gitignore b/.gitignore index 8707db1f..1658e671 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ # Python # Byte-compiled / optimized / DLL files __pycache__/ +downloaded_hamlib_files/ *.py[cod] *$py.class diff --git a/hamlib/qiskit/benchmarks-qiskit.ipynb b/hamlib/qiskit/benchmarks-qiskit.ipynb index 4040131e..5e747abc 100644 --- a/hamlib/qiskit/benchmarks-qiskit.ipynb +++ b/hamlib/qiskit/benchmarks-qiskit.ipynb @@ -16,8 +16,8 @@ "metadata": {}, "outputs": [], "source": [ - "min_qubits=2\n", - "max_qubits=2\n", + "min_qubits=6\n", + "max_qubits=6\n", "skip_qubits=1\n", "max_circuits=1\n", "num_shots=1000\n", @@ -139,75 +139,270 @@ "output_type": "stream", "text": [ "Hamiltonian Simulation Benchmark Program - Qiskit\n", - "... execution starting at Jun 18, 2024 02:18:18 UTC\n", + "... execution starting at Jun 19, 2024 21:40:18 UTC\n", "************\n", - "Executing [1] circuits with num_qubits = 2\n", - "[('ZZ', [0, 1], 1.0)]\n", - "Number of qubits 2\n", - "Hamiltonian: SparsePauliOp(['ZZ'],\n", - " coeffs=[1.+0.j])\n", - " ┌──────────────┐ ░ ┌───────────────────┐ ░ ░ ┌─┐ \n", - " q_0: ┤0 ├─░─┤0 ├─░──░─┤M├───\n", - " │ circuit-196 │ ░ │ exp(-it ZZ)(0.2) │ ░ ░ └╥┘┌─┐\n", - " q_1: ┤1 ├─░─┤1 ├─░──░──╫─┤M├\n", - " └──────────────┘ ░ └───────────────────┘ ░ ░ ║ └╥┘\n", - "meas: 2/═══════════════════════════════════════════════╩══╩═\n", - " 0 1 \n", - "... submit circuit - group=2 id=0 shots=1000 params=None\n", - " ... executing job f1eedcb7-37a0-45ce-8be2-db4e76afc159\n", - "rr\n", - "... job complete - group=2 id=0 shots=1000\n", + "Executing [1] circuits with num_qubits = 6\n", + "Downloaded downloaded_hamlib_files/FH_D-1.zip successfully.\n", + "Extracted to downloaded_hamlib_files.\n", + "downloaded_path downloaded_hamlib_files\n", + "hdf5_file_path downloaded_hamlib_files/FH_D-1.hdf5\n", + "b'(-0.5+0j) [X0 X1] +\\n(-0.5+0j) [Y0 Y1] +\\n(-0.5+0j) [X1 X2] +\\n(-0.5+0j) [Y1 Y2] +\\n(-0.5+0j) [X3 X4] +\\n(-0.5+0j) [Y3 Y4] +\\n(-0.5+0j) [X4 X5] +\\n(-0.5+0j) [Y4 Y5]'\n", + "Raw Hamiltonian Data: b'(-0.5+0j) [X0 X1] +\\n(-0.5+0j) [Y0 Y1] +\\n(-0.5+0j) [X1 X2] +\\n(-0.5+0j) [Y1 Y2] +\\n(-0.5+0j) [X3 X4] +\\n(-0.5+0j) [Y3 Y4] +\\n(-0.5+0j) [X4 X5] +\\n(-0.5+0j) [Y4 Y5]'\n", + "Number of qubits: 6\n", + "Hamiltonian:\n", + "SparsePauliOp(['XXIIII', 'YYIIII', 'IXXIII', 'IYYIII', 'IIIXXI', 'IIIYYI', 'IIIIXX', 'IIIIYY'],\n", + " coeffs=[-0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j,\n", + " -0.5+0.j])\n", + " ┌──────────────┐ ░ »\n", + " q_0: ┤0 ├─░─»\n", + " │ │ ░ »\n", + " q_1: ┤1 ├─░─»\n", + " │ │ ░ »\n", + " q_2: ┤2 ├─░─»\n", + " │ circuit-196 │ ░ »\n", + " q_3: ┤3 ├─░─»\n", + " │ │ ░ »\n", + " q_4: ┤4 ├─░─»\n", + " │ │ ░ »\n", + " q_5: ┤5 ├─░─»\n", + " └──────────────┘ ░ »\n", + "meas: 6/═══════════════════»\n", + " »\n", + "« ┌────────────────────────────────────────────────────────────────────────────────────────┐»\n", + "« q_0: ┤0 ├»\n", + "« │ │»\n", + "« q_1: ┤1 ├»\n", + "« │ │»\n", + "« q_2: ┤2 ├»\n", + "« │ exp(-it (XXIIII + YYIIII + IXXIII + IYYIII + IIIXXI + IIIYYI + IIIIXX + IIIIYY))(0.2) │»\n", + "« q_3: ┤3 ├»\n", + "« │ │»\n", + "« q_4: ┤4 ├»\n", + "« │ │»\n", + "« q_5: ┤5 ├»\n", + "« └────────────────────────────────────────────────────────────────────────────────────────┘»\n", + "«meas: 6/══════════════════════════════════════════════════════════════════════════════════════════»\n", + "« »\n", + "« ░ ░ ┌─┐ \n", + "« q_0: ─░──░─┤M├───────────────\n", + "« ░ ░ └╥┘┌─┐ \n", + "« q_1: ─░──░──╫─┤M├────────────\n", + "« ░ ░ ║ └╥┘┌─┐ \n", + "« q_2: ─░──░──╫──╫─┤M├─────────\n", + "« ░ ░ ║ ║ └╥┘┌─┐ \n", + "« q_3: ─░──░──╫──╫──╫─┤M├──────\n", + "« ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + "« q_4: ─░──░──╫──╫──╫──╫─┤M├───\n", + "« ░ ░ ║ ║ ║ ║ └╥┘┌─┐\n", + "« q_5: ─░──░──╫──╫──╫──╫──╫─┤M├\n", + "« ░ ░ ║ ║ ║ ║ ║ └╥┘\n", + "«meas: 6/═══════╩══╩══╩══╩══╩══╩═\n", + "« 0 1 2 3 4 5 \n", + "... submit circuit - group=6 id=0 shots=1000 params=None\n", + " ... executing job 2c97f585-94dc-4d1c-a08e-e9c552b45fd6\n", + "\n", + "... job complete - group=6 id=0 shots=1000\n", "... computed exec times: queued = 0.001, creating/transpiling = 0.001, validating = 0.001, running = 0.001\n", - "[('ZZ', [0, 1], 1.0)]\n", - "Number of qubits 2\n", - "Hamiltonian: SparsePauliOp(['ZZ'],\n", - " coeffs=[1.+0.j])\n", - " ┌──────────────┐ ░ ┌───────────────────┐ ░ ░ ┌─┐ \n", - " q_0: ┤0 ├─░─┤0 ├─░──░─┤M├───\n", - " │ circuit-213 │ ░ │ exp(-it ZZ)(0.2) │ ░ ░ └╥┘┌─┐\n", - " q_1: ┤1 ├─░─┤1 ├─░──░──╫─┤M├\n", - " └──────────────┘ ░ └───────────────────┘ ░ ░ ║ └╥┘\n", - "meas: 2/═══════════════════════════════════════════════╩══╩═\n", - " 0 1 \n", + "Downloaded downloaded_hamlib_files/FH_D-1.zip successfully.\n", + "Extracted to downloaded_hamlib_files.\n", + "downloaded_path downloaded_hamlib_files\n", + "hdf5_file_path downloaded_hamlib_files/FH_D-1.hdf5\n", + "b'(-0.5+0j) [X0 X1] +\\n(-0.5+0j) [Y0 Y1] +\\n(-0.5+0j) [X1 X2] +\\n(-0.5+0j) [Y1 Y2] +\\n(-0.5+0j) [X3 X4] +\\n(-0.5+0j) [Y3 Y4] +\\n(-0.5+0j) [X4 X5] +\\n(-0.5+0j) [Y4 Y5]'\n", + "Raw Hamiltonian Data: b'(-0.5+0j) [X0 X1] +\\n(-0.5+0j) [Y0 Y1] +\\n(-0.5+0j) [X1 X2] +\\n(-0.5+0j) [Y1 Y2] +\\n(-0.5+0j) [X3 X4] +\\n(-0.5+0j) [Y3 Y4] +\\n(-0.5+0j) [X4 X5] +\\n(-0.5+0j) [Y4 Y5]'\n", + "Number of qubits: 6\n", + "Hamiltonian:\n", + "SparsePauliOp(['XXIIII', 'YYIIII', 'IXXIII', 'IYYIII', 'IIIXXI', 'IIIYYI', 'IIIIXX', 'IIIIYY'],\n", + " coeffs=[-0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j, -0.5+0.j,\n", + " -0.5+0.j])\n", + " ┌──────────────┐ ░ »\n", + " q_0: ┤0 ├─░─»\n", + " │ │ ░ »\n", + " q_1: ┤1 ├─░─»\n", + " │ │ ░ »\n", + " q_2: ┤2 ├─░─»\n", + " │ circuit-246 │ ░ »\n", + " q_3: ┤3 ├─░─»\n", + " │ │ ░ »\n", + " q_4: ┤4 ├─░─»\n", + " │ │ ░ »\n", + " q_5: ┤5 ├─░─»\n", + " └──────────────┘ ░ »\n", + "meas: 6/═══════════════════»\n", + " »\n", + "« ┌────────────────────────────────────────────────────────────────────────────────────────┐»\n", + "« q_0: ┤0 ├»\n", + "« │ │»\n", + "« q_1: ┤1 ├»\n", + "« │ │»\n", + "« q_2: ┤2 ├»\n", + "« │ exp(-it (XXIIII + YYIIII + IXXIII + IYYIII + IIIXXI + IIIYYI + IIIIXX + IIIIYY))(0.2) │»\n", + "« q_3: ┤3 ├»\n", + "« │ │»\n", + "« q_4: ┤4 ├»\n", + "« │ │»\n", + "« q_5: ┤5 ├»\n", + "« └────────────────────────────────────────────────────────────────────────────────────────┘»\n", + "«meas: 6/══════════════════════════════════════════════════════════════════════════════════════════»\n", + "« »\n", + "« ░ ░ ┌─┐ \n", + "« q_0: ─░──░─┤M├───────────────\n", + "« ░ ░ └╥┘┌─┐ \n", + "« q_1: ─░──░──╫─┤M├────────────\n", + "« ░ ░ ║ └╥┘┌─┐ \n", + "« q_2: ─░──░──╫──╫─┤M├─────────\n", + "« ░ ░ ║ ║ └╥┘┌─┐ \n", + "« q_3: ─░──░──╫──╫──╫─┤M├──────\n", + "« ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + "« q_4: ─░──░──╫──╫──╫──╫─┤M├───\n", + "« ░ ░ ║ ║ ║ ║ └╥┘┌─┐\n", + "« q_5: ─░──░──╫──╫──╫──╫──╫─┤M├\n", + "« ░ ░ ║ ║ ║ ║ ║ └╥┘\n", + "«meas: 6/═══════╩══╩══╩══╩══╩══╩═\n", + "« 0 1 2 3 4 5 \n", "{ 'aux_ops_evaluated': [],\n", - " 'evolved_state': Statevector([0. +0.j , 0.98006658+0.19866933j,\n", - " 0. +0.j , 0. +0.j ],\n", - " dims=(2, 2)),\n", + " 'evolved_state': Statevector([ 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , -0.03894465+0.j ,\n", + " 0. +0.j , 0. +0.18950271j,\n", + " -0.03894465+0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.18950271j,\n", + " 0. +0.j , 0.92211071+0.j ,\n", + " 0. +0.18950271j, 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , -0.03894465+0.j ,\n", + " 0. +0.j , 0. +0.18950271j,\n", + " -0.03894465+0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ,\n", + " 0. +0.j , 0. +0.j ],\n", + " dims=(2, 2, 2, 2, 2, 2)),\n", " 'observables': [],\n", " 'times': array([0. , 0.2])}\n", - "{'11': 3, '10': 3, '00': 4, '01': 990} {'01': 1.0}\n", + "{'000100': 1, '000011': 1, '100011': 1, '010111': 7, '001110': 1, '001011': 2, '110011': 1, '000101': 12, '011101': 7, '001111': 1, '001101': 31, '010011': 38, '100110': 1, '010100': 8, '100101': 36, '010001': 5, '100111': 1, '111101': 1, '110101': 5, '010110': 38, '010101': 802} {'001011': 0.0015166854774452483, '001101': 0.03591127537095574, '001110': 0.0015166854774452483, '010011': 0.03591127537095574, '010101': 0.8502881566063959, '010110': 0.03591127537095574, '100011': 0.0015166854774452483, '100101': 0.03591127537095574, '100110': 0.0015166854774452483}\n", "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 3, 0.0\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 5, 0.5, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.062, 0.117, 0.007 secs\n", - "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.99, 0.987\n", - "\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 10, 0.0\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 23, 0.246, 16.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.677, 0.024, 0.011 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.95, 0.947\n", "\n", - "... execution complete at Jun 18, 2024 02:18:19 UTC in 0.572 secs\n", + "... execution complete at Jun 19, 2024 21:40:20 UTC in 1.56 secs\n", "\n", "Sample Circuit:\n", - " ┌──────────────┐ ░ ┌───────────────────┐ ░ ░ ┌─┐ \n", - " q_0: ┤0 ├─░─┤0 ├─░──░─┤M├───\n", - " │ circuit-213 │ ░ │ exp(-it ZZ)(0.2) │ ░ ░ └╥┘┌─┐\n", - " q_1: ┤1 ├─░─┤1 ├─░──░──╫─┤M├\n", - " └──────────────┘ ░ └───────────────────┘ ░ ░ ║ └╥┘\n", - "meas: 2/═══════════════════════════════════════════════╩══╩═\n", - " 0 1 \n", + " ┌──────────────┐ ░ »\n", + " q_0: ┤0 ├─░─»\n", + " │ │ ░ »\n", + " q_1: ┤1 ├─░─»\n", + " │ │ ░ »\n", + " q_2: ┤2 ├─░─»\n", + " │ circuit-196 │ ░ »\n", + " q_3: ┤3 ├─░─»\n", + " │ │ ░ »\n", + " q_4: ┤4 ├─░─»\n", + " │ │ ░ »\n", + " q_5: ┤5 ├─░─»\n", + " └──────────────┘ ░ »\n", + "meas: 6/═══════════════════»\n", + " »\n", + "« ┌────────────────────────────────────────────────────────────────────────────────────────┐»\n", + "« q_0: ┤0 ├»\n", + "« │ │»\n", + "« q_1: ┤1 ├»\n", + "« │ │»\n", + "« q_2: ┤2 ├»\n", + "« │ exp(-it (XXIIII + YYIIII + IXXIII + IYYIII + IIIXXI + IIIYYI + IIIIXX + IIIIYY))(0.2) │»\n", + "« q_3: ┤3 ├»\n", + "« │ │»\n", + "« q_4: ┤4 ├»\n", + "« │ │»\n", + "« q_5: ┤5 ├»\n", + "« └────────────────────────────────────────────────────────────────────────────────────────┘»\n", + "«meas: 6/══════════════════════════════════════════════════════════════════════════════════════════»\n", + "« »\n", + "« ░ ░ ┌─┐ \n", + "« q_0: ─░──░─┤M├───────────────\n", + "« ░ ░ └╥┘┌─┐ \n", + "« q_1: ─░──░──╫─┤M├────────────\n", + "« ░ ░ ║ └╥┘┌─┐ \n", + "« q_2: ─░──░──╫──╫─┤M├─────────\n", + "« ░ ░ ║ ║ └╥┘┌─┐ \n", + "« q_3: ─░──░──╫──╫──╫─┤M├──────\n", + "« ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + "« q_4: ─░──░──╫──╫──╫──╫─┤M├───\n", + "« ░ ░ ║ ║ ║ ║ └╥┘┌─┐\n", + "« q_5: ─░──░──╫──╫──╫──╫──╫─┤M├\n", + "« ░ ░ ║ ║ ║ ║ ║ └╥┘\n", + "«meas: 6/═══════╩══╩══╩══╩══╩══╩═\n", + "« 0 1 2 3 4 5 \n", "\n", " circuit = \n", - " ┌──────────────┐ ░ ┌───────────────────┐ ░ ░ ┌─┐ \n", - " q_0: ┤0 ├─░─┤0 ├─░──░─┤M├───\n", - " │ circuit-213 │ ░ │ exp(-it ZZ)(0.2) │ ░ ░ └╥┘┌─┐\n", - " q_1: ┤1 ├─░─┤1 ├─░──░──╫─┤M├\n", - " └──────────────┘ ░ └───────────────────┘ ░ ░ ║ └╥┘\n", - "meas: 2/═══════════════════════════════════════════════╩══╩═\n", - " 0 1 \n" + " ┌──────────────┐ ░ »\n", + " q_0: ┤0 ├─░─»\n", + " │ │ ░ »\n", + " q_1: ┤1 ├─░─»\n", + " │ │ ░ »\n", + " q_2: ┤2 ├─░─»\n", + " │ circuit-196 │ ░ »\n", + " q_3: ┤3 ├─░─»\n", + " │ │ ░ »\n", + " q_4: ┤4 ├─░─»\n", + " │ │ ░ »\n", + " q_5: ┤5 ├─░─»\n", + " └──────────────┘ ░ »\n", + "meas: 6/═══════════════════»\n", + " »\n", + "« ┌────────────────────────────────────────────────────────────────────────────────────────┐»\n", + "« q_0: ┤0 ├»\n", + "« │ │»\n", + "« q_1: ┤1 ├»\n", + "« │ │»\n", + "« q_2: ┤2 ├»\n", + "« │ exp(-it (XXIIII + YYIIII + IXXIII + IYYIII + IIIXXI + IIIYYI + IIIIXX + IIIIYY))(0.2) │»\n", + "« q_3: ┤3 ├»\n", + "« │ │»\n", + "« q_4: ┤4 ├»\n", + "« │ │»\n", + "« q_5: ┤5 ├»\n", + "« └────────────────────────────────────────────────────────────────────────────────────────┘»\n", + "«meas: 6/══════════════════════════════════════════════════════════════════════════════════════════»\n", + "« »\n", + "« ░ ░ ┌─┐ \n", + "« q_0: ─░──░─┤M├───────────────\n", + "« ░ ░ └╥┘┌─┐ \n", + "« q_1: ─░──░──╫─┤M├────────────\n", + "« ░ ░ ║ └╥┘┌─┐ \n", + "« q_2: ─░──░──╫──╫─┤M├─────────\n", + "« ░ ░ ║ ║ └╥┘┌─┐ \n", + "« q_3: ─░──░──╫──╫──╫─┤M├──────\n", + "« ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + "« q_4: ─░──░──╫──╫──╫──╫─┤M├───\n", + "« ░ ░ ║ ║ ║ ║ └╥┘┌─┐\n", + "« q_5: ─░──░──╫──╫──╫──╫──╫─┤M├\n", + "« ░ ░ ║ ║ ║ ║ ║ └╥┘\n", + "«meas: 6/═══════╩══╩══╩══╩══╩══╩═\n", + "« 0 1 2 3 4 5 \n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -217,7 +412,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/hamlib/qiskit/hamiltonian_simulation_kernel.py b/hamlib/qiskit/hamiltonian_simulation_kernel.py index 1de81eb2..114a3d00 100644 --- a/hamlib/qiskit/hamiltonian_simulation_kernel.py +++ b/hamlib/qiskit/hamiltonian_simulation_kernel.py @@ -13,11 +13,16 @@ from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister # from hamlib_test import create_circuit, HamiltonianSimulationExact import h5py +import re +import os +import requests +import zipfile from qiskit.quantum_info import SparsePauliOp, Pauli from qiskit.circuit import QuantumCircuit from qiskit.circuit.library import PauliEvolutionGate from qiskit.quantum_info import SparsePauliOp + # Saved circuits and subcircuits for display QC_ = None XX_ = None @@ -34,156 +39,259 @@ # For validating the implementation of XXYYZZ operation (saved for possible use in drawing) _use_XX_YY_ZZ_gates = False -def extract_dataset_hdf5_2(filename, dataset_name): +def extract_dataset_hdf5(filename, dataset_name): """ Extract a dataset from an HDF5 file. - + Args: - filename (str): The name of the HDF5 file. + filename (str): The path to the HDF5 file. dataset_name (str): The name of the dataset to extract. Returns: - data: The extracted data. Returns None if the dataset is not found. + numpy.ndarray or None: The extracted dataset as a NumPy array, or None if the dataset is not found. + """ # Open the HDF5 file with h5py.File(filename, 'r') as file: - # Check if the dataset exists if dataset_name in file: dataset = file[dataset_name] - # Check if the dataset is a scalar - if dataset.shape == (): - data = dataset[()] # Correct way to read scalar data - else: - data = dataset[:] # For non-scalar, use slicing - # Convert bytes to string if necessary - if isinstance(data, bytes): - data = data.decode('utf-8') + data = dataset[()] if dataset.shape == () else dataset[:] else: data = None print(f"Dataset {dataset_name} not found in the file.") return data -def parse_hamiltonian(hamiltonian): +def needs_normalization(data): """ - Parse a Hamiltonian string into a list of Pauli terms with coefficients and involved qubits. - + Determine if the given data needs normalization. + Args: - hamiltonian (str): The Hamiltonian string to be parsed. - + data (str or bytes): The data to be checked. Can be a string or bytes. + + Returns: + str: "Yes" if the data needs normalization, "No" otherwise. + """ + if isinstance(data, bytes): + data = data.decode() + # Check if the data matches the format that does not need normalization + if re.search(r'\(\s*-?\d+(\.\d+)?(\+|\-)?\d*?j?\s*\)\s*\[.*?\]', data): + return "No" + else: + return "Yes" + +def normalize_data_format(data): + """ + Normalize the format of the given data. + + Args: + data (str or bytes): The data to be normalized. Can be a string or bytes. + + Returns: + bytes: The normalized data as a byte string. + """ + if isinstance(data, bytes): + data = data.decode() + normalized_data = [] + terms = data.split('+') + for term in terms: + term = term.strip() + if term: + match = re.match(r'(\S+)\s*\[(.*?)\]', term) + if match: + coeff = match.group(1) + ops = match.group(2).strip() + normalized_term = f"({coeff}) [{ops}]" + normalized_data.append(normalized_term) + return ' +\n'.join(normalized_data).encode() + +def parse_hamiltonian_to_sparsepauliop(data): + """ + Parse the Hamiltonian string into a list of SparsePauliOp terms. + + Args: + data (str or bytes): The Hamiltonian data to be parsed. Can be a string or bytes. + Returns: - list: A list of tuples, each containing a Pauli string, a list of involved qubits, and a coefficient. + list: A list of tuples, where each tuple contains a dictionary representing the Pauli operators and + their corresponding qubit indices, and a complex coefficient. """ - import re - # Regular expression to capture numeric coefficients and the involved qubits - term_pattern = re.compile(r'([+-]?\d*\.?\d*) \[([Z\d\s]*)\]') + if isinstance(data, bytes): + data = data.decode() - pauli_list = [] + terms = re.findall(r'\(([^)]+)\)\s*\[(.*?)\]', data) - # Iterate over all matches - for match in term_pattern.finditer(hamiltonian): - coefficient = float(match.group(1)) # Convert coefficient to float - if not coefficient: # Skip terms with a coefficient of 0 - continue - - # Extract qubits and construct the Pauli string - qubits = [] - pauli_string = '' - if match.group(2): # Check if there are any qubits - qubits_info = match.group(2).split() - for qubit_info in qubits_info: - qubit_index = int(qubit_info[1:]) # Extract the qubit index from the format Z0, Z1, etc. - qubits.append(qubit_index) - pauli_string += 'Z' - - pauli_list.append((pauli_string, qubits, coefficient)) + parsed_pauli_list = [] + + for coeff, ops in terms: + coeff = complex(coeff.strip()) + ops_list = ops.split() + pauli_dict = {} + + for op in ops_list: + match = re.match(r'([XYZ])(\d+)', op) + if match: + pauli_op = match.group(1) + qubit_index = int(match.group(2)) + pauli_dict[qubit_index] = pauli_op + + parsed_pauli_list.append((pauli_dict, coeff)) - return pauli_list + return parsed_pauli_list def determine_qubit_count(terms): """ - Determine the number of qubits required for a given list of Pauli terms. - + Determine the number of qubits required based on the given list of Pauli terms. + Args: - terms (list): A list of tuples, each containing a Pauli string, a list of involved qubits, and a coefficient. - + terms (list): A list of tuples, where each tuple contains a dictionary representing the Pauli operators and + their corresponding qubit indices, and a complex coefficient. + Returns: - int: The total number of qubits required, determined by the highest qubit index in the terms. + int: The number of qubits required. """ max_qubit = 0 - for _, qubits, _ in terms: - if qubits: # Ensure the list is not empty - max_in_term = max(qubits) + for pauli_dict, _ in terms: + if pauli_dict: + max_in_term = max(pauli_dict.keys()) if max_in_term > max_qubit: max_qubit = max_in_term return max_qubit + 1 # Since qubit indices start at 0 def sparse_pauliop(terms, num_qubits): """ - Create a SparsePauliOp representation from a list of Pauli terms and the number of qubits. - + Construct a SparsePauliOp from a list of Pauli terms and the number of qubits. + Args: - terms (list): A list of tuples, each containing a Pauli string, a list of involved qubits, and a coefficient. - num_qubits (int): The total number of qubits in the system. - + terms (list): A list of tuples, where each tuple contains a dictionary representing the Pauli operators and + their corresponding qubit indices, and a complex coefficient. + num_qubits (int): The total number of qubits. + Returns: - SparsePauliOp: The Hamiltonian represented as a SparsePauliOp object. + SparsePauliOp: The Hamiltonian represented as a SparsePauliOp. """ - edges = [] pauli_list = [] - for pauli_string, qubits, coefficient in terms: - # Generate PauliOp representation - label = ''.join(['I']*num_qubits) # Start with identity on all qubits - if qubits: - label_list = list(label) - for qubit in qubits: - label_list[qubit] = 'Z' - label = ''.join(label_list) + for pauli_dict, coefficient in terms: + label = ['I'] * num_qubits # Start with identity on all qubits + for qubit, pauli_op in pauli_dict.items(): + label[qubit] = pauli_op + label = ''.join(label) pauli_list.append((label, coefficient)) - - # Generate edges for ZZ interactions (representing graph edges) - if len(qubits) == 2 and pauli_string == 'ZZ': - edges.append((qubits[0], qubits[1], coefficient)) - # Creating the SparsePauliOp from the list of Pauli terms - hamiltonian = SparsePauliOp.from_list(pauli_list) + hamiltonian = SparsePauliOp.from_list(pauli_list, num_qubits=num_qubits) return hamiltonian -def create_circuit(): +def process_data(data): """ - Create and return a quantum circuit based on the Hamiltonian extracted from an HDF5 file. + Process the given data to construct a Hamiltonian in the form of a SparsePauliOp and determine the number of qubits. + + Args: + data (str or bytes): The Hamiltonian data to be processed. Can be a string or bytes. + + Returns: + tuple: A tuple containing the Hamiltonian as a SparsePauliOp and the number of qubits. + """ + if needs_normalization(data) == "Yes": + data = normalize_data_format(data) + parsed_pauli_list = parse_hamiltonian_to_sparsepauliop(data) + num_qubits = determine_qubit_count(parsed_pauli_list) + hamiltonian = sparse_pauliop(parsed_pauli_list, num_qubits) + return hamiltonian, num_qubits + +def download_and_extract(filename, url): + """ + Download a file from a given URL and unzip it. + + Args: + filename (str): The name of the file to be downloaded. + url (str): The URL to download the file from. + + Returns: + str: The path to the extracted file. + """ + download_dir = "downloaded_hamlib_files" + os.makedirs(download_dir, exist_ok=True) + local_zip_path = os.path.join(download_dir, os.path.basename(url)) - The function performs the following steps: - 1. Extracts the dataset from the HDF5 file. - 2. Parses the Hamiltonian string into Pauli terms. - 3. Determines the number of qubits required. - 4. Converts the Pauli terms into a SparsePauliOp object. - 5. Constructs a quantum circuit with an initial state and evolution gate. - 6. Measures all qubits and returns the circuit and Hamiltonian. + # Download the file + response = requests.get(url) + if response.status_code == 200: + with open(local_zip_path, 'wb') as file: + file.write(response.content) + print(f"Downloaded {local_zip_path} successfully.") + else: + raise Exception(f"Failed to download from {url}.") + + # Unzip the file + with zipfile.ZipFile(local_zip_path, 'r') as zip_ref: + zip_ref.extractall(download_dir) + print(f"Extracted to {download_dir}.") + + # Return the path to the directory containing the extracted files + return download_dir + +def process_hamiltonian_file(filename, dataset_name): + """ + Download the Hamiltonian file, extract it, and process the data to create a quantum circuit. + + Args: + dataset_name (str): The name of the dataset to extract. + filename (str): The name of the Hamiltonian file to be downloaded and processed. Returns: - tuple: A tuple containing the quantum circuit and the Hamiltonian as a SparsePauliOp object. + tuple: A tuple containing the constructed QuantumCircuit and the Hamiltonian as a SparsePauliOp. """ - # Usage - dataset_name = 'graph-1D-grid-nonpbc-qubitnodes_Lx-2_h-0.1' - # filename = '/Users/avimitachatterjee/Library/CloudStorage/OneDrive-ThePennsylvaniaStateUniversity/PSU/Internship/SRI/work/hamiltonnian/QC-App-Oriented-Benchmarks/hamiltonian-simulation/qiskit/tfim.hdf5' - filename = '/Users/avimitachatterjee/Library/CloudStorage/OneDrive-ThePennsylvaniaStateUniversity/PSU/Internship/SRI/work/hamiltonnian/hamlib_tfim/tfim.hdf5' - data = extract_dataset_hdf5_2(filename, dataset_name) + url_mapping = { + 'tfim.hdf5': 'https://portal.nersc.gov/cfs/m888/dcamps/hamlib/condensedmatter/tfim/tfim.zip', + 'FH_D-1.hdf5': 'https://portal.nersc.gov/cfs/m888/dcamps/hamlib/condensedmatter/fermihubbard/FH_D-1.zip' + # Add more mappings as needed + } + + if filename in url_mapping: + url = url_mapping[filename] + extracted_path = download_and_extract(filename, url) + print('downloaded_path',extracted_path) + # Assuming the HDF5 file is located directly inside the extracted folder + hdf5_file_path = os.path.join(extracted_path, filename) + print('hdf5_file_path', hdf5_file_path) + else: + raise ValueError(f"No URL mapping found for filename: {filename}") + data = extract_dataset_hdf5(hdf5_file_path, dataset_name) + print(data) + return data + + +def create_circuit(): + """ + Create a quantum circuit based on the Hamiltonian data from an HDF5 file. + + Steps: + 1. Extract Hamiltonian data from an HDF5 file. + 2. Process the data to obtain a SparsePauliOp and determine the number of qubits. + 3. Build a quantum circuit with an initial state and an evolution gate based on the Hamiltonian. + 4. Measure all qubits and print the circuit details. + + Returns: + tuple: A tuple containing the constructed QuantumCircuit and the Hamiltonian as a SparsePauliOp. + """ + + # dataset_name = 'graph-1D-grid-nonpbc-qubitnodes_Lx-4_h-0.1' + # filename = 'tfim.hdf5' - if data: - parsed_pauli_list = parse_hamiltonian(data) - print(parsed_pauli_list) + dataset_name = 'fh-graph-1D-grid-nonpbc-qubitnodes_Lx-3_U-0_enc-jw' + filename = 'FH_D-1.hdf5' + data = process_hamiltonian_file(filename, dataset_name) + if data is not None: + print("Raw Hamiltonian Data: ",data) else: print("No data extracted.") - # Usage - num_qubits = determine_qubit_count(parsed_pauli_list) - hamiltonian = sparse_pauliop(parsed_pauli_list, num_qubits) + hamiltonian, num_qubits = process_data(data) + + print("Number of qubits:", num_qubits) + print("Hamiltonian:") + print(hamiltonian) - print("Number of qubits",num_qubits) - print("Hamiltonian:", hamiltonian) - - # Assuming 'hamiltonian' is already defined as a SparsePauliOp object from your previous code: operator = hamiltonian # Use the SparsePauliOp object directly time = 0.2 @@ -192,22 +300,18 @@ def create_circuit(): # Plug it into a circuit circuit = QuantumCircuit(operator.num_qubits) - - init_state = "checkerboard" - - # apply initial state circuit.append(initial_state(num_qubits, init_state), range(operator.num_qubits)) circuit.barrier() circuit.append(evo, range(operator.num_qubits)) circuit.barrier() + circuit.measure_all() print (circuit) - circuit.draw(output="mpl") - global QC_ - QC_ = circuit + # circuit.draw(output="mpl") + # circuit.decompose(reps=2).draw(output="mpl", style="iqp") return circuit, hamiltonian - # + ############### Circuit Definition