# --- Polars (lazy) ---
import polars as pl
from aqora_cli.pyarrow import dataset
df = pl.scan_pyarrow_dataset(dataset("leopla/mnisq", "v1.0.0")).collect()
qasm_str = df["qasm"][0]
sgz = df["state_gz"][0]  # None for Base entries

# --- pandas (eager) ---
import pandas as pd
df = pd.read_parquet("aqora://leopla/mnisq/v1.0.0")
qasm_str = df.loc[df.index[0], "qasm"]
sgz = df.loc[df.index[0], "state_gz"]  # NaN/None for Base entries

import gzip, numpy as np
state = None
if sgz is not None and not (isinstance(sgz, float) and np.isnan(sgz)):
    if isinstance(sgz, memoryview):
        sgz = sgz.tobytes()
    if isinstance(sgz, bytearray):
        sgz = bytes(sgz)
    text = gzip.decompress(sgz).decode("utf-8")
    pairs = [tuple(map(float, line.split())) for line in text.splitlines() if line.strip()]
    state = np.array([complex(r, i) for r, i in pairs], dtype=np.complex128)
print("Loaded state amplitudes:", None if state is None else state.shape)

from qiskit import QuantumCircuit
try:
    # OpenQASM 2
    qc = QuantumCircuit.from_qasm_str(qasm_str)
except Exception:
    # OpenQASM 3
    from qiskit.qasm3 import loads as qasm3_loads
    qc = qasm3_loads(qasm_str)
print(qc)  # or qc.draw("mpl")
# If you have a state vector (DenseMatrix rows):
if state is not None:
    from qiskit.quantum_info import Statevector
    sv = Statevector(state)
    print("Qiskit Statevector dim:", sv.dim)

import pennylane as qml
import numpy as np
# Option A — parse QASM directly (requires a PL version with QASM loading):
qnode = None
try:
    dev = qml.device("default.qubit")
    qnode = qml.from_qasm(qasm_str, device=dev)  # type: ignore[attr-defined]
    print("Loaded PennyLane circuit from QASM")
except Exception:
    pass
# Option B — initialize from provided state (works whenever `state` is available)
if qnode is None and state is not None:
    n_qubits = int(np.log2(state.size))
    dev = qml.device("default.qubit", wires=n_qubits)
    @qml.qnode(dev)
    def qnode():
        qml.StatePrep(state, wires=range(n_qubits))
        return qml.state()
    psi = qnode()
    print("Initialized PennyLane from amplitudes; |ψ|^2 sum:", float(np.sum(np.abs(psi)**2)))

import cirq
from cirq.contrib.qasm_import import circuit_from_qasm
cc = circuit_from_qasm(qasm_str)
print(cc)
# If you have a state vector:
if state is not None:
    sim = cirq.Simulator()
    n_qubits = len(cc.all_qubits())
    assert state.size == 2**n_qubits, "State size must match circuit qubit count."
    result = sim.simulate(cc, initial_state=state)
    print("Final state norm:", float(np.linalg.norm(result.final_state_vector)))

import numpy as np
import matplotlib.pyplot as plt
# `state` from step 2 above (complex vector)
assert state is not None, "This example needs a DenseMatrix row with state_gz."
image_array = np.reshape(np.abs(state[:784]), (28, 28))
plt.imshow(image_array)
plt.axis("off")
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import pennylane as qml
# Try to build a PL circuit directly from QASM (requires PL with qasm support)
try:
    dev = qml.device("default.qubit")
    qnode = qml.from_qasm(qasm_str, device=dev)  # type: ignore[attr-defined]
    @qml.qnode(dev)
    def circuit():
        qnode()  # execute loaded circuit
        return qml.state()
    psi = circuit()
    image_array = np.reshape(np.abs(psi[:784]), (28, 28))
    plt.imshow(image_array)
    plt.axis("off")
    plt.show()
except Exception as e:
    print("PennyLane QASM loader unavailable; use the state_gz path or Qiskit/Cirq to simulate.")

@misc{placidi2023mnisq,
  title         = {MNISQ: A Large-Scale Quantum Circuit Dataset for Machine Learning on/for Quantum Computers in the NISQ era},
  author        = {Placidi, Leonardo and Hataya, Ryuichiro and Mori, Toshio and Aoyama, Koki and Morisaki, Hayata and Mitarai, Kosuke and Fujii, Keisuke},
  year          = {2023},
  eprint        = {2306.16627},
  archivePrefix = {arXiv},
  primaryClass  = {quant-ph},
  doi           = {10.48550/arXiv.2306.16627},
  url           = {https://arxiv.org/abs/2306.16627}
}

@misc{aqora_mnisq_full,
  title        = {MNISQ: Comprehensive Quantum Circuit Corpus (Aqora mirror)},
  howpublished = {\url{https://aqora.io/datasets/leopla/mnisq}},
  note         = {Aqora Datasets Hub. Please cite the pinned version you used, e.g., v1.0.0},
  year         = {2025},
  publisher    = {Aqora}
}