State compression - fine tuning

import qiskit
import numpy as np
import pandas as pd
from qiskit.circuit.library import QFT
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
from haiqu.sdk import haiqu

haiqu.login()
haiqu.init("State Compression Tutorial")

def build_heisenberg_evolution_circuit(num_qubits, w, t, num_steps, seed=None):
    """
    Builds a quantum circuit of Trotterized Heisenberg evolution, started from the antiferromagnetic state.
    
    Parameters:
    - num_qubits (int): Number of qubits.
    - w (float): Intensity of the disorder
    - t (float): Time step
    - num_steps (int): Number of Trotter steps
    - seed (int|None): optional seed for setting the random field
    
    Returns:
    - QuantumCircuit implementing the Trotter evolution.
    """
    rng = np.random.default_rng(seed=seed)  # we specify the seed to be able to reproduce the circuits
    h_x = rng.uniform(-w, w, size=num_qubits)
    h_z = rng.uniform(-w, w, size=num_qubits)

    paulis = []  # pauli strings
    coeffs = []  # coefficients of the corresponding strings

    for i in range(num_qubits - 1):  # add ZZ, XX, YY components
        for op in ["Z", "X", "Y"]:
            pauli = ["I"] * num_qubits
            pauli[i] = op
            pauli[i + 1] = op
            
            paulis.append("".join(pauli))
            coeffs.append(1)

    # adding disorder components
    for i in range(num_qubits):
        pauli = ["I"] * num_qubits
        pauli[i] = "X"
        paulis.append("".join(pauli))
        coeffs.append(h_x[i])
    
        pauli = ["I"] * num_qubits
        pauli[i] = "Z"
        paulis.append("".join(pauli))
        coeffs.append(h_z[i])

    hamiltonian = SparsePauliOp(paulis, coeffs)  # creating the hamiltonian

    # creating an antiferromagnetic state
    qc_init = qiskit.QuantumCircuit(num_qubits)
    for i in range(0, num_qubits, 2):
        qc_init.x(i)

    # a circuit, implementing a single Trotter step
    trotter_step = PauliEvolutionGate(hamiltonian, time=t)

    # building the evolution circuit
    qc = qc_init.copy()
    for i in range(num_steps):
        qc = qc.compose(trotter_step)
    qc.name = "evolution"
    
    return qc

evolution_circuit = build_heisenberg_evolution_circuit(25, 1, 0.1, 10, seed=42)

evolution_circuit_meta = haiqu.transpile(evolution_circuit, device=haiqu.get_device("aer_simulator"))
evolution_circuit_meta.core_metrics()

# Initialize scenarios.
scenarios = [
    {"fine_tuning": "disabled", "description": "No fine-tuning"},
    {"fine_tuning": "low", "description": "Low fine-tuning"},
    {"fine_tuning": "heavy", "description": "Extensive fine-tuning"},
]
# Loop over scenarios and initialize results.
results = []
for scenario in scenarios:
    job_h = haiqu.state_compression(circuit=evolution_circuit, fine_tuning=scenario["fine_tuning"])
    circuit, quality = job_h.result()

    compression_time = job_h.logs.split()[job_h.logs.split().index("time:") + 1]
    
    # Store results for summary table.
    results.append({"compression_time": compression_time, "quality": quality, "description": scenario["description"]})

def build_summary(results):
    """Build summary table data from experiment results."""
    return {
        'Configuration': [r["description"] for r in results],
        'Compression time': [r["compression_time"] for r in results],
        'Compression quality': [r["quality"] for r in results],
        'Business Impact': [
            'Base compression quality and fast result',
            'Significan quality boost with low time cost',
            'Maximally improved quality with high time cost',
        ]
    }

pd.DataFrame(build_summary(results))