Quantum DSL
Circuit synthesis, cost-function building, and optimization run locally. Shipped as a Python SDK.
Aware just what to solve.The QASIS DSL builds the circuit.
Qbasis.One builds a development environment for quantum software. Define the problem with a matrix and a function; the DSL synthesizes the circuit, and the platform runs it and returns the results.
from synthesis import synthesize_qsvt, synthesize_state
from client import submit
# Solve Ax = b with the regularized inverse f(x) = x / (x² + δ²)
qsvt, subnorm = synthesize_qsvt(A, f, block_encoding="sparse_lcu")
prep = synthesize_state(b)
circuit = ... # join prep and qsvt, add measurements (omitted)
handle = submit(circuit, device="qasis.gpu-sim", shots=32768)
result = handle.result()|ψ⟩Output
- Qubits
- 4 (anc) + 3 (sys)
- Run
- qasis.gpu-sim, 32,768 shots
- Circuit fidelity
- Σ√(p·q) = 0.999917
PASS
Platform
Author locally. Execute remotely.
The Qbasis platform has three parts: the DSL, the execution platform, and the execution backends. The only thing that leaves your machine is a submission.
Execution platform
Manages submissions, queues, sessions, and stored results. Job status and convergence curves are viewable on the web.
Execution backends
Runs on our own GPU simulator. Quantum hardware (QPU) access is being prepared behind the same submission format.
Quantum DSL
Write only the code that defines the algorithm
Block encoding, polynomial approximation, phase-factor computation, and reading measurement results are handled by the DSL.
Qbasis DSL
synthesize_state(b)
synthesize_qsvt(A, f, block_encoding="sparse_lcu")You decide: the matrix A, the function f, and the block-encoding kind
Hand-built with a general-purpose quantum SDK
- Block-encoding construction (dilation formula, ancilla placement)
- Chebyshev truncation degree and parity
- |P| ≤ 1 normalization
- Phase-factor convention conversion
- Signs in the real-part gadget
- U and U† alternation order
- Little-endian index handling
with open_session("qasis.gpu-sim", seed=1234) as session:
for i in range(12):
# one objective + two parameter-shift gradients = one job
handle = submit(
ansatz, device="qasis.gpu-sim",
observable=[("Z", 1.0)],
parameter_bindings=[{"theta": theta},
{"theta": theta + pi / 2},
{"theta": theta - pi / 2}],
roles=["objective", "gradient", "gradient"],
session=session,
)
r = handle.result()
grad = (expval_of(r, binding_idx=1)
- expval_of(r, binding_idx=2)) / 2
theta -= 0.5 * grad
curve = session.curve() # same data as the web session pageConvergence curve
Measured
We publish what we measured
Circuit fidelity
0.999917
Agreement Σ√(p·q) between the GPU simulator's 32,768-shot distribution and the numerical target f(A)b. Identical distributions score 1.
We do not claim quantum advantage. We build the toolchain so the code is already there when the hardware is ready.
Qbasis.One principles
DSL circuit growth per qubit
+820gates
Total gates at 3, 4, and 5 grid qubits
6,182 → 6,986 → 7,822
Whole-matrix loading growth per qubit
×4.7CX
CX count of one block-encoding unitary for the same problem
81 → 393 → 1,783
* Measured in-house in August 2026 on one step of an implicit Black–Scholes FDM (8 grid points) solved with a QSVT regularized inverse. The comparison is the same problem assembled by hand from a general-purpose quantum SDK's gates.
Principles
A toolchain without the hype
- 01
No quantum-advantage claims
The example circuits are beyond what today's NISQ hardware runs. What we provide is the code and the pipeline from problem definition to execution.
- 02
Verification ships with results
Simulator results are checked against the classical solution. Error and post-selection success rate go into the results table as measured.
- 03
Same submission, same result
Every submission carries a reproducible key. Sending the same submission again returns the earlier result instead of running it twice.