Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Kuantum modellerden kuantum programlara: Petri ağları, algoritmalar ve derleme

Syed Asad Shah

Published Sep 1, 2026• 0 citations
OpenAlex

Abstract

This thesis introduces a simplified quantum Petri net (QPN) model and uses this model to generalize classical SISO, SIMO, MISO, MIMO, and Priority buffers to their quantum counterparts.It provides a primitive storage element, namely a quantum S-R flip-flop and describes two different such flip-flop designs using quantum NOT, CNOT, CCNOT, and SWAP gates.Each of the quantum S-R flip-flops can be replicated to obtain a quantum register for any given number of qubits.The aforementioned quantum buffers are then obtained using the simplified QPN model and quantum registers.The quantum S-R flip-flop and quantum buffer designs have been tested using OpenQASM 2.0 and Qiskit programs on IBM quantum computers and simulators and the results validate their expected operations.The thesis also addresses the problem of reachability in bounded quantum Petri nets (QPNs).The proposed approach exploits quantum parallelism to construct a superposition over all reachable markings from the initial marking.Grover's amplitude amplification algorithm is then applied to efficiently identify a desired target marking, while ancillary q-tokens used solely for transition control are excluded from the search space, significantly reducing its size.Theoretical analysis shows that our approach achieves a quadratic speed-up over classical exhaustive algorithms.Experimental results also confirm the correctness and feasibility of the proposed quantum algorithm for solving the bounded reachability problem in Quantum Petri Nets.A quantum algorithm for the Subset Sum Problem is also developed.The proposed approach exploits quantum superposition to represent all candidate subsets simultaneously and uses reversible controlled addition to compute their corresponding subset sums.Grover's amplitude amplification algorithm is then applied to increase the probability of measuring subsets whose sum matches the desired target.Theoretical analysis shows that our approach achieves a quadratic iii iv speed-up over classical exhaustive algorithms.The algorithm is implemented in Q# and evaluated using both valid and invalid target sums.Experimental results obtained using a Q# implementation confirm that the algorithm can correctly identify valid subsets for both single-solution and multiple-solution cases.Finally, the thesis introduces AQASM, an Abstract Quantum Assembly Language, together with a compiler framework for translating Quantum Intermediate Representation (QIR) programs into a backend-independent assembly representation.AQASM explicitly represents quantum and classical operations, synchronization, timing information, and parallel execution.The compiler performs preprocessing, instruction lowering, gate decomposition, dependency analysis, parallel-region generation, synchronization, and abstract scheduling.An abstract backend model with all-to-all qubit connectivity and representative operation durations is used to evaluate the compilation and scheduling process without targeting a specific quantum processor.Experimental evaluation using the Bernstein-Vazirani and quantum Subset Sum programs shows that the compiler correctly translates supported QIR operations, preserves instruction dependencies, identifies opportunities for parallel execution, and generates scheduled AQASM programs according to the assumptions of the abstract backend model.

Related papers

On the Reachability Problem in Quantum Petri Nets

Syed Asad Shah, A. Yavuz Oruc

In this paper, we propose a novel quantum solution to address the problem of reachability in bounded quantum Petri nets (QPNs), an advanced modeling framework that combines the classical Petri net model with quantum mechanical principles. The proposed approach exploits quantum parallelism to construct a superposition over all reachable markings from the initial marking. Grover's amplitude amplification algorithm is then applied to efficiently identify a desired target marking, while ancillary q-tokens used solely for transition control are excluded from the search space, significantly reducing its size. Theoretical analysis shows that our approach achieves a quadratic speed up over classical exhaustive algorithms. Experimental results also confirm the correctness and feasibility of the proposed quantum algorithm for solving the bounded reachability problem in Quantum Petri Nets.

quant-pharXiv:2608.21428•Aug 18, 2026•1 citation

Quantum buffer design using Petri nets

Syed Asad Shah, A. Yavuz Oruç

