Component reference
Docker users: only a subset of processors is installed by default. Add class names to
docker/processors.txtand rundocker compose up -d --build nifi. Enable additional processors.
This catalogue is generated from ProcessorDetails.description in the processor
source files. Shared helper modules are excluded. Regenerate it with just docs.
For FlowFile attributes and processor construction, see
Creating processors.
The current source tree contains 115 processors.
Algorithms (all-in-one solvers)
| Processor | Description | Source |
|---|---|---|
CirqAmplitudeEstimation |
Canonical QPE-based Quantum Amplitude Estimation implemented from primitives in Cirq (Bernoulli problem, A = Ry(2asin(sqrt(p))), Grover operator Ry(2theta)). Measures the m-qubit phase register and estimates a = sin^2(piy/2^m). Emits ae. attributes and report.type = simulation. | Source |
CirqQAOA |
Trains a p-layer QAOA ansatz using a hand-rolled sympy-parameterised Cirq circuit (exact statevector expectations, scipy.optimize.minimize) and emits the trained, bound circuit as portable OpenQASM 2.0 (same construction as CirqQAOACircuit) with qaoa.optimal_parameters (betas then gammas). It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
CirqVQE |
Hand-rolled VQE for Cirq: simulates a sympy-parameterised ansatz, computes the Hamiltonian expectation from the state vector, and minimises it with scipy.optimize. Strict solver - requires an upstream Hamiltonian (content) and ansatz (ansatz.cirq_json). Emits vqe.* results, optimal-circuit counts as JSON, and report.type=simulation. | Source |
PennylaneAmplitudeEstimation |
Canonical QPE-based Quantum Amplitude Estimation composed from PennyLane's QuantumPhaseEstimation template (Bernoulli problem, A = Ry(2asin(sqrt(p))), Grover operator Ry(2theta)). Reads the analytic probabilities of the estimation wires and estimates a = sin^2(piy/2^m). Emits ae. attributes and report.type = simulation. | Source |
PennylaneQAOA |
Trains a p-layer QAOA ansatz using PennyLane's qml.qaoa layers (exact analytic expectations on default.qubit, scipy.optimize.minimize) and emits the trained, bound circuit as portable OpenQASM 2.0 (same construction as PennylaneQAOACircuit) with qaoa.optimal_parameters (betas then gammas). It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
PyquilQAOA |
Trains a p-layer QAOA ansatz using the native pyQuil program builder (exact local-expectation objectives, scipy.optimize.minimize) and emits the trained, bound circuit as portable OpenQASM 2.0 (same construction as PyquilQAOACircuit) with qaoa.optimal_parameters (betas then gammas). It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
PyquilVQE |
Minimize a Hermitian Hamiltonian using a recipe from PyquilAnsatz (attach mode), native pyQuil exact local expectations and SciPy. Reads neutral Hamiltonian content; emits final counts, vqe.* results and the optimized qasm2 in circuit.qasm2. No Forest server or hardware calls. | Source |
QiskitAmplitudeEstimation |
Quantum Amplitude Estimation (Bernoulli problem) using qiskit-algorithms. Estimates the amplitude p prepared by A = Ry(2asin(sqrt(p))). Method 'canonical' is QPE-based with a grid estimate plus MLE refinement; 'iterative' converges within epsilon without a phase register. Emits ae. attributes and report.type = simulation. | Source |
QiskitGroverSearch |
Runs Grover's search algorithm for a given target bitstring. Builds a phase oracle for the marked state, wraps it with the grover_operator from qiskit.circuit.library, applies it N times, simulates with AerSimulator, and writes the measurement counts as JSON. | Source |
QiskitQAOA |
Trains a p-layer QAOA ansatz using qiskit_algorithms.QAOA (a seeded StatevectorSampler, sampled objective at 1024 shots) and emits the trained, bound circuit as portable OpenQASM 2.0 (same construction as QiskitQAOACircuit) with qaoa.optimal_parameters (betas then gammas). It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
QiskitVQE |
Variational Quantum Eigensolver. Reads a Hamiltonian (from QiskitHamiltonian content or the Hamiltonian property) and an ansatz (from the ansatz.qpy_b64 attribute or built from properties), then minimises the energy with a classical optimizer. Emits vqe.* result attributes, the optimal-circuit measurement counts as JSON content, and report.type = simulation for QuanifiReport. | Source |
QrispAmplitudeEstimation |
Quantum Amplitude Estimation (Bernoulli problem) using Qrisp's native IQAE. Estimates the amplitude p prepared by A = Ry(2asin(sqrt(p))) to within Epsilon Target at confidence Alpha. Emits ae. attributes and report.type = simulation. | Source |
QrispBernsteinVazirani |
Executes the Bernstein-Vazirani algorithm using Qrisp. Finds a hidden bitstring s in a single quantum query. Emits bv.secret_bitstring, bv.found_bitstring, and measurement distributions. | Source |
QrispDeutschJozsa |
Executes the Deutsch-Jozsa algorithm using Qrisp. Determines whether a boolean oracle is constant or balanced in a single evaluation. Emits dj.verdict ('constant' or 'balanced') and measurement distributions. | Source |
QrispGroverSearch |
Runs Grover's search algorithm using the Qrisp framework. Accepts a target bitstring, builds a phase oracle with tag_state(), runs grovers_alg(), and outputs the measurement probability distribution as JSON with sim. and circuit. attributes compatible with QuanifiReport. | Source |
QrispQAOA |
Trains a p-layer QAOA ansatz using Qrisp's QAOAProblem.optimization_routine (exact, Qrisp-rounded probabilities) and emits the trained, bound circuit as portable OpenQASM 2.0 (same construction as QrispQAOACircuit) with qaoa.optimal_parameters (betas then gammas). It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
QrispQIRO |
Quantum-Informed Recursive Optimization (QIRO) for Maximum Independent Set using Qrisp's own QIRO components: train a QAOA, fix or remove vertices from the strongest correlation, shrink the graph and repeat. Emits the final stage's trained circuit as portable OpenQASM 2.0 plus a qiro.* step trace. It does not sample: connect any counts simulator, then QuantumQAOAEvaluator. | Source |
QrispShor |
Runs Shor's factoring algorithm using Qrisp's native shors_alg. Configure Number To Factor (small odd composites, e.g. 15 or 21); emits shor.factor_1 / shor.factor_2. Educational scale: the local statevector simulator limits N to small numbers. | Source |
QrispSwapTest |
Executes the SWAP test using Qrisp to measure quantum state fidelity / overlap | |
Source |
QrispVQE |
Variational Quantum Eigensolver using Qrisp's VQEProblem. Reads a Hamiltonian (content) and an ansatz spec (ansatz.format=qrisp_spec), trains the ansatz with the chosen optimizer, and emits vqe.* results, the optimal-state probability distribution as JSON, and report.type=simulation. Strict solver - requires both upstream stages. | Source |
Circuit builders
| Processor | Description | Source |
|---|---|---|
CirqAnsatz |
Builds a parameterised Cirq variational ansatz (efficient_su2, real_amplitudes, or two_local) with sympy free parameters and attaches it as Cirq JSON in the ansatz.cirq_json attribute. In chain mode the incoming Hamiltonian passes through; standalone it writes the ansatz as circuit content. | Source |
CirqGroverCircuit |
Builds a Grover search circuit using Cirq for a given target bitstring and outputs the unmeasured circuit in either Cirq JSON or OpenQASM 2.0 format. Connect to a Cirq simulator processor to run the simulation. | Source |
CirqGroverOperator |
Reads an oracle circuit from the FlowFile content (produced by CirqPhaseOracle), prepends the uniform superposition H⊗n, and applies the full Grover operator (oracle + diffuser) the requested number of times. Equivalent to Classiq's power(reps, grover_operator(oracle, hadamard_transform)). No measurement is added — connect to CirqSimulator to run the circuit. | Source |
CirqHadamardTransform |
Applies a Hadamard gate to every qubit (H⊗n). In standalone mode a fresh n-qubit circuit is created, producing the uniform superposition H⊗n|0⟩. In compose mode the H layer is appended to an existing Cirq circuit received via the FlowFile content (circuit.format must be cirq_json or qasm2). | Source |
CirqPhaseEstimation |
Quantum Phase Estimation (QPE) using Cirq. Estimates the eigenphase φ of a unitary operator U such that U|ψ⟩ = exp(2πiφ)|ψ⟩. In standalone mode a builtin Z-rotation gate (T, S, or Z) is used as the unitary. In compose mode the incoming Cirq circuit is used as the unitary — its qubits become the target register and are prepared in the |1⟩ eigenstate. Circuit structure: X on target → H on phase register → controlled-U^(2^k) → inverse QFT on phase register. No measurement is added — connect to CirqSimulator; the first circuit.qpe_phase_register_size bits of the top result encode the phase. | Source |
CirqQAOACircuit |
Builds the bound Cirq QAOA circuit (hand-rolled sympy-parameterised cost/mixer ladder) for a diagonal I/Z cost Hamiltonian and explicit Betas/Gammas (beta then gamma) and emits portable OpenQASM 2.0 plus hamiltonian.json, so any counts engine can run it and QuantumQAOAEvaluator can score it. Convention: H on all qubits, then per layer exp(-igammaH) and RX(2*beta). | Source |
CirqQFTCircuit |
Applies the Quantum Fourier Transform (or its inverse QFT†) using Cirq's built-in cirq.qft primitive. In standalone mode a fresh n-qubit QFT circuit is created. In compose mode the QFT is appended to an existing Cirq circuit received via the FlowFile content (cirq_json or qasm2). No measurement is added — connect to CirqSimulator to run the circuit. | Source |
CirqQuantumArithmetic |
Builds a reversible integer adder circuit in Cirq, which ships no high-level adder of its own. Choose the Cuccaro ripple-carry construction or Draper's Fourier-basis adder. Configure Operand A, Operand B, and Bit Width. Outputs qasm2 with no measurement, plus the classical expected result for a deterministic-output oracle. | Source |
CirqStatePreparation |
Prepares a quantum state circuit from a classical description, using Cirq. Supports uniform superposition, GHZ, a specific basis state, or an arbitrary normalized amplitude vector (custom mode). Cross-framework mirror of QiskitStatePreparation. | Source |
PennylaneGroverCircuit |
Builds a PennyLane Grover search circuit for a given target bitstring and outputs the unmeasured circuit as OpenQASM 2.0, so it can be executed by any Quanifi counts engine. PennyLane's export emits an OpenQASM 3 'gphase' statement that OpenQASM 2.0 does not define; it is removed, and circuit.global_phase_dropped records that it was. | Source |
PennylaneQAOACircuit |
Builds the bound PennyLane QAOA circuit (qml.qaoa cost_layer/mixer_layer) for a diagonal I/Z cost Hamiltonian and explicit Betas/Gammas (beta then gamma) and emits portable OpenQASM 2.0 plus hamiltonian.json, so any counts engine can run it and QuantumQAOAEvaluator can score it. Convention: H on all qubits, then per layer exp(-igammaH) and RX(2*beta). PennyLane emits the RX mixer as h.rz.h and no gphase; circuit.global_phase_dropped records whether any were stripped. | Source |
PennylaneQuantumArithmetic |
Builds a reversible integer adder with PennyLane's SemiAdder from Operation, Operand A, Operand B and Bit Width. Outputs qasm2 with no measurement, plus the classical expected result for a deterministic-output oracle. | Source |
PennylaneVariationalAnsatz |
Builds a PennyLane variational ansatz (StronglyEntanglingLayers or BasicEntanglerLayers) with reproducible seeded weights and emits it as OpenQASM 2.0. Standalone mode creates a fresh n-qubit ansatz; when the incoming FlowFile already carries a qasm2 circuit (circuit.format=qasm2) the ansatz is appended to it, composing an embedding->ansatz model circuit. The qasm2 output feeds any Quanifi simulator or PennylaneExpectation. | Source |
PyquilAnsatz |
Build a reusable RY or RY/RZ trial-state recipe with CNOT entanglers. Attach mode preserves an upstream Hamiltonian for PyquilVQE; circuit mode emits a bound qasm2 circuit for simulation or PyquilExpectation. | Source |
PyquilGroverCircuit |
Builds a Grover search circuit using pyquil (Rigetti) for a given target bitstring and outputs the unmeasured circuit as OpenQASM 2.0, the interchange format every engine in this repo accepts. pyquil ships no Grover/amplitude-amplification helper, so the oracle and diffuser -- including the multi-controlled-Z, which pyquil has no native gate for beyond 2 controls -- are built here directly from pyquil's own H/X/CNOT/RZ primitives (see pyquil_components.mcz_ops), not translated from another framework's circuit. Connect to PyquilSimulator or any other engine in this repo to run the simulation. | Source |
PyquilGroverOperator |
Read a phase oracle as qasm2/qasm3, prepare a uniform superposition, and repeat oracle plus native pyQuil diffuser. Output qasm2 for any simulator. Input must be an oracle, not a complete Grover circuit. | Source |
PyquilQAOACircuit |
Builds the bound native pyQuil QAOA circuit (pyquil_components.qaoa) for a diagonal I/Z cost Hamiltonian and explicit Betas/Gammas (beta then gamma) and emits portable OpenQASM 2.0 plus hamiltonian.json, so any counts engine can run it and QuantumQAOAEvaluator can score it. Convention: H on all qubits, then per layer exp(-igammaH) and RX(2*beta). | Source |
PyquilQFT |
Build or append the forward/inverse quantum Fourier transform in native pyQuil. Qubit 0 is the most significant bit in the documented Fourier matrix; optional final swaps reverse the output register. Emits bound qasm2. | Source |
QiskitAmplitudeAmplification |
Generalised Grover amplitude amplification using the qiskit-algorithms AmplificationProblem / Grover.construct_circuit() framework (Brassard et al., 2000). Standalone mode: builds a phase oracle for the Marked State bitstring and wraps it in a uniform-superposition (H⊗n) Grover circuit. Compose mode: the incoming FlowFile is treated as the oracle circuit; amplitude amplification is built around it. No measurement is added — connect to QiskitAerSimulator to run. Q = A·S₀·A†·Sᶠ is applied Num Iterations times. | Source |
QiskitAnsatz |
Builds a parameterised variational ansatz (efficient_su2, real_amplitudes, or two_local) and attaches it to the FlowFile as base64 QPY in the ansatz.qpy_b64 attribute. In chain mode the incoming Hamiltonian content passes through unchanged; in standalone mode the ansatz is written as the circuit content with the circuit.* contract. | Source |
QiskitBellState |
Prepares one of the four Bell states (H + CNOT + optional local flips), samples it, and reports the two-outcome histogram plus bell.correlation (probability mass on the correlated pair, 1.0 ideal). The canonical entanglement demo. | Source |
QiskitGroverCircuit |
Builds a Grover search circuit for a given target bitstring and outputs the unmeasured circuit in either QPY (Qiskit binary) or OpenQASM 3 format. Connect to AerSimulator to run the simulation. | Source |
QiskitGroverOperator |
Reads an oracle circuit from the FlowFile content (produced by QiskitPhaseOracle, or by CirqPhaseOracle with Output Format 'qasm2'), prepends the uniform superposition H⊗n, and applies the full Grover operator (oracle + diffuser) the requested number of times via qiskit.circuit.library.grover_operator. Mirrors CirqGroverOperator so the two are interchangeable on the canvas. No measurement is added — connect to QiskitAerSimulator to run the circuit. | Source |
QiskitHadamardTransform |
Applies a Hadamard gate to every qubit of a circuit. If the incoming FlowFile already carries a circuit (circuit.format attribute set), H gates are appended to all its qubits. If the FlowFile is empty, a fresh n-qubit circuit is created. | Source |
QiskitPhaseEstimation |
Builds a Quantum Phase Estimation (QPE) circuit using Qiskit's PhaseEstimation library block. In standalone mode a demo QPE circuit is constructed for a builtin unitary (T, S, or Z). In compose mode the unitary is loaded from the FlowFile content. The phase register size controls estimation precision. | Source |
QiskitQAOACircuit |
Builds the bound Qiskit QAOA circuit (qiskit.circuit.library.qaoa_ansatz) for a diagonal I/Z cost Hamiltonian and explicit Betas/Gammas (beta then gamma) and emits portable OpenQASM 2.0 plus hamiltonian.json, so any counts engine can run it and QuantumQAOAEvaluator can score it. Convention: H on all qubits, then per layer exp(-igammaH) and RX(2*beta). | Source |
QiskitQFTCircuit |
Applies the Quantum Fourier Transform (QFT) or its inverse to a circuit. In standalone mode a fresh n-qubit QFT circuit is created. In compose mode the QFT is appended to an existing circuit received via the FlowFile content. | Source |
QiskitQuantumArithmetic |
Builds a reversible integer adder circuit with one of Qiskit's three independent implementations (CDKM ripple-carry, VBE ripple-carry, Draper QFT). Configure Implementation, Operand A, Operand B, and Bit Width. Outputs qasm2 with no measurement, plus the classical expected result and expected counts key for a deterministic-output oracle. | Source |
QiskitQuantumHelloWorld |
Runs a Qiskit GHZ-state circuit and writes the measurement bitstring to the FlowFile content | Source |
QiskitStatePreparation |
Prepares a quantum state circuit from a classical description. Supports uniform superposition, GHZ, a specific basis state, or an arbitrary normalized amplitude vector (custom mode). | Source |
QiskitTeleportation |
Teleports Rz(Phi)Ry(Theta)|0> from qubit 0 to qubit 2 using a Bell pair, a Bell measurement, and classically conditioned corrections (dynamic circuit). Self-verifies by inverting the preparation on the target: teleport.fidelity = P(target measures 0), ideally 1.0. | Source |
QrispAnsatz |
Declares a parameterised Qrisp variational ansatz (efficient_su2, real_amplitudes, or two_local) as a spec carried in ansatz.* attributes. A Qrisp ansatz is a callable, not a serialisable circuit, so QrispVQE reconstructs it from the spec. In chain mode the incoming Hamiltonian passes through. | Source |
QrispGroverCircuit |
Builds a Grover search circuit for a target bitstring with Qrisp (tag_state phase oracle + grovers_alg diffuser, fixed Num Iterations) and outputs the unmeasured circuit as portable OpenQASM 2.0 (one qreg, gates h/x/cx/rz), so any counts engine can run it. Marked State is q0-left (qubit 0 = leftmost character), like the Qiskit, Cirq, PennyLane and pyQuil Grover builders. 1-8 qubits. | Source |
QrispHadamardTransform |
Applies a Hadamard gate to every qubit (H⊗n) using Qrisp. In standalone mode (empty FlowFile) a fresh n-qubit circuit is created, producing the uniform superposition H⊗n|0⟩. In compose mode the H layer is appended to an existing qasm2 circuit received via the FlowFile content. Always emits OpenQASM 2.0, compatible with QrispSimulator, QiskitAerSimulator, and CirqSimulator. Cross-framework mirror of QiskitHadamardTransform. | Source |
QrispPhaseEstimation |
Quantum Phase Estimation (QPE) using Qrisp. Estimates the eigenphase φ of a unitary operator U such that U|ψ⟩ = exp(2πiφ)|ψ⟩. Uses Qrisp's QPE primitive with iter_spec=True for efficient controlled-U^(2^k) application. Built-in unitaries: T (φ=1/8), S (φ=1/4), Z (φ=1/2). The target register is prepared in the |1⟩ eigenstate. Outputs a probability distribution over estimated phase values (as floats 0–1). Sets qpe.top_phase to the most likely phase; also exports the circuit as qasm2. | Source |
QrispQAOACircuit |
Builds the bound Qrisp QAOA circuit (QAOAProblem's cost operator + mixer, without training) for a diagonal I/Z cost Hamiltonian and explicit Betas/Gammas (beta then gamma) and emits portable OpenQASM 2.0 plus hamiltonian.json, so any counts engine can run it and QuantumQAOAEvaluator can score it. Convention: H on all qubits, then per layer exp(-igammaH) and RX(2*beta). Qrisp's per-qubit registers are normalised to one qreg; the XY mixer is rebased to {h,x,rx,ry,rz,cx}. | Source |
QrispQCCSDAnsatz |
Declares a QCCSD chemistry ansatz for QrispVQE. Carries the chemistry spec in ansatz.* attributes and passes through incoming Hamiltonian content in chain mode. | Source |
QrispQFTCircuit |
Applies the Quantum Fourier Transform (or its inverse QFT†) using Qrisp's built-in QFT primitive. Outputs qasm2 compatible with QrispSimulator, QiskitAerSimulator, and CirqSimulator. No measurement is added — connect to a simulator to run the circuit. | Source |
QrispQuantumArithmetic |
Builds a quantum arithmetic circuit (add / subtract / multiply) on Qrisp QuantumFloat registers. Configure Operation, Operand A, Operand B, Bit Width, and Signed. Outputs qasm2 compatible with QrispSimulator, QiskitAerSimulator, and CirqSimulator; no measurement is added. | Source |
QrispStatePreparation |
Prepares a quantum state circuit from a classical description, using Qrisp. Supports uniform superposition, GHZ, a specific basis state, or an arbitrary normalized amplitude vector (custom mode). Emits OpenQASM 2.0 compatible with QiskitAerSimulator and CirqSimulator. Cross-framework mirror of QiskitStatePreparation. | Source |
QrispTruthTableSynthesis |
Compiles classical boolean truth tables into reversible quantum circuits using Qrisp. Supports Gray-code and PPRM logic synthesis methods. | Source |
QrispTypeEncoder |
Encodes classical numbers or arrays into typed quantum registers (QuantumFloat/QuantumArray) using Qrisp, generating the corresponding quantum initialization circuit. | Source |
QuantumQAOAEvaluator |
Framework-neutral QAOA scoring for any counts engine's output. Reads q0_left measurement counts (sim.bit_order=q0_left) plus the cost Hamiltonian (hamiltonian.json from any upstream QAOA builder/solver, or the Hamiltonian property) and emits qaoa.best_measurement, best_value, sampled_expectation, exact_minimum/maximum, approximation_ratio, expectation_ratio, optimal_probability, optimal_states and the builder/engine that produced this cell. Counts pass through unchanged so QuanifiReport can still render them. | Source |
ReadoutBaselineCircuit |
Builds a readout-error baseline circuit: prepares a target bitstring with X gates only (no superposition, no entanglement, no two-qubit gates) and measures it. Used as the calibration reference in the Grover N-M hardware matrix so gate error (builder-dependent) can be separated from readout error (builder-independent) on the same physical qubits, in the same batch. | Source |
Differential & mutation-testing infrastructure
| Processor | Description | Source |
|---|---|---|
CirqPhaseOracle |
Builds a phase oracle circuit for a given target bitstring. The oracle applies a -1 phase to |target⟩ and leaves all other states unchanged. In standalone mode it outputs a bare oracle circuit (no state preparation). In compose mode it appends the oracle to an existing Cirq circuit. Connect to CirqGroverOperator to build the full Grover search, or feed into amplitude estimation / amplitude amplification circuits. | Source |
MutationScoreReport |
Aggregates per-case verdicts (assert.verdict + mut. attributes) into a mutation survival rate, grouped by mutation operator and keyed on test.run_id. Excludes control rows from the score and reports control dissents (real cross-framework discrepancies) separately. Writes an HTML survival-rate report and emits mutation. summary attributes. | Source |
PyquilPhaseOracle |
Build an unmeasured bitstring phase oracle in native pyQuil. Outputs qasm2, with qubit 0 at the left of Marked State. Connect to PyquilGroverOperator. | Source |
QiskitPhaseOracle |
Builds a phase oracle circuit for a given target bitstring using Qiskit. The oracle applies a -1 phase to |target⟩ and leaves all other states unchanged. In standalone mode it outputs a bare oracle circuit (no state preparation). In compose mode it appends the oracle to an existing Qiskit circuit. Connect to QiskitGroverOperator to build the full Grover search, or feed into QiskitAmplitudeAmplification. Mirrors CirqPhaseOracle so the two are interchangeable on the canvas (use Output Format 'qasm2' to cross frameworks). | Source |
QuantumAssertion |
Assertion gate for data-driven differential testing. Receives the output of QuantumDistributionComparison and applies a Hellinger threshold check (differential oracle) plus an optional ground-truth check against test.expected. Routes to 'pass' or 'fail'. Appends a row to an HTML test-results table showing per-case verdicts, reasons, and a pass rate. | Source |
QuantumCalibratedOracle |
Scores a hardware batch with a threshold calibrated from control replicates in the same job, instead of a fixed value. Applies the two-gate kill rule (chi-squared rejection AND effect size) to every control and mutant comparison, reports false alarms and the mutation score, persists the raw batch counts, and writes an HTML card. Pair with a batch submitter/poller. | Source |
QuantumConsensusOracle |
K-way majority oracle: collects K framework measurement distributions sharing a slot key, takes a majority vote (endian-agnostic), and emits assert.verdict = PASS / FAIL / DISAGREE plus consensus.* details. Generalises QuantumDistributionComparison+QuantumAssertion to K branches and feeds MutationScoreReport. FAIL catches whole-case mutants that all branches get equally wrong; DISAGREE catches single-branch dissent. | Source |
QuantumDistributionComparison |
Pairs two quantum measurement distributions and computes Hellinger distance, Total Variation, and Fidelity (effect sizes), plus a Pearson chi-squared homogeneity test on the raw counts (inference: is the gap explainable by shot noise?). Emits a two-gate verdict — consistent / negligible-difference / disagree — gated by the Significance Level and Practical Hellinger Threshold properties. Writes a side-by-side HTML comparison card. Pairing is controlled by a static Comparison Label — no shared FlowFile attribute required. | Source |
QuantumDistributionOracle |
K-way consensus over branch measurement distributions, voting on distribution similarity (max pairwise Hellinger gated by a chi-squared homogeneity test) instead of the top-1 measured state. Use for degenerate or multi-peaked outputs such as GHZ, where a top-1 vote is a coin flip and reports DISAGREE on correct code. Ground truth is checked as expected support, not a single winner. Writes an HTML consensus card. | Source |
QuantumMutator |
Gate-level (Layer-A) mutation-testing operator: reads a qasm2/qasm3 circuit, applies one syntactic mutation (gate.add, gate.remove, gate.replace same-arity, rotation.perturb) and emits the mutant in the same format with mut.* bookkeeping attributes. Connect between a circuit builder and a simulator on ONE branch of a K-branch consensus flow so a killed mutant surfaces as a single-branch DISAGREE at QuantumConsensusOracle. Control rows (mut.applied=false) and Layer-B mutants pass through unmutated. | Source |
QuantumSuccessProbabilityOracle |
Scores measurement counts against a single known-correct outcome: success probability with a Wilson confidence interval, and (in paired mode) a two-proportion test between two runs sharing a Comparison Label. For programs whose specification fixes exactly one answer, such as reversible arithmetic. | Source |
QuantumTestCaseSource |
Expands a compact test-matrix spec (explicit JSON table or parameter axes) into a JSON array of test-case rows for data-driven / differential testing. Each row carries input parameters plus test.case_id / test.run_id / test.partition. Feed into SplitJson to fan out one FlowFile per case. | Source |
QuantumUnitaryComparison |
Compares two unitary matrices for equivalence up to a global phase. Pairs two FlowFiles produced by QuanifiUnitary using a static Comparison Label, then computes the process fidelity F = |tr(U_A^dagger . U_B)|^2 / d^2. F = 1 (within tolerance) means the circuits are equivalent on every possible input, not just |0...0>. The first arrival is held in a state file; the second triggers the comparison. Routes the first of a pair to failure (auto-terminate it) and the completed comparison to success. | Source |
Hamiltonians & problem encoders
| Processor | Description | Source |
|---|---|---|
CirqHamiltonian |
Builds a problem Hamiltonian from a compact-indexed Pauli sum such as 'Z0 + Z1 + 0.5 X0 X1' (or JSON) and serialises it in the framework-neutral wire format shared with QiskitHamiltonian. Tags hamiltonian.framework=cirq. No quantum execution. | Source |
MaxCliqueProblem |
Encodes a graph (JSON edge list) into the Maximum Clique Ising Hamiltonian in the framework-neutral wire format (hamiltonian.format = sparse_pauli_op_json). Drop the output directly into QrispQAOA, QiskitQAOA, or CirqQAOA. | Source |
MaxCutProblem |
Encodes a weighted graph (JSON edge list, e.g. [[0,1],[1,2,0.5]]) as the MaxCut Ising Hamiltonian in the framework-neutral wire format (hamiltonian.format = sparse_pauli_op_json, diagonal). The minimum eigenvalue equals -max_cut. Drop the output into QiskitQAOA, CirqQAOA, QrispQAOA or PennylaneQAOA to solve it — no Pauli strings required. | Source |
MaxIndependentSetProblem |
Encodes a graph (JSON edge list) into the Maximum Independent Set (MIS) Ising Hamiltonian in the framework-neutral wire format (hamiltonian.format = sparse_pauli_op_json). Drop the output directly into QrispQAOA, QiskitQAOA, or CirqQAOA. | Source |
MoleculeHamiltonian |
Builds a molecular qubit Hamiltonian from a geometry such as 'H 0 0 0; H 0 0 0.735' using pyscf + OpenFermion (Jordan-Wigner). Emits the framework-neutral operator JSON with hamiltonian.format = 'sparse_pauli_op_json' so any *VQE solver can consume it, plus chemistry attributes (formula, bond distance, HF/FCI reference energies). No quantum execution happens here. | Source |
PortfolioRebalancingProblem |
Encodes Markowitz portfolio rebalancing with cardinality constraint into the framework-neutral Ising Hamiltonian wire format. Drop the output into QrispQAOA (especially with Mixer Type = XY), QiskitQAOA, or CirqQAOA. | Source |
QiskitHamiltonian |
Builds a problem Hamiltonian (SparsePauliOp) from a compact-indexed Pauli sum such as 'Z0 + Z1 + 0.5 X0 X1' (or JSON) and serialises it as JSON. Sets hamiltonian.format = 'sparse_pauli_op_json' so QiskitVQE (or any operator consumer) can pick it up. No quantum execution happens here. | Source |
QrispHamiltonian |
Builds a problem Hamiltonian from a compact-indexed Pauli sum such as 'Z0 + Z1 + 0.5 X0 X1' (or JSON) and serialises it in the framework-neutral wire format shared with QiskitHamiltonian and CirqHamiltonian. Tags hamiltonian.framework=qrisp. No quantum execution. | Source |
QuboToHamiltonian |
Encodes a QUBO matrix (JSON 2D array; minimize x^T Q x over binary x) as the equivalent Ising Hamiltonian in the framework-neutral wire format (hamiltonian.format = sparse_pauli_op_json, diagonal). The minimum eigenvalue equals the QUBO optimum and the ground bitstring is the binary solution. Feed it to any QAOA or VQE solver. | Source |
Hardware batch lane
| Processor | Description | Source |
|---|---|---|
IQMJobPoller |
Polls the IQM Resonance REST API (GET /api/v1/jobs/{id}) for the job in hw.job_id, honouring the Retry-After header, and emits measurement counts when it completes. Routes to 'pending' while the job is still queued or running — wire that back into this processor to keep polling without blocking the canvas. | Source |
QuantumBatchPoller |
Polls an IQM Resonance batch job and emits all circuits' measurement counts merged with the submitter's manifest, ready for QuantumCalibratedOracle. Routes to 'pending' while the job is queued — wire that back in to keep polling without blocking the canvas. | Source |
QuantumBatchResultExpander |
Expands a polled hardware batch into a JSON array of one row per circuit, each carrying that circuit's counts (normalised to q0_left) and the ground-truth attributes recorded at submission, so per-circuit results can be scored against a known answer. Feed into SplitJson. | Source |
QuantumIBMBatchPoller |
Polls an asynchronous IBM Runtime Sampler batch and emits all raw counts. | Source |
QuantumIBMBatchSubmitter |
Accumulates one calibrated hardware batch, searches and pins one layout, checks queue and estimated QPU usage caps, and submits one asynchronous IBM Runtime Sampler job. | Source |
QuantumIQMBatchPoller |
Polls one IQM Resonance BATCH job and merges its measurement counts back onto the submitter's manifest, preserving each circuit's ground truth, so QuantumBatchResultExpander can expand and score it. The batch twin of IQMJobPoller, which handles a single circuit. | Source |
QuantumIQMBatchSubmitter |
Accumulates OpenQASM circuits and submits them to IQM Resonance as a single job with one shared, searched qubit layout — required so that control replicates and mutants share a calibration snapshot, and so per-job cost is paid once. Does not block: emits the job id and a manifest for QuantumBatchPoller to collect. | Source |
QuantumInspireBatchPoller |
Polls one Quantum Inspire BATCH job -- recovered from the QPY handle QuantumInspireBatchSubmitter wrote alongside its manifest -- and merges its measurement counts back onto that manifest, preserving each circuit's ground truth, so QuantumBatchResultExpander can expand and score it. | Source |
QuantumInspireBatchSubmitter |
Accumulates OpenQASM circuits and submits them to Quantum Inspire as a single batch job with one shared, searched qubit layout. Does not block: emits the batch job id and a manifest for QuantumInspireBatchPoller to collect. | Source |
Hardware execution
| Processor | Description | Source |
|---|---|---|
BraketDevice |
Runs a circuit (circuit.format = qasm3 or qasm2, from any framework's builder) on an Amazon Braket device: a QPU / managed-simulator ARN, or 'local' for the offline LocalSimulator. Supports fire-and-forget submission (Wait For Results = false -> hw.task_arn) for long QPU queues. Credentials via the standard AWS chain. | Source |
QiskitRuntimeSampler |
Samples a circuit (circuit.format = qasm2 or qasm3, from any framework's builder) via IBM Qiskit Runtime SamplerV2. Backend 'fake_ |
Source |
QrispIQMDevice |
Runs a circuit (circuit.format = qasm2, from any framework's builder) on an IQM quantum computer via Qrisp's Backend Interface. Device Instance 'local' uses Qrisp's offline statevector simulator; 'garnet' / 'emerald' / ... submit to IQM Resonance (API token required). Supports fire-and-forget submission (Wait For Results = false -> hw.job_id) for long QPU queues; pair it with IQMJobPoller. | Source |
PennyLane QML lane
| Processor | Description | Source |
|---|---|---|
PennylaneDatasetLoader |
Emits a labelled classical dataset as a JSON array of records ({"features": [...], "label": k}) to drive a QML pipeline. 'synthetic' generates a separable two-class Gaussian-blob dataset (numpy only, fully offline and seeded); 'inline' validates and emits a dataset provided in the Records property. Feed into SplitJson to fan out one FlowFile per sample, then into PennylaneFeatureEmbedding. | Source |
PennylaneFeatureEmbedding |
Encodes a classical feature vector into a quantum circuit using a PennyLane embedding template (angle / amplitude / iqp / basis) and emits it as OpenQASM 2.0. The feature vector is read from the FlowFile content (a JSON array of numbers) when present, otherwise from the Features property. This is the classical->quantum data-loading step of a QML pipeline; the qasm2 output is interoperable with every Quanifi simulator. | Source |
PennylaneVariationalClassifier |
Trains a variational quantum classifier (AngleEmbedding + StronglyEntanglingLayers + trainable bias) on the labelled JSON dataset in the FlowFile content (from PennylaneDatasetLoader). Emits train.* attributes (final loss, train/validation accuracy), the loss history and trained weights as JSON, and report.type = training for the loss-curve report card. | Source |
Reporting & utility
| Processor | Description | Source |
|---|---|---|
QiskitCircuitReport |
[DEPRECATED — use QuanifiReport] Legacy Qiskit-only reporter. Appends an HTML card to a local report file for each FlowFile, showing the Grover circuit diagram (SVG re-rendered from QASM3), OpenQASM 3 source, simulation attributes, and a measurement-count bar chart. Superseded by the generic, framework-agnostic QuanifiReport (report.type/sim.framework-driven); kept only for backward compatibility with existing saved flows. | Source |
QuanifiReport |
Generic HTML report writer for Quanifi processors. Reads report.type from the FlowFile attribute to select which sections to render (circuit diagram, counts, statevector, comparison metrics, etc.) and appends a card to a local HTML file. Extend _SECTION_REGISTRY to support new processor output types. | Source |
QuanifiUnitary |
Computes the 2^n by 2^n unitary matrix of a quantum circuit and writes it as JSON ({real: [...], imag: [...]}). Connect between any circuit builder (CirqGroverCircuit, CirqPhaseOracle, CirqGroverOperator, QiskitGroverCircuit, QiskitQFTCircuit, etc.) and a downstream consumer such as QuantumUnitaryComparison. Reads the input format from the circuit.format attribute (cirq_json, qasm2, qasm3, qpy). Qiskit circuits are normalised to Cirq qubit-ordering convention so the unitaries are directly comparable across frameworks. Routes to failure with a clear error if the input is not a circuit or if the circuit exceeds Max Qubits. | Source |
Simulators
| Processor | Description | Source |
|---|---|---|
BraketSimulator |
Reads a quantum circuit from the FlowFile content (OpenQASM 3 or OpenQASM 2.0, determined by the 'circuit.format' attribute; both are re-based onto Braket-native gates via Qiskit's parser), samples it on the Amazon Braket LocalSimulator (no AWS account or network access required), and writes shot counts as JSON. Bit order is MSB-first (qubit 0 leftmost, the Cirq convention). Noise Model = none (default) runs the ideal state-vector simulator (braket_sv), unchanged from prior versions. Any other Noise Model runs the density-matrix simulator (braket_dm) with the selected single-qubit noise channel injected via Braket QASM pragmas after every 1-qubit gate; braket_dm's memory cost is 4^n (vs 2^n for braket_sv), so noisy runs are narrower and slower than noiseless ones. | Source |
CirqSimulator |
Reads a quantum circuit from the FlowFile content (Cirq JSON or OpenQASM 2.0, determined by the 'circuit.format' attribute), adds measurement, runs it on Cirq's wave-function simulator, and writes shot counts as JSON. Accepts Cirq JSON from CirqGroverCircuit or OpenQASM 2.0 from any circuit processor (including Qiskit processors that output qasm2 format). Optionally applies a noise channel (depolarizing / bit-flip / amplitude-damping) and a readout error. | Source |
CirqStatevectorSimulator |
Computes the exact statevector of an unmeasured quantum circuit using cirq.Simulator().simulate(). Accepts Cirq JSON or OpenQASM 2.0 (set by the 'circuit.format' attribute). Outputs the probability distribution as JSON and writes an HTML card with amplitude and phase per basis state. Cross-framework mirror of QiskitStatevectorSimulator. | Source |
PennylaneExpectation |
Runs a quantum circuit (OpenQASM 2.0, via circuit.format=qasm2) on a PennyLane device and emits its QML-native outputs: per-qubit Pauli expectation values (sim.expectations) and the probability distribution (FlowFile content, JSON state->probability). Unlike the shot-count simulators this is the expectation-value lane PennyLane is built around. Set Shots for sampled estimates, or leave blank for an exact (analytic) result. Accepts qasm2 from any Quanifi circuit builder. | Source |
PennylaneSimulator |
Reads a quantum circuit from the FlowFile content (OpenQASM 2.0, determined by the 'circuit.format' attribute), samples it on PennyLane's default.qubit device, and writes shot counts as JSON. Accepts qasm2 output from any Quanifi circuit builder. Note: default.qubit is an ideal (noiseless) statevector engine — for noisy simulation use QiskitAerSimulator or CirqSimulator, which expose a Noise Model property. For PennyLane's QML-native outputs (expectation values, analytic probabilities) use PennylaneExpectation instead. | Source |
PyquilExpectation |
Evaluate a Hermitian Pauli-sum expectation exactly using pyQuil local wavefunction simulation. Reads a qasm2/qasm3 circuit and an indexed Pauli expression or neutral Hamiltonian JSON property. Outputs expectation JSON, not shot counts. | Source |
PyquilSimulator |
Reads a quantum circuit from the FlowFile content (OpenQASM 2 or OpenQASM 3, determined by the 'circuit.format' attribute; both are re-based onto Quil-native gates via Qiskit's parser), samples it on Rigetti's pyquil PyQVM (no external quilc/qvm server required), and writes shot counts as JSON. Bit order is q0-left. Optionally applies pyquil's built-in Kraus noise channels via PyQVM's ReferenceDensitySimulator. | Source |
QSharpSimulator |
Reads an OpenQASM 2 or 3 circuit natively via the Microsoft QDK (no cross-framework translation through Qiskit), adds a full-register measurement when one isn't already present, and runs it with the QDK sparse-state or Clifford simulator. Emits canonical q0-left counts and optionally applies Pauli noise. | Source |
QiskitAerSimulator |
Reads a quantum circuit from the FlowFile content (QPY or OpenQASM 3, determined by the 'circuit.format' attribute), adds measurement, runs it on Qiskit's AerSimulator, and writes the shot counts as JSON. Optionally applies a gate/readout noise model so the simulation is non-ideal. | Source |
QiskitStatevectorSimulator |
Computes the exact statevector of an unmeasured quantum circuit using qiskit.quantum_info.Statevector. Outputs probability distribution as JSON and writes an HTML card with amplitude and phase per basis state. | Source |
QrispSimulator |
Reads a quantum circuit from the FlowFile content (OpenQASM 2.0, determined by the 'circuit.format' attribute), adds measurement, runs it on Qrisp's native statevector simulator, and writes shot counts as JSON. Accepts qasm2 output from any Qiskit or Cirq circuit processor. Note: Qrisp's native simulator is an ideal (noiseless) statevector engine and has no noise-model support — for noisy simulation use QiskitAerSimulator or CirqSimulator, which expose a Noise Model property. | Source |