added utils folder

utils/EBU_Quantum

@@ -0,0 +1 @@
+Subproject commit 8b4d693379b544ea9d3b4163189ac46fe52887bb

utils/adapt-aqc

@@ -0,0 +1 @@
+Subproject commit da9bf5895b1b694b167f7eaecae358b670ea29d9

utils/base_functions.py

@@ -0,0 +1,443 @@
+import numpy as np
+import scipy.sparse as sp
+import math
+import random
+import matplotlib.pyplot as plt
+from scipy.special import jn
+from scipy.sparse import identity, csr_matrix, kron, diags, eye
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit.library import MCXGate, MCPhaseGate, RXGate, CRXGate, QFTGate, StatePreparation, PauliEvolutionGate, RZGate
+from qiskit.quantum_info import SparsePauliOp, Statevector, Operator, Pauli
+from scipy.linalg import expm
+# from tools import *
+from qiskit.qasm3 import dumps  # QASM 3 exporter
+from qiskit.qasm3 import loads
+from qiskit.circuit.library import QFT
+from qiskit.primitives import StatevectorEstimator
+from qiskit import transpile
+from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit, apply_circuit_to_state, compute_overlap
+from qiskit_aer import AerSimulator
+
+
+simulator_settings = AerSimulator(
+    method="matrix_product_state",
+    matrix_product_state_max_bond_dimension=100,
+)
+
+def Wj(j, theta, lam, name='Wj', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}$ '
+    qc=QuantumCircuit(j, name=name)
+
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+    if lam != 0:
+        qc.p(lam, j-1)
+    qc.h(j-1)
+    if xgate:
+        qc.x(range(j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        qc.mcrz(theta, range(j-1), j-1)
+    else:
+        qc.rz(theta, j-1)
+    
+    if xgate:
+        qc.x(range(j-1))
+    qc.h(j-1)
+    if lam != 0:
+        qc.p(-lam, j-1)
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+
+    return qc
+
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}_block$ '
+    qc=QuantumCircuit(n + j, name=name)
+
+    if j > 1:
+        qc.cx(n + j-1, range(n, n+j-1))
+    if lam != 0:
+        qc.p(lam, n + j -1)
+    qc.h(n + j -1)
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        mcrz = RZGate(theta).control(len(ctrl_state) + j-1, ctrl_state = "1"*(j-1)+ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    else:
+        mcrz = RZGate(theta).control(len(ctrl_state), ctrl_state = ctrl_state)
+        qc.append(mcrz, range(0, n+j))
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+            
+    qc.h(n+ j-1)
+    if lam != 0:
+        qc.p(-lam, n + j-1)
+    if j > 1:
+        qc.cx(n + j-1, range(n, n +j-1))
+
+    return qc.to_gate(label=name)
+
+def V1(nx, dt, name = "V1"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, n, "0"*n, -dt , 0, xgate=True)
+    qc.append(W1, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W2 = Wj_block(3, n-1, "1"*(n-1), dt , 0, xgate=[0,1])
+    qc.append(W2, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(1, n+1, "0"*(n+1), dt , 0, xgate=False)
+    qc.append(W3, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "0"+"1"*(n-1), -dt , 0, xgate=False)
+    qc.append(W4, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    return qc
+
+def V2(nx, dt, name = "V2"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, 0, "", -2*dt , -np.pi/2, xgate=True)
+    qc.append(W1, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W2 = Wj_block(2+j, 0, "", 2*dt , -np.pi/2, xgate=[1]*(j-1)+[0,1])
+        qc.append(W2, list(derivatives[0:j])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(2, n, "0"*n, -dt , -np.pi/2, xgate=True)
+    qc.append(W3, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "1"*n, 2*dt , -np.pi/2, xgate=True)
+    qc.append(W4, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W5 = Wj_block(3, n-1, "1"*(n-1), dt , -np.pi/2, xgate=[0,1])
+    qc.append(W5, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W6 = Wj_block(1, 1, "0", 2*dt , -np.pi/2, xgate=False)
+    qc.append(W6, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W7 = Wj_block(1+j, 1, "0", -2*dt , -np.pi/2, xgate=[1]*(j-1))
+        qc.append(W7, [blocks[0]]+list(derivatives[n:n+j])+[blocks[1]])
+
+        # qc.barrier()
+
+    W8 = Wj_block(1, n+1, "0"*(n+1), dt , -np.pi/2, xgate=False)
+    qc.append(W8, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W9 = Wj_block(1, n+1, "0"+"1"*(n), -2*dt , -np.pi/2, xgate=False)
+    qc.append(W9, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W10 = Wj_block(2, n, "0"+"1"*(n-1), -dt , -np.pi/2, xgate=False)
+    qc.append(W10, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    # qc.barrier()
+    
+    return qc
+
+def schro(nx, na, R, dt, initial_state, steps):
+
+    nq = int(np.ceil(np.log2(nx)))
+
+    # warped phase transformation
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm1 = np.linalg.norm(fp[2**(na-1):]) # norm of p>=0
+
+    # construct quantum circuit
+    system = QuantumRegister(2*nq+2, name='system')
+    ancilla = QuantumRegister(na, name='ancilla')
+    qc = QuantumCircuit(system, ancilla)
+
+    # initialization
+    prep = StatePreparation(initial_state)
+    anc_prep = StatePreparation(fp / np.linalg.norm(fp))
+
+    qc.append(prep, system)
+    # qc.append(anc_prep, ancilla)
+    qc.initialize(fp / np.linalg.norm(fp), ancilla)
+
+
+    # QFT
+    qc.append(QFTGate(na), ancilla)
+    qc.x(ancilla[-1])
+
+    A1 = V1(nx, dt, name = "V1").to_gate()
+    A2 = V2(nx, dt, name = "V2")
+
+    
+    # Hamiltonian simulation for Nt steps
+    for i in range(steps):
+        # circuit for one step
+        for j in range(na):
+            # repeat controlled H1 for 2**j times
+            qc.append(A1.control().repeat(2**j), [ancilla[j]] + system[:])
+
+        # qc.append(A1.inverse().control(ctrl_state = "0").repeat(2**(na-1)), [ancilla[na-1]] + system[:])
+        qc.append(A1.inverse().repeat(2**(na-1)), system[:])
+        qc.append(A2, system[:])
+
+    # rearrange eta
+    qc.x(ancilla[-1])
+    qc.append(QFTGate(na).inverse(), ancilla)
+
+    return qc
+
+
+
+def circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps):
+
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    index_bin = format(index, f'0{qc.num_qubits-2}b')
+    ctrl_state = '1' + index_bin
+    ctrl_qubits = qc.qubits[:-1]
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state)
+
+    return qc
+
+def circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez'):    
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    if field_ref == 'Ez':
+        index_ref = nx * yref + xref
+    elif field_ref == 'Hx':
+        index_ref = 2*nx*nx + nx * yref + xref
+    else:
+        index_ref = 3*nx*nx + nx * yref + xref
+
+    index_bin = [(index >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_ref_bin = [(index_ref >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_bin.append(1)
+    index_ref_bin.append(1)
+
+    #Convert reference bitstring to 00000 
+    for i, bit in enumerate(index_ref_bin):
+        if bit == 1:
+            qc.x(i)
+
+    d_bits = [b ^ r for b, r in zip(index_ref_bin, index_bin)]
+    control = d_bits.index(1)
+
+    #Convert the other bitstring to 0001000
+    for target, bit in enumerate(d_bits):
+        if bit == 1 and target != control:
+            qc.cx(control, target)
+    qc.h(control)
+
+    ctrl_state_sum = '0'*(qc.num_qubits-1)
+    ctrl_state_diff = '0'*(qc.num_qubits-1-control-1)+'1'+'0'*(control)
+    
+    qcdiff = qc.copy()
+
+    ctrl_qubits = qc.qubits[:-1]
+
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_sum)
+    qcdiff.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_diff)
+
+    return qc, qcdiff
+
+def get_absolute_field_value(qc, nq, na, offset, norm):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator (no parameters needed) ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect = (1 - z_exp) / 2
+
+    Absolute_value = norm*np.sqrt(pi_expect)-offset
+    
+    return Absolute_value
+
+def get_relative_sign(qc, qcdiff, nq, na):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+
+    pub_diff = (qcdiff, observable)
+    job_diff = estimator.run([pub_diff])
+    result_diff = job_diff.result()[0]
+    z_exp_diff = result_diff.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect_sum = (1 - z_exp) / 2
+    pi_expect_diff = (1 - z_exp_diff) / 2
+
+    relative_sign = 'same' if pi_expect_sum >= pi_expect_diff else 'different'
+    
+    return relative_sign
+
+def Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez'):
+    if steps < 31:
+        offset = 1
+    else :
+        offset = 0.15
+    deltastate = np.zeros(4*nx*nx)
+    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1
+    deltastate[nx*yref+xref] = 1
+    deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset
+    norm1 = np.linalg.norm(deltastate)
+    initial_state = deltastate/norm1
+
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm2 = np.linalg.norm(fp)
+    norm = norm1 * norm2
+
+    qc = circ_for_magnitude(field_ref, xref, yref, nx, na, R, dt, initial_state, steps)
+
+    Ezref = get_absolute_field_value(qc, nq, na, offset, norm)
+
+    return Ezref
+
+
+def transpile_circ(circ, basis_gates=None):
+    """
+    Transpile the circuit to the specified basis gates.
+    """
+    if basis_gates is None:
+        basis_gates = ['z', 'y', 'x', 'sdg', 's', 'h', 'rz', 'ry', 'rx', 'ecr', 'cz', 'cx']
+    
+    transpiled_circ = transpile(circ, basis_gates=basis_gates)
+    return transpiled_circ
+
+def compute_fidelity(circ1, circ2):
+    
+    circ_1 = tensornetwork_from_circuit(transpile_circ(circ1), simulator_settings)
+    circ_2 = tensornetwork_from_circuit(transpile_circ(circ2), simulator_settings)
+    fidelity = abs(compute_overlap(circ_1, circ_2))**2
+    
+    return fidelity
+
+# def create_impulse_state(grid_dims, impulse_pos):
+#     """
+#     Creates an initial state vector with a single delta impulse at a specified grid position.
+
+#     The 2D grid is flattened into a 1D vector in row-major order, and this
+#     vector is then padded to match the full simulation state space size (4x).
+
+#     Args:
+#         grid_dims (tuple): A tuple (width, height) defining the simulation grid dimensions.
+#                            For your original code, this would be (nx, nx).
+#         impulse_pos (tuple): A tuple (x, y) for the position of the impulse.
+#                              Coordinates are 0-indexed.
+
+#     Returns:
+#         numpy.ndarray: The full, padded initial state vector with a single 1.
+    
+#     Raises:
+#         ValueError: If the impulse position is outside the grid dimensions.
+#     """
+#     grid_width, grid_height = grid_dims
+#     impulse_x, impulse_y = impulse_pos
+
+#     # --- Input Validation ---
+#     # Ensure the requested impulse position is actually on the grid.
+#     if not (0 <= impulse_x < grid_width and 0 <= impulse_y < grid_height):
+#         raise ValueError(f"Impulse position ({impulse_x}, {impulse_y}) is outside the "
+#                          f"grid dimensions ({grid_width}x{grid_height}).")
+
+#     # --- 1. Calculate the 1D Array Index ---
+#     # Convert the (x, y) coordinate to a single index in a flattened 1D array.
+#     # The formula for row-major order is: index = y_coord * width + x_coord
+#     flat_index = impulse_y * grid_width + impulse_x
+
+#     # --- 2. Create the Full, Padded State Vector ---
+#     grid_size = grid_width * grid_height
+#     total_size = 4 * grid_size  # The simulation space is 4x the grid size.
+#     initial_state = np.zeros(total_size)
+
+#     # --- 3. Set the Delta Impulse ---
+#     initial_state[flat_index] = 1
+
+#     return initial_state

utils/base_ionq.py

@@ -0,0 +1,458 @@
+import numpy as np
+import scipy.sparse as sp
+import math
+import random
+import matplotlib.pyplot as plt
+from scipy.special import jn
+from scipy.sparse import identity, csr_matrix, kron, diags, eye
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit.library import MCXGate, MCPhaseGate, RXGate, CRXGate, QFTGate, StatePreparation, PauliEvolutionGate, RZGate
+from qiskit.quantum_info import SparsePauliOp, Statevector, Operator, Pauli
+from scipy.linalg import expm
+# from tools import *
+from qiskit.qasm3 import dumps  # QASM 3 exporter
+from qiskit.qasm3 import loads
+from qiskit.circuit.library import QFT
+from qiskit.primitives import StatevectorEstimator
+from qiskit import transpile
+from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit, apply_circuit_to_state, compute_overlap
+from qiskit_aer import AerSimulator
+from qiskit_ionq import IonQProvider
+import os
+my_api_key = os.getenv("IONQ_API_KEY")
+from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator
+
+
+
+
+# provider = IonQProvider()
+
+api_token = "SgUkiDq1r2bVEadyiUfvtuxQ03Qci6UW"
+provider = IonQProvider(api_token)
+ionq_backend = provider.get_backend("simulator")
+
+
+
+
+simulator_settings = AerSimulator(
+    method="matrix_product_state",
+    matrix_product_state_max_bond_dimension=100,
+)
+
+def Wj(j, theta, lam, name='Wj', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}$ '
+    qc=QuantumCircuit(j, name=name)
+
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+    if lam != 0:
+        qc.p(lam, j-1)
+    qc.h(j-1)
+    if xgate:
+        qc.x(range(j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        qc.mcrz(theta, range(j-1), j-1)
+    else:
+        qc.rz(theta, j-1)
+    
+    if xgate:
+        qc.x(range(j-1))
+    qc.h(j-1)
+    if lam != 0:
+        qc.p(-lam, j-1)
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+
+    return qc
+
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}_block$ '
+    qc=QuantumCircuit(n + j, name=name)
+
+    if j > 1:
+        qc.cx(n + j-1, range(n, n+j-1))
+    if lam != 0:
+        qc.p(lam, n + j -1)
+    qc.h(n + j -1)
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        mcrz = RZGate(theta).control(len(ctrl_state) + j-1, ctrl_state = "1"*(j-1)+ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    else:
+        mcrz = RZGate(theta).control(len(ctrl_state), ctrl_state = ctrl_state)
+        qc.append(mcrz, range(0, n+j))
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+            
+    qc.h(n+ j-1)
+    if lam != 0:
+        qc.p(-lam, n + j-1)
+    if j > 1:
+        qc.cx(n + j-1, range(n, n +j-1))
+
+    return qc.to_gate(label=name)
+
+def V1(nx, dt, name = "V1"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, n, "0"*n, -dt , 0, xgate=True)
+    qc.append(W1, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W2 = Wj_block(3, n-1, "1"*(n-1), dt , 0, xgate=[0,1])
+    qc.append(W2, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(1, n+1, "0"*(n+1), dt , 0, xgate=False)
+    qc.append(W3, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "0"+"1"*(n-1), -dt , 0, xgate=False)
+    qc.append(W4, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    return qc
+
+def V2(nx, dt, name = "V2"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, 0, "", -2*dt , -np.pi/2, xgate=True)
+    qc.append(W1, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W2 = Wj_block(2+j, 0, "", 2*dt , -np.pi/2, xgate=[1]*(j-1)+[0,1])
+        qc.append(W2, list(derivatives[0:j])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(2, n, "0"*n, -dt , -np.pi/2, xgate=True)
+    qc.append(W3, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "1"*n, 2*dt , -np.pi/2, xgate=True)
+    qc.append(W4, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W5 = Wj_block(3, n-1, "1"*(n-1), dt , -np.pi/2, xgate=[0,1])
+    qc.append(W5, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W6 = Wj_block(1, 1, "0", 2*dt , -np.pi/2, xgate=False)
+    qc.append(W6, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W7 = Wj_block(1+j, 1, "0", -2*dt , -np.pi/2, xgate=[1]*(j-1))
+        qc.append(W7, [blocks[0]]+list(derivatives[n:n+j])+[blocks[1]])
+
+        # qc.barrier()
+
+    W8 = Wj_block(1, n+1, "0"*(n+1), dt , -np.pi/2, xgate=False)
+    qc.append(W8, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W9 = Wj_block(1, n+1, "0"+"1"*(n), -2*dt , -np.pi/2, xgate=False)
+    qc.append(W9, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W10 = Wj_block(2, n, "0"+"1"*(n-1), -dt , -np.pi/2, xgate=False)
+    qc.append(W10, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    # qc.barrier()
+    
+    return qc
+
+def schro(nx, na, R, dt, initial_state, steps):
+
+    nq = int(np.ceil(np.log2(nx)))
+
+    # warped phase transformation
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm1 = np.linalg.norm(fp[2**(na-1):]) # norm of p>=0
+
+    # construct quantum circuit
+    system = QuantumRegister(2*nq+2, name='system')
+    ancilla = QuantumRegister(na, name='ancilla')
+    qc = QuantumCircuit(system, ancilla)
+
+    # initialization
+    prep = StatePreparation(initial_state)
+    anc_prep = StatePreparation(fp / np.linalg.norm(fp))
+
+    qc.append(prep, system)
+    # qc.append(anc_prep, ancilla)
+    qc.initialize(fp / np.linalg.norm(fp), ancilla)
+
+
+    # QFT
+    qc.append(QFTGate(na), ancilla)
+    qc.x(ancilla[-1])
+
+    A1 = V1(nx, dt, name = "V1").to_gate()
+    A2 = V2(nx, dt, name = "V2")
+
+    
+    # Hamiltonian simulation for Nt steps
+    for i in range(steps):
+        # circuit for one step
+        for j in range(na):
+            # repeat controlled H1 for 2**j times
+            qc.append(A1.control().repeat(2**j), [ancilla[j]] + system[:])
+
+        # qc.append(A1.inverse().control(ctrl_state = "0").repeat(2**(na-1)), [ancilla[na-1]] + system[:])
+        qc.append(A1.inverse().repeat(2**(na-1)), system[:])
+        qc.append(A2, system[:])
+
+    # rearrange eta
+    qc.x(ancilla[-1])
+    qc.append(QFTGate(na).inverse(), ancilla)
+
+    return qc
+
+
+
+def circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps):
+
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    index_bin = format(index, f'0{qc.num_qubits-2}b')
+    ctrl_state = '1' + index_bin
+    ctrl_qubits = qc.qubits[:-1]
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state)
+
+    return qc
+
+def circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez'):    
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    if field_ref == 'Ez':
+        index_ref = nx * yref + xref
+    elif field_ref == 'Hx':
+        index_ref = 2*nx*nx + nx * yref + xref
+    else:
+        index_ref = 3*nx*nx + nx * yref + xref
+
+    index_bin = [(index >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_ref_bin = [(index_ref >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_bin.append(1)
+    index_ref_bin.append(1)
+
+    #Convert reference bitstring to 00000 
+    for i, bit in enumerate(index_ref_bin):
+        if bit == 1:
+            qc.x(i)
+
+    d_bits = [b ^ r for b, r in zip(index_ref_bin, index_bin)]
+    control = d_bits.index(1)
+
+    #Convert the other bitstring to 0001000
+    for target, bit in enumerate(d_bits):
+        if bit == 1 and target != control:
+            qc.cx(control, target)
+    qc.h(control)
+
+    ctrl_state_sum = '0'*(qc.num_qubits-1)
+    ctrl_state_diff = '0'*(qc.num_qubits-1-control-1)+'1'+'0'*(control)
+    
+    qcdiff = qc.copy()
+
+    ctrl_qubits = qc.qubits[:-1]
+
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_sum)
+    qcdiff.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_diff)
+
+    return qc, qcdiff
+
+def get_absolute_field_value(qc, nq, na, offset, norm):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator (no parameters needed) ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect = (1 - z_exp) / 2
+
+    Absolute_value = norm*np.sqrt(pi_expect)-offset
+    
+    return Absolute_value
+
+def get_relative_sign(qc, qcdiff, nq, na):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+
+    pub_diff = (qcdiff, observable)
+    job_diff = estimator.run([pub_diff])
+    result_diff = job_diff.result()[0]
+    z_exp_diff = result_diff.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect_sum = (1 - z_exp) / 2
+    pi_expect_diff = (1 - z_exp_diff) / 2
+
+    relative_sign = 'same' if pi_expect_sum >= pi_expect_diff else 'different'
+    
+    return relative_sign
+
+def Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez'):
+    if steps < 31:
+        offset = 1
+    else :
+        offset = 0.15
+    deltastate = np.zeros(4*nx*nx)
+    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1
+    deltastate[nx*yref+xref] = 1
+    deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset
+    norm1 = np.linalg.norm(deltastate)
+    initial_state = deltastate/norm1
+
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm2 = np.linalg.norm(fp)
+    norm = norm1 * norm2
+
+    qc = circ_for_magnitude(field_ref, xref, yref, nx, na, R, dt, initial_state, steps)
+
+    Ezref = get_absolute_field_value(qc, nq, na, offset, norm)
+
+    return Ezref
+
+
+def transpile_circ(circ, basis_gates=None):
+    """
+    Transpile the circuit to the specified basis gates.
+    """
+    if basis_gates is None:
+        basis_gates = ['z', 'y', 'x', 'sdg', 's', 'h', 'rz', 'ry', 'rx', 'ecr', 'cz', 'cx']
+    
+    transpiled_circ = transpile(circ, basis_gates=basis_gates)
+    return transpiled_circ
+
+def compute_fidelity(circ1, circ2):
+    
+    circ_1 = tensornetwork_from_circuit(transpile_circ(circ1), simulator_settings)
+    circ_2 = tensornetwork_from_circuit(transpile_circ(circ2), simulator_settings)
+    fidelity = abs(compute_overlap(circ_1, circ_2))**2
+    
+    return fidelity
+
+# def create_impulse_state(grid_dims, impulse_pos):
+#     """
+#     Creates an initial state vector with a single delta impulse at a specified grid position.
+
+#     The 2D grid is flattened into a 1D vector in row-major order, and this
+#     vector is then padded to match the full simulation state space size (4x).
+
+#     Args:
+#         grid_dims (tuple): A tuple (width, height) defining the simulation grid dimensions.
+#                            For your original code, this would be (nx, nx).
+#         impulse_pos (tuple): A tuple (x, y) for the position of the impulse.
+#                              Coordinates are 0-indexed.
+
+#     Returns:
+#         numpy.ndarray: The full, padded initial state vector with a single 1.
+    
+#     Raises:
+#         ValueError: If the impulse position is outside the grid dimensions.
+#     """
+#     grid_width, grid_height = grid_dims
+#     impulse_x, impulse_y = impulse_pos
+
+#     # --- Input Validation ---
+#     # Ensure the requested impulse position is actually on the grid.
+#     if not (0 <= impulse_x < grid_width and 0 <= impulse_y < grid_height):
+#         raise ValueError(f"Impulse position ({impulse_x}, {impulse_y}) is outside the "
+#                          f"grid dimensions ({grid_width}x{grid_height}).")
+
+#     # --- 1. Calculate the 1D Array Index ---
+#     # Convert the (x, y) coordinate to a single index in a flattened 1D array.
+#     # The formula for row-major order is: index = y_coord * width + x_coord
+#     flat_index = impulse_y * grid_width + impulse_x
+
+#     # --- 2. Create the Full, Padded State Vector ---
+#     grid_size = grid_width * grid_height
+#     total_size = 4 * grid_size  # The simulation space is 4x the grid size.
+#     initial_state = np.zeros(total_size)
+
+#     # --- 3. Set the Delta Impulse ---
+#     initial_state[flat_index] = 1
+
+#     return initial_state

utils/delta_impulse_generator.py

@@ -0,0 +1,493 @@
+import numpy as np
+import math
+from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import StatePreparation, QFTGate, RZGate
+from qiskit.quantum_info import Statevector
+import pyvista as pv
+
+def create_impulse_state(grid_dims, impulse_pos):
+    """
+    Creates an initial state vector with a single delta impulse at a specified grid position.
+
+    The 2D grid is flattened into a 1D vector in row-major order, and this
+    vector is then padded to match the full simulation state space size (4x).
+
+    Args:
+        grid_dims (tuple): A tuple (width, height) defining the simulation grid dimensions.
+                           For your original code, this would be (nx, nx).
+        impulse_pos (tuple): A tuple (x, y) for the position of the impulse.
+                             Coordinates are 0-indexed.
+
+    Returns:
+        numpy.ndarray: The full, padded initial state vector with a single 1.
+    
+    Raises:
+        ValueError: If the impulse position is outside the grid dimensions.
+    """
+    grid_width, grid_height = grid_dims
+    impulse_x, impulse_y = impulse_pos
+
+    # --- Input Validation ---
+    # Ensure the requested impulse position is actually on the grid.
+    if not (0 <= impulse_x < grid_width and 0 <= impulse_y < grid_height):
+        raise ValueError(f"Impulse position ({impulse_x}, {impulse_y}) is outside the "
+                         f"grid dimensions ({grid_width}x{grid_height}).")
+
+    # --- 1. Calculate the 1D Array Index ---
+    # Convert the (x, y) coordinate to a single index in a flattened 1D array.
+    # The formula for row-major order is: index = y_coord * width + x_coord
+    flat_index = impulse_y * grid_width + impulse_x
+
+    # --- 2. Create the Full, Padded State Vector ---
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size  # The simulation space is 4x the grid size.
+    initial_state = np.zeros(total_size)
+
+    # --- 3. Set the Delta Impulse ---
+    initial_state[flat_index] = 1
+
+    return initial_state
+
+def create_gaussian_state(grid_dims, mu, sigma):
+    """
+    Creates an initial state vector with a 2D Gaussian distribution.
+
+    The state is normalized and padded to match the full simulation state space size (4x).
+
+    Args:
+        grid_dims (tuple): A tuple (width, height) defining the grid dimensions.
+        mu (tuple): A tuple (mu_x, mu_y) for the center (mean) of the Gaussian.
+        sigma (tuple): A tuple (sigma_x, sigma_y) for the standard deviation (spread).
+
+    Returns:
+        numpy.ndarray: The full, padded initial state vector for the Gaussian state.
+
+    Raises:
+        ValueError: If sigma values are not positive.
+    """
+    grid_width, grid_height = grid_dims
+    mu_x, mu_y = mu
+    sigma_x, sigma_y = sigma
+
+    if sigma_x <= 0 or sigma_y <= 0:
+        raise ValueError("Sigma values (spread) must be positive.")
+
+    # --- 1. Create a Coordinate Grid ---
+    x = np.arange(0, grid_width)
+    y = np.arange(0, grid_height)
+    X, Y = np.meshgrid(x, y)
+
+    # --- 2. Calculate the 2D Gaussian Function ---
+    gaussian_2d = np.exp(-((X - mu_x)**2 / (2 * sigma_x**2)) - 
+                         ((Y - mu_y)**2 / (2 * sigma_y**2)))
+
+    # --- 3. Normalize the State Vector ---
+    # For a valid quantum state, the L2 norm (sum of squares of amplitudes) must be 1.
+    norm = np.linalg.norm(gaussian_2d)
+    if norm > 0:
+        gaussian_2d = gaussian_2d / norm
+    
+    # --- 4. Flatten and Pad the Vector ---
+    gaussian_flat = gaussian_2d.flatten()
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    initial_state = np.pad(gaussian_flat, (0, total_size - grid_size), mode='constant')
+
+    return initial_state
+
+
+
+
+
+# --- New: Continuous-position helpers for excitation before meshing ---
+def _normalize_to_unit(vec: np.ndarray) -> np.ndarray:
+    n = np.linalg.norm(vec)
+    return vec / n if n > 0 else vec
+
+
+
+
+def create_impulse_state_from_pos(grid_dims, pos01):
+    """
+    Create a delta-like initial state from continuous position pos01=(x,y) in [0,1].
+
+    Why grid_dims?
+    - Simulation runs on a discrete nx×ny lattice; the continuous position must be
+      discretized onto that grid to produce the state vector fed into the solver.
+    - grid_dims provides (nx, ny) so we can map (x,y)∈[0,1]→grid coordinates via
+      gx = x*(nx-1), gy = y*(ny-1), then distribute amplitude bilinearly to the 4
+      neighboring nodes. This is required only for the simulation state, not the preview.
+
+    The preview uses create_impulse_preview_state(), which renders a smooth bump on a
+    fixed unit-square grid independent of nx for visualization.
+    """
+    grid_width, grid_height = grid_dims
+    px, py = pos01
+    px = float(max(0.0, min(1.0, px)))
+    py = float(max(0.0, min(1.0, py)))
+
+    gx = px * (grid_width - 1)
+    gy = py * (grid_height - 1)
+    i0, j0 = int(np.floor(gx)), int(np.floor(gy))
+    i1, j1 = min(i0 + 1, grid_width - 1), min(j0 + 1, grid_height - 1)
+    dx, dy = gx - i0, gy - j0
+
+    w00 = (1 - dx) * (1 - dy)
+    w10 = dx * (1 - dy)
+    w01 = (1 - dx) * dy
+    w11 = dx * dy
+
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    field = np.zeros(grid_size)
+    field[j0 * grid_width + i0] += w00
+    field[j0 * grid_width + i1] += w10
+    field[j1 * grid_width + i0] += w01
+    field[j1 * grid_width + i1] += w11
+    field = _normalize_to_unit(field)
+
+    initial_state = np.zeros(total_size)
+    initial_state[:grid_size] = field
+    return initial_state
+
+
+def create_gaussian_state_from_pos(grid_dims, mu01, sigma01):
+    """
+    Create a Gaussian initial state with center mu01=(x,y) and spreads sigma01=(sx,sy)
+    in [0,1] of the domain, then discretize to the solver grid given by grid_dims.
+
+    Why grid_dims?
+    - The quantum solver expects a vector aligned to the chosen nx×ny simulation grid.
+      We convert normalized μ and σ (fractions of the domain) into grid units using
+      (nx-1) and (ny-1). This step is necessary for the simulation, not for the preview.
+
+    For preview-only rendering, use create_impulse_preview_state() to keep the visuals
+    continuous and independent of nx.
+    """
+    grid_width, grid_height = grid_dims
+    mu_x01, mu_y01 = mu01
+    sig_x01, sig_y01 = sigma01
+
+    mu_x01 = float(max(0.0, min(1.0, mu_x01)))
+    mu_y01 = float(max(0.0, min(1.0, mu_y01)))
+    sig_x01 = float(sig_x01)
+    sig_y01 = float(sig_y01)
+    if sig_x01 <= 0 or sig_y01 <= 0:
+        raise ValueError("Sigma values (spread) must be positive.")
+
+    mu_x = mu_x01 * (grid_width - 1)
+    mu_y = mu_y01 * (grid_height - 1)
+    sigma_x = sig_x01 * (grid_width - 1)
+    sigma_y = sig_y01 * (grid_height - 1)
+
+    x = np.arange(0, grid_width)
+    y = np.arange(0, grid_height)
+    X, Y = np.meshgrid(x, y)
+    gaussian_2d = np.exp(-((X - mu_x) ** 2) / (2 * sigma_x ** 2) - ((Y - mu_y) ** 2) / (2 * sigma_y ** 2))
+
+    field = _normalize_to_unit(gaussian_2d.ravel())
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    initial_state = np.zeros(total_size)
+    initial_state[:grid_size] = field
+    return initial_state
+
+# --- Simulation Code (from previous context) ---
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):
+    qc = QuantumCircuit(n + j, name=name)
+    if j > 1: qc.cx(n + j - 1, range(n, n + j - 1))
+    if lam != 0: qc.p(lam, n + j - 1)
+    qc.h(n + j - 1)
+    if xgate and j > 1:
+        if isinstance(xgate, (list, tuple)):
+            for idx, flag in enumerate(xgate):
+                if flag: qc.x(n + idx)
+        elif xgate is True: qc.x(range(n, n + j - 1))
+    if j > 1:
+        mcrz = RZGate(theta).control(len(ctrl_state) + j - 1, ctrl_state="1" * (j - 1) + ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    else:
+        mcrz = RZGate(theta).control(len(ctrl_state), ctrl_state=ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    if xgate and j > 1:
+        if isinstance(xgate, (list, tuple)):
+            for idx, flag in enumerate(xgate):
+                if flag: qc.x(n + idx)
+        elif xgate is True: qc.x(range(n, n + j - 1))
+    qc.h(n + j - 1)
+    if lam != 0: qc.p(-lam, n + j - 1)
+    if j > 1: qc.cx(n + j - 1, range(n, n + j - 1))
+    return qc.to_gate(label=name)
+
+def V1(nx, dt):
+    n = int(np.ceil(np.log2(nx)))
+    derivatives, blocks = QuantumRegister(2 * n), QuantumRegister(2)
+    qc = QuantumCircuit(derivatives, blocks)
+    qc.append(Wj_block(2, n, "0" * n, -dt, 0, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(3, n - 1, "1" * (n - 1), dt, 0, xgate=[0, 1]), list(derivatives[1:n]) + [derivatives[0]] + list(blocks[:]))
+    qc.append(Wj_block(1, n + 1, "0" * (n + 1), dt, 0, xgate=True), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" + "1" * (n - 1), -dt, 0, xgate=False), list(derivatives[n + 1:2 * n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+    return qc
+
+def V2(nx, dt):
+    n = int(np.ceil(np.log2(nx)))
+    derivatives, blocks = QuantumRegister(2 * n), QuantumRegister(2)
+    qc = QuantumCircuit(derivatives, blocks)
+    qc.append(Wj_block(2, 0, "", -2 * dt, -np.pi / 2, xgate=True), blocks[:])
+    for j in range(1, n + 1): qc.append(Wj_block(2 + j, 0, "", 2 * dt, -np.pi / 2, xgate=[1] * (j - 1) + [0, 1]), list(derivatives[0:j]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" * n, -dt, -np.pi / 2, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "1" * n, 2 * dt, -np.pi / 2, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(3, n - 1, "1" * (n - 1), dt, -np.pi / 2, xgate=[0, 1]), list(derivatives[1:n]) + [derivatives[0]] + list(blocks[:]))
+    qc.append(Wj_block(1, 1, "0", 2 * dt, -np.pi / 2, xgate=False), blocks[:])
+    for j in range(1, n + 1): qc.append(Wj_block(1 + j, 1, "0", -2 * dt, -np.pi / 2, xgate=[1] * (j - 1)), [blocks[0]] + list(derivatives[n:n + j]) + [blocks[1]])
+    qc.append(Wj_block(1, n + 1, "0" * (n + 1), dt, -np.pi / 2, xgate=False), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(1, n + 1, "0" + "1" * n, -2 * dt, -np.pi / 2, xgate=False), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" + "1" * (n - 1), -dt, -np.pi / 2, xgate=False), list(derivatives[n + 1:2 * n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+    return qc
+
+def run_sim(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, progress_callback=None, print_callback=None):
+    """
+    Runs the quantum simulation for electromagnetic scattering with fixed dt=0.1.
+    Captures frames only at user-defined snapshot times: [0, Δt, 2Δt, ..., ≤ T_eff],
+    always including t=0 and the final solver-aligned T (T_eff = floor(T/dt)*dt).
+
+    Returns:
+        frames (np.ndarray), snapshot_times (np.ndarray)
+    """
+    def _log(msg):
+        if print_callback:
+            print_callback(msg)
+        else:
+            print(msg)
+
+    dt = 0.1
+    # Validate total time and compute solver-aligned end time
+    try:
+        T_val = float(T)
+    except Exception:
+        return np.array([]), np.array([])
+    if T_val <= 0:
+        return np.array([]), np.array([])
+
+    steps = int(np.floor(T_val / dt))
+    if steps <= 0:
+        return np.array([]), np.array([])
+    T_eff = steps * dt
+
+    # Determine snapshot Δt on solver grid
+    tol = 1e-12
+    if snapshot_dt is None:
+        snapshot_dt_val = dt
+    else:
+        try:
+            snapshot_dt_val = float(snapshot_dt)
+        except Exception:
+            snapshot_dt_val = dt
+    if snapshot_dt_val < dt - tol:
+        snapshot_dt_val = dt
+    k = max(1, int(round(snapshot_dt_val / dt)))
+    snapshot_dt_eff = k * dt
+
+    # Build requested snapshot times on solver grid
+    target_times = [0.0]
+    t = 0.0
+    while t + snapshot_dt_eff <= T_eff + tol:
+        t = round(t + snapshot_dt_eff, 12)
+        if t <= T_eff + tol:
+            target_times.append(min(t, T_eff))
+    if abs(target_times[-1] - T_eff) > tol:
+        target_times.append(T_eff)
+
+    # Setup circuit
+    nq = int(np.ceil(np.log2(nx)))
+    dp = 2 * R * np.pi / 2 ** na
+    p = np.arange(-R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    system, ancilla = QuantumRegister(2 * nq + 2), QuantumRegister(na)
+    qc = QuantumCircuit(system, ancilla)
+    qc.append(StatePreparation(initial_state), system)
+    qc.append(StatePreparation(fp / np.linalg.norm(fp)), ancilla)
+    expA1 = V1(nx, dt).to_gate()
+    expA2 = V2(nx, dt)
+
+    frames = []
+    # Capture initial frame at t=0
+    sv0 = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))
+    frames.append(sv0[2 ** (na - 1)])
+    next_idx = 1  # next target_times index to capture
+
+    _log(f"Starting simulation: T={T_eff:.2f}s, steps={steps}, snapshot_dt={snapshot_dt_eff:.2f}s")
+
+    for i in range(steps):
+        if stop_check and stop_check():
+            _log(f"Simulation interrupted at step {i}/{steps}")
+            break
+        # One solver step
+        qc.append(QFTGate(na), ancilla)
+        qc.x(ancilla[-1])
+        for j in range(na - 1):
+            qc.append(expA1.control().repeat(2 ** j), [ancilla[j]] + system[:])
+        qc.append(expA1.inverse().control(ctrl_state="0").repeat(2 ** (na - 1)), [ancilla[na - 1]] + system[:])
+        qc.append(expA2, system[:])
+        qc.x(ancilla[-1])
+        qc.append(QFTGate(na).inverse(), ancilla)
+
+        current_time = (i + 1) * dt
+        if next_idx < len(target_times) and abs(current_time - target_times[next_idx]) <= tol:
+            u = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))
+            frames.append(u[2 ** (na - 1)])
+            next_idx += 1
+
+        if progress_callback:
+            try:
+                progress = ((i + 1) / steps) * 100
+                progress_callback(progress)
+            except Exception:
+                pass
+
+    if progress_callback:
+        try:
+            progress_callback(100.0)
+        except Exception:
+            pass
+    
+    _log("Simulation completed.")
+
+    # Ensure snapshot_times align with number of captured frames (covers early stop)
+    frames_arr = np.asarray(frames)
+    times_arr = np.asarray(target_times[: len(frames_arr)])
+    return frames_arr, times_arr
+
+def create_impulse_preview_state(preview_n: int, pos01, sigma01: float = 0.02):
+    """
+    Smooth delta-like preview on a unit square using a narrow Gaussian (sigma in [0,1]).
+    Preview-only helper, independent of simulation grid size (nx). Use this for the
+    Excitation preview; use the *_from_pos() variants for the actual simulation.
+    """
+    try:
+        sx = float(sigma01) if sigma01 and sigma01 > 0 else 0.02
+    except Exception:
+        sx = 0.02
+    return create_gaussian_state_from_pos((int(preview_n), int(preview_n)), (float(pos01[0]), float(pos01[1])), (sx, sx))
+
+
+
+
+
+
+##### Statevector Estimator Simulation Code Below #####
+
+from .base_functions import * 
+
+def create_time_frames(total_time, snapshot_interval):
+    dt = 0.1
+    tol = 1e-9
+    try:
+        T_val = float(total_time)
+    except (ValueError, TypeError):
+        return []
+    if T_val <= 0:
+        return []
+    steps = int(np.floor(T_val / dt))
+    if steps <= 0:
+        return [0.0]
+    T_eff = steps * dt
+    try:
+        snapshot_dt_val = float(snapshot_interval)
+    except (ValueError, TypeError):
+        snapshot_dt_val = dt
+    if snapshot_dt_val < dt:
+        snapshot_dt_val = dt
+    k = max(1, int(round(snapshot_dt_val / dt)))
+    snapshot_dt_eff = k * dt
+    times = np.arange(0, T_eff + tol, snapshot_dt_eff)
+    if abs(times[-1] - T_eff) > tol:
+        times = np.append(times, T_eff)
+    times = np.round(times, 12)
+    unique_times = []
+    for t in times:
+        if not unique_times or abs(t - unique_times[-1]) > tol:
+            unique_times.append(float(t))
+    return unique_times
+
+
+
+def run_sve(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos, progress_callback=None, print_callback=None):
+    """Statevector Estimator for time-series field values.
+
+    Supports both single-point and multi-point modes.
+
+    - Single-point (backward compatible): x, y are integers; returns list[float].
+    - Multi-point: x is a list/tuple of (ix, iy) integer pairs and y is None; returns dict[(ix,iy) -> list[float]].
+    """
+    def _log(msg):
+        if print_callback:
+            print_callback(msg)
+        else:
+            print(msg)
+
+    na = 1
+    dt = 0.1
+    R = 4
+    nq = int(np.ceil(np.log2(nx)))
+
+    # Normalize monitor points input
+    if isinstance(x, (list, tuple)) and y is None:
+        points = [tuple(map(int, pt)) for pt in x]
+        multi = True
+    else:
+        points = [(int(x), int(y))]
+        multi = False
+
+    xref, yref = impulse_pos
+
+    offset = 0
+    grid_dims = (nx, nx)
+    initial_state = create_impulse_state(grid_dims, impulse_pos)
+    
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm = np.linalg.norm(fp)
+
+    time_frames = create_time_frames(T, snapshot_time)
+    total_frames = len(time_frames)
+
+    _log(f"Starting QPU simulation: T={T}s, frames={total_frames}, points={len(points)}")
+
+    # Prepare outputs
+    if multi:
+        series_by_point = { (px, py): [] for (px, py) in points }
+    else:
+        series_single = []
+
+    for idx, time in enumerate(time_frames):
+        steps = int(math.ceil(time / dt))
+        # Reference Ez field at impulse location for sign
+        Eref = Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref='Ez')
+
+        for (px, py) in points:
+            circ_magnitude = circ_for_magnitude(field, px, py, nx, na, R, dt, initial_state, steps)
+            magnitude = get_absolute_field_value(circ_magnitude, nq, na, offset, norm)
+
+            if field == 'Ez' and px == xref and py == yref:
+                Field_value = -magnitude if Eref < 0 else magnitude
+            else:
+                circsum, circdiff = circuits_for_sign(field, px, py, nx, na, dt, R, initial_state, steps, xref, yref, field_ref='Ez')
+                sign = get_relative_sign(circsum, circdiff, nq, na)
+                if (sign == 'same' and Eref > 0) or (sign == 'different' and Eref < 0):
+                    Field_value = magnitude
+                else:
+                    Field_value = -magnitude
+
+            if multi:
+                series_by_point[(px, py)].append(Field_value)
+            else:
+                series_single.append(Field_value)
+        
+        if progress_callback:
+            progress_callback((idx + 1) / total_frames * 100)
+    
+        _log("Statevector Estimator simulation completed.")
+
+    return series_by_point if multi else series_single

wq

@@ -0,0 +1,6 @@
+Merge branch 'main' of https://huggingface.co/spaces/ansysresearch/quantum
+# Please enter a commit message to explain why this merge is necessary,
+# especially if it merges an updated upstream into a topic branch.
+#
+# Lines starting with '#' will be ignored, and an empty message aborts
+# the commit.