This paper introduces a simplified quantum Petri net (QPN) model and uses this model to generalize classical SISO, SIMO, MISO, MIMO, and Priority buffers to their quantum counterparts. It provides a primitive storage element, namely a quantum S-R flip-flop and describes two different such flip-flop designs using quantum NOT, CNOT, CCNOT, and SWAP gates. Each of the quantum S-R flip-flops can be replicated to obtain a quantum register for any given number of qubits. The aforementioned quantum buffers are then obtained using the simplified QPN model and quantum registers. The quantum S-R flip-flop and quantum buffer designs have been tested using OpenQasm 2.0 and Qiskit programs on IBM quantum computers and simulators and the results validate their expected operations.

arXiv:2408.08369•International Journal of Parallel Emergent and Distributed Systems•Dec 10, 2024•2 citations

Quantum Petri Nets

Tiberiu Stefan Letia, Elenita Maria Durla-Pasca, Dahlia Al-Janabi

The development of quantum software applications requires models capable to describe quantum features (superposition, entanglement, reversibility etc.) as well as the software algorithm requirements. The newly proposed Quantum Petri Nets (QPNs) have the structure of the classical Petri Nets (PNs), but their tokens represent superposed quantum states fulfilling the Hilbert space features. Instead of the integer numerical values of the PN marking, QPNs use quantum marking describing an extreme huge space. New conditions for the transition enabling and new mappings for the transition executions are conceived. A PN based language is used for the structure analysis. Replacing the classical tokens with the probability distribution of the quantum vectors, the QPN simulation is possible as well as the construction of a reachability graph.

International Conference on System Theory, Control and Computing (ICSTCC)•Oct 20, 2021•8 citations

Kvanttiohjelmien kääntämisen kehittäminen NISQ-aikakaudella

Arianne Meijer-van de Griend

Recent advances in the development of quantum technology have made it possible to run small quantum programs on real quantum computers. This has created a need for compiling methods specific to these quantum computers. Unlike classical computers, if a quantum computation takes too long, the qubits might decohere and lose their information, making the computation useless. Hence, well-optimized quantum programs are a necessity. Like classical computers, quantum computers have registers for qubits that are generally sparsely connected. However, classical compilation methods that rely on copying data from one register to another do not apply to quantum computers because qubits cannot be copied. This problem is called the qubit routing problem. Following classical compilation, one could solve the connectivity constraints by moving the qubits to adjacent qubit registers. However, this requires the addition of SWAP gates throughout the quantum circuit, resulting in a strictly longer program. Additionally, a SWAP gate on qubits is not cheap and requires three CNOT gates each. Instead, in this thesis, we have defined a new method for quantum compilation that is based in the quantum nature of the program to be compiled. Instead of routing the qubits directly, we generate new machine code (in the form of quantum circuits) from an intermediate representation. We call this process quantum circuit synthesis. During synthesis, we make sure that all generated gates are supported by the target quantum hardware. Additionally, if the synthesis process is optimal, the resulting quantum circuit will also be optimal, although the methods proposed in this thesis are all heuristic in nature due to the computational complexity of optimal architecture-aware synthesis. We construct the nested intermediate representation starting from sequences of CNOT circuits interleaved with single qubit gates and incrementally generalize the intermediate representation to a universal representation. In particular, we propose two algorithms for synthesizing CNOT circuits from their parity matrix representation and one algorithm for synthesizing phase polynomials (i.e. CNOT+$R_z$ circuits). Additionally, we show that when combining these methods into the universal representation called Mixed ZX-phase polynomial, it is competitive with existing commercial quantum compilers IBM's Qiskit and Quantinuum's TKET for large circuits. This thesis additionally contains a proposal for a framework to benchmark the quality of circuits used in an algorithm called Variational Quantum Eigensolver (VQE). This framework attempts to measure how close the solution found by the VQE is to our best estimate of a real molecule (i.e. accuracy), rather than a classical simulation of the approximate molecule as given to the quantum computer (i.e. precision).

Työväentutkimus Vuosikirja•Jan 8, 2024•0 citations

A Reasoning Method Using Quantum Petri Nets

Yang Xun

To deal with the non-applicability of the thresh value in Petri Nets,a reasoning method based on the quantum superposition principle is proposed.The reasoning method provide the quantum Petri Nets(QPN).In the quantum petri nets,The ignition thresholds and the tokes of QPN is described by quantum superposition states.The reasoning method can deal with inconsistent inforamtion in parallel computation and get the inference results in quantum state.The quantum state of the results collapses in probability and a inference result set is obtained.The inference result set is analysed based on the designed optimization operators and the most reasonable result is oabtained.To increase the recognition rate of Morse code signal targets,a recognition algorithm of Morse code signal targets is proposed.The software developed based on the recognition algorithm has good stability and anti-noise ability.

Signal Processing•Jan 1, 2009•0 citations

Program compilation for large-scale quantum computers

Giulia Meuli

Practical realizations of quantum computers are poised to deliver outstanding computational capabilities far beyond the reach of any classical supercomputer. While classical systems are reliably implemented using CMOS technology, the fabrication of quantum hardware has not yet reached a commercially viable level of maturity. Nowadays, many different technologies are being developed as competing candidates to build the first error-corrected quantum computer. Among the software resources required to operate such a system, quantum compilers translate a high-level description of a quantum algorithm into low-level, technology-dependent quantum instructions. Many quantum algorithms, including Shor's and Grover's algorithms, require to compute some classical logic functions on the quantum computer. The first part of this thesis deals with the problem of compiling quantum circuits that perform such classical Boolean functions, called oracles, into a fault-tolerant set of instructions. Oracle circuits often demand many resources in terms of the number of qubits and gates. The focus is on compiling quantum circuits starting from multi-level logic networks representing large Boolean functions while minimizing the resource footprint of the obtained quantum circuits. At the same time, the trade-off between memory resources and the number of operations typical of such a compilation process is explored. As part of the effort in reducing the resources required to perform a given quantum program, I also present some quantum circuit optimization techniques. The researched algorithms leverage data structures and techniques borrowed and adapted from classical logic synthesis, e.g., SAT solvers, LUT mapping, and multi-level logic networks. I implemented all the compilation algorithms presented in this thesis as part of open-source projects. In particular, I develop and maintain caterpillar---a C++ header-only library dedicated to the quantum compilation of oracles and quantum memory management. The second part of this thesis describes how to equip quantum programming language compilers with automatic accuracy management. Despite the availability of many of such languages, resource estimation of quantum algorithms does not yet support taking approximation errors into account. This general methodology is applicable to any programming language and I demonstrate its integration into the Q# compiler. The technique consists of providing language support to ease the accuracy-aware programming task. The user can define accuracy parameters that will be automatically optimized according to a constraint and a cost function directly generated from the source code. In the presented practical evaluations, the constraint function is the overall allowed accuracy, while the cost function is application-dependent and related to the number of gates. During the optimization process, such functions are evaluated hundreds of times. For this reason, we extract them as (near-)symbolic expressions, whose evaluation time does not depend on the quantum algorithm size. The algorithms and the methodologies presented in this thesis are part of a widespread effort of the research community to build a complete and efficient software stack to program and control the first practical universal quantum computer.

•Jan 1, 2020•1 citation
This thesis introduces a simplified quantum Petri net (QPN) model and uses this model to generalize classical SISO, SIMO, MISO, MIMO, and Priority buffers to their quantum counterparts.It provides a primitive storage element, namely a quantum S-R flip-flop and describes two different such flip-flop designs using quantum NOT, CNOT, CCNOT, and SWAP gates.Each of the quantum S-R flip-flops can be replicated to obtain a quantum register for any given number of qubits.The aforementioned quantum buffers are then obtained using the simplified QPN model and quantum registers.The quantum S-R flip-flop and quantum buffer designs have been tested using OpenQASM 2.0 and Qiskit programs on IBM quantum computers and simulators and the results validate their expected operations.The thesis also addresses the problem of reachability in bounded quantum Petri nets (QPNs).The proposed approach exploits quantum parallelism to construct a superposition over all reachable markings from the initial marking.Grover's amplitude amplification algorithm is then applied to efficiently identify a desired target marking, while ancillary q-tokens used solely for transition control are excluded from the search space, significantly reducing its size.Theoretical analysis shows that our approach achieves a quadratic speed-up over classical exhaustive algorithms.Experimental results also confirm the correctness and feasibility of the proposed quantum algorithm for solving the bounded reachability problem in Quantum Petri Nets.A quantum algorithm for the Subset Sum Problem is also developed.The proposed approach exploits quantum superposition to represent all candidate subsets simultaneously and uses reversible controlled addition to compute their corresponding subset sums.Grover's amplitude amplification algorithm is then applied to increase the probability of measuring subsets whose sum matches the desired target.Theoretical analysis shows that our approach achieves a quadratic iii iv speed-up over classical exhaustive algorithms.The algorithm is implemented in Q# and evaluated using both valid and invalid target sums.Experimental results obtained using a Q# implementation confirm that the algorithm can correctly identify valid subsets for both single-solution and multiple-solution cases.Finally, the thesis introduces AQASM, an Abstract Quantum Assembly Language, together with a compiler framework for translating Quantum Intermediate Representation (QIR) programs into a backend-independent assembly representation.AQASM explicitly represents quantum and classical operations, synchronization, timing information, and parallel execution.The compiler performs preprocessing, instruction lowering, gate decomposition, dependency analysis, parallel-region generation, synchronization, and abstract scheduling.An abstract backend model with all-to-all qubit connectivity and representative operation durations is used to evaluate the compilation and scheduling process without targeting a specific quantum processor.Experimental evaluation using the Bernstein-Vazirani and quantum Subset Sum programs shows that the compiler correctly translates supported QIR operations, preserves instruction dependencies, identifies opportunities for parallel execution, and generates scheduled AQASM programs according to the assumptions of the abstract backend model.
In this paper, we propose a novel quantum solution to address the problem of reachability in bounded quantum Petri nets (QPNs), an advanced modeling framework that combines the classical Petri net model with quantum mechanical principles. The proposed approach exploits quantum parallelism to construct a superposition over all reachable markings from the initial marking. Grover's amplitude amplification algorithm is then applied to efficiently identify a desired target marking, while ancillary q-tokens used solely for transition control are excluded from the search space, significantly reducing its size. Theoretical analysis shows that our approach achieves a quadratic speed up over classical exhaustive algorithms. Experimental results also confirm the correctness and feasibility of the proposed quantum algorithm for solving the bounded reachability problem in Quantum Petri Nets.
This paper introduces a simplified quantum Petri net (QPN) model and uses this model to generalize classical SISO, SIMO, MISO, MIMO, and Priority buffers to their quantum counterparts. It provides a primitive storage element, namely a quantum S-R flip-flop and describes two different such flip-flop designs using quantum NOT, CNOT, CCNOT, and SWAP gates. Each of the quantum S-R flip-flops can be replicated to obtain a quantum register for any given number of qubits. The aforementioned quantum buffers are then obtained using the simplified QPN model and quantum registers. The quantum S-R flip-flop and quantum buffer designs have been tested using OpenQasm 2.0 and Qiskit programs on IBM quantum computers and simulators and the results validate their expected operations.
The development of quantum software applications requires models capable to describe quantum features (superposition, entanglement, reversibility etc.) as well as the software algorithm requirements. The newly proposed Quantum Petri Nets (QPNs) have the structure of the classical Petri Nets (PNs), but their tokens represent superposed quantum states fulfilling the Hilbert space features. Instead of the integer numerical values of the PN marking, QPNs use quantum marking describing an extreme huge space. New conditions for the transition enabling and new mappings for the transition executions are conceived. A PN based language is used for the structure analysis. Replacing the classical tokens with the probability distribution of the quantum vectors, the QPN simulation is possible as well as the construction of a reachability graph.
Recent advances in the development of quantum technology have made it possible to run small quantum programs on real quantum computers. This has created a need for compiling methods specific to these quantum computers. Unlike classical computers, if a quantum computation takes too long, the qubits might decohere and lose their information, making the computation useless. Hence, well-optimized quantum programs are a necessity. Like classical computers, quantum computers have registers for qubits that are generally sparsely connected. However, classical compilation methods that rely on copying data from one register to another do not apply to quantum computers because qubits cannot be copied. This problem is called the qubit routing problem. Following classical compilation, one could solve the connectivity constraints by moving the qubits to adjacent qubit registers. However, this requires the addition of SWAP gates throughout the quantum circuit, resulting in a strictly longer program. Additionally, a SWAP gate on qubits is not cheap and requires three CNOT gates each. Instead, in this thesis, we have defined a new method for quantum compilation that is based in the quantum nature of the program to be compiled. Instead of routing the qubits directly, we generate new machine code (in the form of quantum circuits) from an intermediate representation. We call this process quantum circuit synthesis. During synthesis, we make sure that all generated gates are supported by the target quantum hardware. Additionally, if the synthesis process is optimal, the resulting quantum circuit will also be optimal, although the methods proposed in this thesis are all heuristic in nature due to the computational complexity of optimal architecture-aware synthesis. We construct the nested intermediate representation starting from sequences of CNOT circuits interleaved with single qubit gates and incrementally generalize the intermediate representation to a universal representation. In particular, we propose two algorithms for synthesizing CNOT circuits from their parity matrix representation and one algorithm for synthesizing phase polynomials (i.e. CNOT+RzR_zRz​ circuits). Additionally, we show that when combining these methods into the universal representation called Mixed ZX-phase polynomial, it is competitive with existing commercial quantum compilers IBM's Qiskit and Quantinuum's TKET for large circuits. This thesis additionally contains a proposal for a framework to benchmark the quality of circuits used in an algorithm called Variational Quantum Eigensolver (VQE). This framework attempts to measure how close the solution found by the VQE is to our best estimate of a real molecule (i.e. accuracy), rather than a classical simulation of the approximate molecule as given to the quantum computer (i.e. precision).
To deal with the non-applicability of the thresh value in Petri Nets,a reasoning method based on the quantum superposition principle is proposed.The reasoning method provide the quantum Petri Nets(QPN).In the quantum petri nets,The ignition thresholds and the tokes of QPN is described by quantum superposition states.The reasoning method can deal with inconsistent inforamtion in parallel computation and get the inference results in quantum state.The quantum state of the results collapses in probability and a inference result set is obtained.The inference result set is analysed based on the designed optimization operators and the most reasonable result is oabtained.To increase the recognition rate of Morse code signal targets,a recognition algorithm of Morse code signal targets is proposed.The software developed based on the recognition algorithm has good stability and anti-noise ability.
Practical realizations of quantum computers are poised to deliver outstanding computational capabilities far beyond the reach of any classical supercomputer. While classical systems are reliably implemented using CMOS technology, the fabrication of quantum hardware has not yet reached a commercially viable level of maturity. Nowadays, many different technologies are being developed as competing candidates to build the first error-corrected quantum computer. Among the software resources required to operate such a system, quantum compilers translate a high-level description of a quantum algorithm into low-level, technology-dependent quantum instructions. Many quantum algorithms, including Shor's and Grover's algorithms, require to compute some classical logic functions on the quantum computer. The first part of this thesis deals with the problem of compiling quantum circuits that perform such classical Boolean functions, called oracles, into a fault-tolerant set of instructions. Oracle circuits often demand many resources in terms of the number of qubits and gates. The focus is on compiling quantum circuits starting from multi-level logic networks representing large Boolean functions while minimizing the resource footprint of the obtained quantum circuits. At the same time, the trade-off between memory resources and the number of operations typical of such a compilation process is explored. As part of the effort in reducing the resources required to perform a given quantum program, I also present some quantum circuit optimization techniques. The researched algorithms leverage data structures and techniques borrowed and adapted from classical logic synthesis, e.g., SAT solvers, LUT mapping, and multi-level logic networks. I implemented all the compilation algorithms presented in this thesis as part of open-source projects. In particular, I develop and maintain caterpillar---a C++ header-only library dedicated to the quantum compilation of oracles and quantum memory management. The second part of this thesis describes how to equip quantum programming language compilers with automatic accuracy management. Despite the availability of many of such languages, resource estimation of quantum algorithms does not yet support taking approximation errors into account. This general methodology is applicable to any programming language and I demonstrate its integration into the Q# compiler. The technique consists of providing language support to ease the accuracy-aware programming task. The user can define accuracy parameters that will be automatically optimized according to a constraint and a cost function directly generated from the source code. In the presented practical evaluations, the constraint function is the overall allowed accuracy, while the cost function is application-dependent and related to the number of gates. During the optimization process, such functions are evaluated hundreds of times. For this reason, we extract them as (near-)symbolic expressions, whose evaluation time does not depend on the quantum algorithm size. The algorithms and the methodologies presented in this thesis are part of a widespread effort of the research community to build a complete and efficient software stack to program and control the first practical universal quantum computer.