Development of Dynamic System Applications Using Distributed Quantum-Centric Computing

Abstract

Many applications of quantum computers require the classical and quantum implementation of dynamic systems (DSs). These applications comprise interacting quantum and classical tasks. While quantum tasks evolve in the quantum domain, classical tasks behave in the classical domain. Besides tackling these kinds of tasks, the computational gap between these domains is covered by the current study. The quantum computing feature All at Once (A@O) executions is appropriate for static systems but less for DSs. The novelty of the proposed approach consists of using Distributed Quantum-Centric Petri Net (DQCPN) models composed of quantum and high-level Petri Nets for specification, design, verification, and implementation of classical–quantum applications. Quantum Processing Units (QPUs) are linked to classical components implementing the control and optimization operations in the proposed application. Many practical applications combine quantum and classical computing to address optimization problems. Quantum computers can be built with a combination of qubits and bosonic qumodes, leading to a new paradigm toward quantum computing. The optimizations are performed by some Evolutionary Algorithms (EAs), including Particle Swarm Optimization (PSO) methods and Genetic Algorithms (GAs). For experiments, an Urban Vehicle Traffic System (UVTS) is used as an open distributed system. The vehicle flows are implemented by discrete qubits, discrete vectors of qubits, or qumodes.

1. Introduction

Quantum and classical computing are increasingly combined to address optimization problems [1]. Quantum computers may integrate qubits and bosonic qumodes, introducing a new paradigm. While qubits are implemented on quantum superconductivity hardware at cryogenic temperatures, qumodes are realized on optical processors operating at room temperature.

Practical applications of quantum computing include the following:

• Artificial intelligence (AI) and machine learning (e.g., quantum-inspired tensor neural networks for quantum machine learning and quantum generative AI);
• Financial modeling for market prediction and risk management;
• Manufacturing resilience, for identifying components that contribute to incidents of product failure;
• Secure communications and access control for blockchain or quantum cryptography;
• Cybersecurity;
• Material science, for finding molecules with more complex interactions;
• Drug and chemical research for new-drug finding;
• Weather forecasting and climate change;
• Electrical power system balance, and scheduling and control;
• Route and traffic optimization for finding the shortest possible route between cities or traffic flows;
• Complex circuit design;
• Complex structure synthesis;
• Automotive industry (e.g., improved battery conception);
• Quantum computing applied to natural language processing;
• Quantum computing for task optimization;
• Quantum sensing (environmental monitoring, medical imaging, geological exploration, etc.).

1.1. Development of Quantum Software Application

The practical use of quantum computing requires accessible and effective programming development methods. Several important approaches for solving quantum computing problems are analyzed in [2].

According to [3], there is a strong need for simulators and design environments focused more on software design than on quantum circuits. This refers to the high-level design of hybrid software systems, often incorporating existing modeling languages and methodologies.

As noted in [4], tools that allow programmers to work at the algorithmic level rather than dealing with hardware organization and low-level optimization are required. Similar to classical computing, a complete life cycle of quantum computing tools, methods, and procedures must be provided.

A quantum programming environment is described in [5], consisting of a platform that includes a compiler of the quantum while-language, together with tools for simulating quantum computation, optimizing quantum circuits, and analyzing and verifying quantum programs.

A survey of architectures and demands for software in quantum computing is provided in [6], while quantum model development architectures are systematically reviewed in [7], including architecture-centric solutions and emerging challenges.

Language-level extensions have also been proposed. For instance, [8] extends C++ with quantum operations for hybrid implementations, and [9] introduces Q#, an algorithm definition language in which the quantum program operates as a co-processor to the classical machine.

Another direction is quantum service-oriented computing [10], whose evaluation considers qubit count, number of shots, precision, response time, and cost.

Our proposed approach builds on these architectural, modeling, validation, and deployment requirements but also emphasizes analysis and verification. Petri Nets (PNs), widely used in classical software verification, are extended here to support quantum computing.

1.2. Dynamic Systems

A dynamic system (DS) consists of related elements (variables) whose relationships evolve over time. The term dynamic highlights continual or discrete changes, while dynamical emphasizes the study of such evolution. DS behavior can be mathematically modeled through variables and their interactions, governed by rules that describe state dependence on a parameter called time.

Time may be discrete ($\mathbb{Z}$), continuous ($\mathbb{R}$), complex ($\mathbb{C}$), or multi-dimensional subsets of ${\mathbb{R}}^n$. The collection of states defines the system’s state space, which may be discrete, continuous, or multi-dimensional. Rule application defines state transitions and, over multiple applications, system evolution. Rules may involve fixed or time-dependent parameters.

Some characteristics of DSs are the following:

• Time dependence: State change across time.
• State variables: Internal conditions at a given time.
• Inputs: External influences on system behavior.
• Outputs: Measurable indicators of system evolution.

From these, DSs can be classified as

• Continuous-time DSs (variables change continuously);
• Discrete-time DSs (variables change at fixed intervals);
• Discrete-event DSs (variables change asynchronously);
• Deterministic DSs (future states precisely predictable);
• Stochastic DSs (behavior described by probabilities);
• Random DSs (state changes unpredictable in timing or magnitude).

DSs may be linear, non-linear, time-invariant, or time-variant. Non-linear systems violate the superposition principle, which complicates the implementation of quantum systems. A typical application is closed-loop control, achieved through classical methods or AI-based approaches, such as reinforcement learning, supervised learning, unsupervised learning, and deep learning [11].

DSs can be simple [12] or composed of more DSs, resulting in dynamic systems of systems [13].

A closed DS is typically modeled as

$$(\dots ,x(\tau -n),x(\tau -n-1),\dots ,x(\tau -1),x(\tau \left)\right)\to x(\tau +1),$$

(1)

where $x\left(\tau \right)\in X$ is the state at time $\tau \in \mathcal{T}$.

An open DS with an input $u\left(\tau \right)\in U$ is described by

$$(\dots ,x(\tau -n),x(\tau -n-1),\dots ,x(\tau -1),x(\tau ),u(\tau \left)\right)\to x(\tau +1).$$

(2)

There are many models for DSs dependent on their characteristics. The current approach focuses on a class of models that have a graphical representation and are derived from Petri Nets (PNs).

Classical Hybrid Petri Nets (CHPNs) are composed of discrete and continuous Petri Nets (ContPNs) [14]. QPNs have different features compared with ContPNs. There is no structural difference between QPNs and ContPNs, but the assigned mappings are different. Thus, the algorithms they can model are different. The transition admissibility is also different. Conclusion: DQCPNs differ significantly from CHPNs.

Goal and justification of the current research study: Dynamic systems (DSs) need space–time representation. This means that DS models need a kind of memory feature to store their state values for their implementation. Classical tasks must interact with the execution of quantum tasks for the proper implementation of quantum-centric applications.

Applications of DSs include modeling, identification, control, and forecasting, among others [15]. They are widely used for scientific research, engineering, financial markets, psychology, etc. [16].

1.3. Quantum Computation Related to Dynamic Systems

Wharton [17] describes several features of quantum computing (QC) that conflicts with the requirements of DSs:

• No-cloning principle: A general quantum state (unlike some particular quantum states) cannot be copied.
• All at Once (A@O) executions: Suitable for static systems but less appropriate for DSs.
• No-go theorem: Ruling out local hidden-variable models.
• Lack of synchronization: It complicates the enforcement of state-precedence relations.

Another challenge is the difficulty of implementing quantum memory, which is essential to DS simulations and critical in fields such as AI and optimization [18].

To address some of these limitations, Lattner et al. [19] introduced MLIR, a reusable and extensible compiler infrastructure that supports software fragmentation, heterogeneous compilation, and the integration of domain-specific compilers. Similarly, ref. [20] presents an intermediate representation (IR) framework for quantum programs that verifies the no-cloning principle at compile time and performs redundancy and dead-code elimination.

Although quantum computing supports parallelism, many DS applications require execution of concurrent tasks assequences of quantum operations that preserve precedence relations.

A general and comprehensive theory for non-computability or non-approximability for optimization problems in general settings is developed in [21]. Many such problems are formulated as minimization or maximization of some functional $F:X\times Y\to \mathbb{R}$ over a solution space $X\subset {\mathbb{R}}^n$ and a parameter space $Y\subset {\mathbb{R}}^m$ for $n,m\in \mathbb{N}$:

$${\displaystyle \underset{y\in Y;x\in X\left(y\right)}{\max }\left\{F(x,y)\right\};or\underset{y\in Y;x\in X\left(y\right)}{\min }\left\{F(x,y)\right\}.}$$

(3)

Here, the parameter y can play the role of time for the quantum program, while $X\left(y\right)$ models the solution space determined by time. Details, relations, and theorems can be found in the reference mentioned above. Two main problems are emphasized in [21], as presented below.

Find the extreme of the function $f:Y\to \mathbb{R}$:

$${\displaystyle \forall y\in Y:f\left(y\right)=\underset{y\in Y;x\in X\left(y\right)}{\max }\left\{F(x,y)\right\};or\underset{y\in Y;x\in X\left(y\right)}{\min }\left\{F(x,y)\right\}.}$$

(4)

Find a function $G:Y\to X$ such that

$$\forall y\in Y:f\left(y\right)=F\left(G\right(y),y).$$

(5)

2. Quantum Computing

According to [22], the computational space in quantum computing is richer than in classical computing. Classical computation is based on bits, which take values in $\{0,1\}$. The state space defined by n bits has a size of $2^n$. Dynamic system (DS) problem solving often requires steering a system toward desired states, yet this is challenged by the no-cloning theorem. The central difficulty lies in determining a quantum gate sequence that transforms an initial state into a target state with minimal error.

Quantum computation can be implemented using qubits (discrete variables) or qumodes (continuous variables). Repeated measurements (“shots”) on qubits can provide statistical approximations to continuous-variable behavior.

2.1. Discrete Qubits

Discrete qubits are defined on the basis $\left\{\right|0\rangle ,|1\rangle \}$, forming Hilbert vectors of dimension n in the computational basis $\left\{\right|0\rangle ,|1\rangle ,\cdots ,|n\rangle \}$. A discrete qubit in Hilbert space is described as

$$|\Psi \rangle ={\displaystyle \sum _{k=0}^{n-1}}{c}_k|q_k\rangle$$

(6)

with $c_k\in \mathbb{C}$ satisfying ${\sum }_{k=0}^{n-1}\left|\right|c_i{\left|\right|}^2=1.$ In most cases, the vectors $|q_k\rangle$ are chosen from the computational basis.

Unitary matrices perform operations on discrete qubits. Measurements collapse qubit states into classical basis states, and multiple shots yield empirical probabilities that approximate a continuous distribution.

A unitary transformation of an initial state $|{\Psi }_0\rangle$ is written as

$$|\Psi \rangle =U|{\Psi }_0\rangle .$$

(7)

A single-qubit logic gate is a $2\times 2$ matrix. For example, the Hadamard (or diffusion) matrix

$$H={\displaystyle \frac{1}{\sqrt{2}}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]$$

(8)

acting on $|b\rangle ={\alpha }_0|0\rangle +{\beta }_0|1\rangle$ produces $|b^{\prime }\rangle ={\displaystyle \frac{1}{2}}({\alpha }_0+{\beta }_0)|0\rangle +{\displaystyle \frac{1}{2}}({\alpha }_0-{\beta }_0)|1\rangle$, which preserves normalization. Any composition of gates must yield a unitary matrix to ensure this property.

The qubit information is stored as a two dimensional vector $[\alpha ,\beta ]$, while the m qubit Hilbert vector is stored as an $n=2^m$ dimensional vector $[c_0,c_1,\cdots ,c_{n-1}]$.

The identity matrix is denoted by I, while the Pauli operators X and Z are

$$X=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right],$$

(9)

$$Z=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right].$$

(10)

Parameterized Quantum Circuits (PQCs) [23] introduce variational parameters $\theta$, producing states of the form

$$|\Psi \left(\theta \right)\rangle =U\left(\theta \right)|{\Psi }_0\rangle .$$

(11)

For example, a qubit rotation is given by

$$R\left(\theta \right)=\left[\begin{array}{cc}cos\left(\theta \right)& -sin\left(\theta \right)\\ sin\left(\theta \right)& cos\left(\theta \right)\end{array}\right].$$

(12)

Such relations between Hilbert vectors and unitary operators can be modeled naturally by Quantum Petri Nets (QPNs) [24,25].

2.2. Qumodes

Continuous-variable quantum states, or qumodes, evolve in Fock space, defined as the direct sum of Hilbert spaces representing zero-, one-, two-particle states, and so on [22,26]. A correspondence between qubit- and qumode-based quantum computing is included in [27]. While a qubit state is expressed as $\left\{\right|0\rangle ,|1\rangle \}$, a qumode uses the continuous basis ${\left\{\right|q\rangle \}}_{q\in \mathbb{R}}$ with $|\Psi \rangle =\int dq·c(q\left)\right|q\rangle$.

Formally, the Fock space is

$$F_{\nu }\left(H\right)={\displaystyle \underset{n=0}{\overset{\infty }{⨁}}}{S}_{\nu }{H}^{\otimes n}.$$

(13)

with $S_{\nu }$ being an operator for tensor symmetrization or unsymmetrization.

A qumode state is

$$|\Psi \rangle ={\displaystyle \sum _{k=0}^{\infty }}{c}_k|q_k\rangle$$

(14)

with ${\sum }_{k=0}^{\infty }{\left|c_i\right|}^2=1.$

For m qumodes,

$$|{\Psi }_0\rangle \otimes |{\Psi }_1\rangle \otimes \cdots \otimes |{\Psi }_{m-1}\rangle .$$

(15)

Because infinite expansions are impractical, a cutoff $n_c$ is introduced:

$$|\widehat{\Psi }\rangle ={\displaystyle \sum _{k=0}^{n_c-1}}{c}_k|q_k\rangle$$

(16)

with ${\sum }_{k=0}^{n_c-1}{\left|c_i\right|}^2=1$. The qumode is stored as

$$qm={[c_0,c_1,\cdots ,c_{n_c-1}]}^T.$$

(17)

With m qumodes and cutoff $n_c$, the state space has dimension $n_c^m$. Operations are represented by $n_c^m\times n_c^m$ Gaussian operators.

A system comprising m qumodes, each truncated to a cutoff dimension $n_c$, is described by a state vector residing in a Hilbert space of dimension $n_c^m$. The operators acting on this space are represented by $n_c^m\times n_c^m$ matrices, which typically implement Gaussian transformations for the standard continuous-variable gate set.

Fundamental operations on a single qumode include rotation or phase shift, position displacement, momentum displacement, and squeezing [26,28]. These transformations are defined using the bosonic annihilation $\widehat{a}$ and creation ${\widehat{a}}^{†}$ operators, whose matrix representations in the Fock basis are given by:

$$\widehat{a}=\left[\begin{array}{cccccc}0& \sqrt{1}& 0& \cdots & 0& 0\\ 0& 0& \sqrt{2}& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & \sqrt{n_c-2}& 0\\ 0& 0& 0& \cdots & 0& \sqrt{n_c-1}\\ 0& 0& 0& \cdots & 0& 0\end{array}\right],$$

(18)

$${\widehat{a}}^{†}=\left[\begin{array}{cccccc}0& 0& 0& \cdots & 0& 0\\ \sqrt{1}& 0& 0& \cdots & 0& 0\\ 0& \sqrt{2}& 0& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 0& 0\\ 0& 0& 0& \cdots & \sqrt{n_c-1}& 0\end{array}\right].$$

(19)

The number operator, ${\widehat{n}}_c={\widehat{a}}^{†}·\widehat{a}$, is consequently a diagonal matrix whose entries correspond to the photon numbers

$${\widehat{n}}_c=\left[\begin{array}{cccccc}0& 0& 0& \cdots & 0& 0\\ 0& 1& 0& \cdots & 0& 0\\ 0& 0& 2& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & n_c-2& 0\\ 0& 0& 0& \cdots & 0& n_c-1\end{array}\right].$$

(20)

This operator satisfies the eigenvalue equation ${\widehat{n}}_c|k\rangle =k|k\rangle$ for Fock state $|k\rangle$.

The canonical position ($\widehat{q}$) and momentum ($\widehat{p}$) operators are derived from the annihilation and creation operators:

$$\widehat{q}={\displaystyle \frac{1}{\sqrt{2}}}(\widehat{a}+{\widehat{a}}^{†}),$$

(21)

$$\widehat{p}={\displaystyle \frac{1}{i\sqrt{2}}}(\widehat{a}-{\widehat{a}}^{†}).$$

(22)

These operators define the phase space and obey the canonical commutation relation $[\widehat{q},\widehat{p}]=i\hslash \widehat{\mathbb{I}}$, where ℏ (Plank’s constant) is often set to 2 in this context.

A phase space rotation by an angle $\theta$ is generated by the number operator and is represented by the unitary matrix

$$R\left(\theta \right)=\left[\begin{array}{cccccc}1& 0& 0& \cdots & 0& 0\\ 0& exp\left[i\theta \right]& 0& \cdots & 0& 0\\ 0& 0& exp\left[i2\theta \right]& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & exp\left[i(n_c-2)\theta \right]& 0\\ 0& 0& 0& \cdots & 0& exp\left[i(n_c-1)\theta \right]\end{array}\right].$$

(23)

Using the relation $e^{i\theta }=cos\left(\theta \right)+i·sin\left(\theta \right)$, the rotation result of $qm$ can be calculated.

Displacement in phase space by a complex amplitude $\alpha$ is achieved by the operator

$$D\left(\alpha \right)=exp[\alpha \widehat{a}-{\alpha }^{*}{\widehat{a}}^{†}].$$

(24)

The squeezing operation, which reduces the variance of one quadrature at the expense of the other, is parameterized by a squeezing factor r and an angle $\theta$:

$$S(r,\theta )=exp\left[{\displaystyle \frac{r}{2}}(e^{-i\theta }{\widehat{a}}^2-e^{i\theta }{\widehat{a}}^{†2})\right].$$

(25)

According to [29], a practical and computationally efficient method for implementing a rotation by $\theta$ in the phase space of the quadrature operators is the linear transformation

$$\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]\to \left[\begin{array}{cc}cos\left(\theta \right)& -sin\left(\theta \right)\\ sin\left(\theta \right)& cos\left(\theta \right)\end{array}\right]·\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right].$$

(26)

Displacement along the position or momentum quadrature corresponds to the translations

$$\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]\to \left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]+\left[\begin{array}{c}s\\ 0\end{array}\right],$$

(27)

$$\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]\to \left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]+\left[\begin{array}{c}0\\ s\end{array}\right].$$

(28)

Squeezing (by a factor s) transformations scale the quadratures according to

$$\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right]\to \left[\begin{array}{cc}s& 0\\ 0& 1/s\end{array}\right]·\left[\begin{array}{c}\widehat{q}\\ \widehat{p}\end{array}\right].$$

(29)

For systems with multiple qumodes, a fundamental two-mode operation is the beamsplitter transformation, which couples modes i and j:

$$BS(\eta ,\theta )=exp[\eta (e^{i\theta }{\widehat{a}}_i·{\widehat{a}}_j^{†}-e^{-i\theta }{\widehat{a}}_i^{†}·{\widehat{a}}_j].$$

(30)

Complex multi-qumode circuits, such as interferometers, can be constructed from networks of these basic elements (beamsplitters and phase shifters). These networks implement unitary transformations that preserve the Gaussian character of the input states [26]. Methods also exist for designing control sequences to steer a qumode system towards a desired target state [30].

Qumode measurement schemes are broadly classified into Gaussian and non-Gaussian strategies [31]. Gaussian measurements include the following:

• Homodyne detection: This technique measures a generalized quadrature observable, ${\widehat{q}}_{\Phi }=cos(\Phi )\widehat{q}+sin(\Phi )\widehat{p}$, which is the eigenbasis of a Hermitian operator. The measurement projects the state onto $|q_{\Phi }\rangle$ with outcome $q\in \mathbb{R}$.
• Heterodyne detection: This method performs a simultaneous albeit noisy measurement of both conjugate quadratures, $\widehat{q}$ and $\widehat{p}$. It projects onto coherent states $|q\rangle$ with outcomes $\alpha \in \mathbb{C}$.

The primary non-Gaussian measurement is the following:

• Photon counting: This approach reveals the particle-like aspect of the field by projecting onto the number state basis $\left\{\right|n\rangle \}$, yielding integer-valued outcomes $n\in \mathbb{N}$.

For both single- and multi-qumode states, experimental results can be processed to extract expectation values, variances, or full probability distributions, providing outcomes over a continuous domain [28].

2.3. Artificial Intelligence Related to Quantum Computing

The requirements of DSs concern stabilizing or leading them to a target state or around it. When the DS is disturbed, it must return to the target state or follow a desired trajectory. Some specifications of DSs require reactions to different inputs, considered control demands (i.e., control signals) or disturbances. Subjects in the DS field include modeling, synthesis, identification, or control. Such kinds of DSs can be obtained by finding some system’s fixed parameters, dynamically changing the parameters provided by functions, or finding control reactions to internal or external events. Optimization of DSs can be performed offline or online. Some offline optimization methods include the search for fixed parameters that lead the systems to target states or around a specified state. Online optimization methods involve continuously changing specific parameters to improve DS behaviors or discovering new reaction rules.

The problem of controlling a dynamic system when the state cannot be directly measured and the control performance metrics are unknown or only partially known is solved in [32].

A domain where quantum computing is expected to achieve great success against classical computing is machine learning and artificial intelligence [11]. Both optimization and machine learning, which are involved in quantum computing, require the repeated execution of specific models. Using artificial neural networks, support vector machines, rule-based systems, etc., machine learning (supervised, unsupervised, deep learning, and reinforcement learning) can solve iteratively the above-presented optimization problems. The procedures have to implement a functional F model, a cost function, and a decision maker for search improvement. These can be solved on a quantum-centric implementation, deciding which parts are implemented on QCs (quantum computers) and which on CCs (classical computers) [2,23].

Some qubits at arbitrary locations are connected with a real-time classical connection, creating the statistics of entanglement through quasiprobability decomposition (QPD) [33].

The fluid dynamics problem is considered purely classical, where the hardness stems from the need to solve non-linear differential equations [34]. A high-level diagram of a hybrid quantum–classical training algorithm for variational circuits is described here.

General heuristic optimization methods are used for their few and weak requirements concerning the process models. Some of them are bio-inspired, and others are based on physical concepts. The current approaches use Genetic Algorithms (GAs) and Particle Swarm Optimization (PSO).

There are evolutionary methods that solve combinatorial problems involving a finite state space [35,36]. Some approaches solve static optimization problems by using a continuous space [37].

In [24], a quantum method that solves discrete dynamic optimization problems in a finite state space is presented.

2.4. Current Research State of the Field

Quantum programs are often modeled and implemented by quantum logic gates or by unitary matrices in Hilbert spaces. A set of quantum logic gates composes a quantum logic circuit. Any quantum logic circuit can be described by a unitary matrix.

Unitary matrices can perform any quantum logic gate or any quantum logic circuits. Any unitary matrix can be implemented by a set of available quantum logic gates or it can be approximated with a specified precision by a set of available gates of a Quantum Processor Unit (QPU).

According to [38], quantum dynamic systems contain more information than the original classical system. The classical DS is linked to a QC presentation using the density of probability.

Wharton et al. (2011) use timed unitary operators and compose sequences of such operators to describe dynamic system evolution [39].

Liu et al. (2023) proposed quantum memory avoiding the quantum no-cloning theorem (principle) effect involved in reading and writing processes (which cannot copy information), realizing this by using quantum operations [18].

Quantum Petri Net (QPN) models were introduced for describing and solving some quantum computing problems in [24,25,40]. A QPN version linking quantum events semantics and quantum software is introduced in [41].

Recently, a quantum buffer was designed using Petri Net models [42].

In [43], the modeling and analysis of quantum applications are performed using Colored Petri Nets.

In [44], Object Enhanced Time Petri Net (OETPN) modeling techniques were used for complex problems of classical software engineering.

Our previous research showed capabilities and benefits of Quantum Petri Nets (QPNs) in modeling quantum programs or conceiving models for classical program construction inspired by quantum computation. So, the collaboration between OETPNs, which sustain the development of classical object-oriented programs, and QPNs, which are used for quantum program development, can lead to software platforms with capabilities derived from both [24].

In [45,46], distributed quantum applications are implemented based on cooperation between quantum and classical computing. A circuit representation of the quantum teleportation process, sending quantum information from a source to a destination, is performed using some quantum logic gates. In the current article, a model for this process combining QPNs and OETPNs is proposed. The result of sending an information qubit from Quantum Processing Unit 1 ($QP{U}_1$) to $QP{U}_2$ is shown in Figure 1.

The circles represent PN places that correspond to state elements. The information assigned to places composes the PN marking that models the state of the system. The transitions model the system’s state changes performed by the assigned operations. Filled rectangles represent quantum operations, while empty rectangles correspond to classical operations. Places $p_6,p_{o0}$, and $p_{o1}$ are classical, while the rest of the places are quantum. Places $p_5$ and $p_5^{\prime }$ model measurements of quantum places $p_4$ and $p_4^{\prime }$, respectively.

The vector information to send is $|{\Psi }_1\rangle =\alpha |0\rangle +\beta |1\rangle$, and the Bell state is $|{\Phi }^{+}\rangle =a|00\rangle +b|11\rangle$.

They are used for the transition mappings providing the vectors

$$t_1:|{\Psi }_2\rangle =I|{\Psi }_1\rangle ;|{\Phi }_2\rangle =X|{\Phi }^{+}\rangle ;|{\Psi }_1\rangle =|{\Psi }_1\rangle ,$$

(31)

$$t_2:|{\Psi }_2\rangle =I|{\Psi }_1\rangle ;|{\Phi }_2\rangle =X|{\Phi }^{+}\rangle ,$$

(32)

$$t_3:|{\Psi }_3\rangle =H|{\Psi }_3\rangle ;|{\Phi }_3\rangle =X|{\Phi }_2\rangle .$$

(33)

The previous model of teleportation can be reduced by joining sequential transitions. The simplified version is represented in Figure 2. The two entangled states stored in $p_2$ and $p_2^{\prime }$ containing the vector $|{\Phi }^{+}\rangle$ are used as support for teleportation of the vector $|{\Psi }_1\rangle$ stored in $p_1$. The system relevant initial state is given by the marking $(M\left(p_1\right),M\left(p_2\right),M\left(p_2^{\prime }\right))=\left(\right|{\Psi }_1\rangle ,|{\Phi }^{+}\rangle ,|{\Phi }^{+}\rangle )$. Almost instantly, the quantum system state becomes $(M\left(p_1\right),M\left(p_2\right),M\left(p_2^{\prime }\right),M\left(p_3\right),M\left(p_3^{\prime }\right))=\left(\right|{\Psi }_1\rangle ,|{\Phi }^{+}\rangle ,|{\Phi }^{+}\rangle ,|{\Psi }_3\rangle ,|{\Phi }_3\rangle ,|{\Phi }^{+}\rangle )$, but only after the execution of the classical transition $t_m$ and the sending of the classical bits to $QP{U}_2$, the vector $|{\Psi }_1\rangle$ is teleported. The teleportation is consistent only if the classical transmission is performed during the coherence time interval of $QP{U}_2$.

Table 1. Node significance of Figure 1 model.

Node	Token	Operation	Dimension	Domain	Significance
$p_0$	$|{\Phi }^{+}\rangle$	-	2	Quantum	Bell state
$t_0$	-	entangle	$2+2$	Quantum	Teleportation
$p_1$	$|{\Psi }_1\rangle$	-	2	Quantum	To send
$p_2$	$|{\Phi }^{+}\rangle$	-	2	Quantum	Entangled state
$t_1$	-	$U_1=(I,XOR)$	$2\times 2,2\times 2$	Quantum	Multiplication
$p_3$	$\left(\right|{\Psi }_3\rangle ,|{\Phi }_3\rangle )$	$|{\Psi }_1\rangle XOR|{\Phi }^{+}\rangle$	$2,2$	Quantum	Composition
$t_2$	-	$U_2=(H,I)$	$2\times 2,2\times 2$	Quantum	Rotation
$p_4$	$\left(\right|{\Psi }_4\rangle ,|{\Phi }_4\rangle )$	-	$2,2$	Quantum	Rotation
$t_3$	-	measurement	$2,2$	Mixed	Conversion
$p_5$	$(b_0,b_1)$	-	2, 2	Classical	Vector
$t_4$	-	store	(2, 2)	Classical	Memory
$p_6$	$(b_0,b_1)$	-	$2,2$	Classical	2 bits
$t_5$	-	transmission	$2+2$	Classical	Teleportation
$p_2^{\prime }$	$|{\Phi }^{+}\rangle$	-	2	Quantum	Entangled state
$t_1^{\prime }$	-	I	$2\times 2$	Quantum	Copy
$p_3^{\prime }$	$|{\Phi }^{+}\rangle$	-	2	Quantum	Entangled state
$t_2^{\prime }$	-	$if{b}_0$ then X	$2\times 2$	Mixed	Controlled
$p_4^{\prime }$	$|{\Phi }_x\rangle$	-	2	Quantum	Rotated state
$t_3^{\prime }$	-	$if{b}_1$ then Z	$2\times 2$	Mixed	Controlled
$p_5^{\prime }$	$|{\Psi }_1\rangle$	-	2	Quantum	Received

shows the meanings and sizes of nodes and the involved operations for the QPN model shown in Figure 2.

The bidirectional communication between $QP{U}_1$ and $QP{U}_2$ is shown in Figure 3. This model performs $|{\Psi }_{13}\rangle =F_1\left(\right|{\Psi }_{11}\rangle ,|{\Psi }_{21}\rangle )$ and $|{\Psi }_{23}\rangle =F_2\left(\right|{\Psi }_{21}\rangle ,|{\Psi }_{11}\rangle )$.

The double communication is timed by classical transitions $t_{13}$ and $t_{23}$, which include the qubit measurements and their transmissions.

Places $p_{e1}$ and $p_{e2}$ model quantum communications channels denoted by $e_1$ and $e_2$, respectively. Places $p_{c1}$ and $p_{c2}$ model classical channels $c_1$ and $c_2$, respectively. They control the behavior of quantum gates modeled by transitions $t_{14}$ and $t_{24}$.

2.5. Analysis and Verification of Quantum and Classical Petri Nets

PNs are bipartite oriented graphs composed of nodes that model the states (represented by places) and their changes (described by transitions). Classical tasks are implemented by digital bits and classical logic circuits that execute logic or arithmetic operations.

Usually, quantum applications are composed of cooperating classical and quantum tasks. Classical tasks solve the user interface, set the quantum task parameters, and control the start and measurements of the quantum tasks. Quantum tasks implemented by discrete variables (i.e., qubits) or continuous variables (i.e., qumodes) change the physical process states by quantum circuits executing quantum operations. Concentrated or distributed quantum tasks evolve at a much higher speed relative to their counterpart classical components.

Verification and analysis of PNs are often performed by Petri Net-based Language and reachability graphs. These methods were used in the current research study.

The behavior of Classical or Quantum Petri Nets, as well as the relations between these two kinds of PNs, must be analyzed and verified.

Petri Net-Based Language (PNL)

This method describes the execution of parallel, sequential, and concurrent transitions. It can also be used for Classical PNs or Quantum PNs. Using the notations “*” for sequence, “+” for alternative, $“\&”$ for concurrence, and $“\#”$ for closing a loop, the behavior of a PN can be described. For example,

• $t_1\ast t_2$ describes the sequential execution of transitions $t_1$ and $t_2$;
• $t_1+t_2$ describes the alternative for executing transition $t_1$ or $t_2$;
• $t_1\&t_2=t_1\ast t_2+t_2\ast t_1$ describes concurrent execution;
• $(t_1\ast t_2)\#t_3$ describes a loop $\sigma =(t_1\ast t_2\ast t_3)\ast \sigma$.

Details of their use are provided in [47,48]. PNL can be extended for Enhanced Time Petri Nets (ETPNs) obtaining a language (ETPNL) capable of describing dynamic open system behavior.

DQCPNs include quantum task models and classical task models that behave in different domains and interact through clearly defined and modeled frontiers separating them. Both kinds of tasks are modeled by PN-based templates. PN-based Language can describe concurrency and can be used to determine the precedence relations. Enhanced (Time) PN-based Language can include input events and signal output events linked to their frontiers.

Enhanced (Time) Petri Net-based Language can be defined in the following manner: Time is a classical task feature, while quantum tasks lack it, so EPNL notation should be used for quantum program description. The precedence notation corresponding to transitions is endowed with two parameters, $e_i$ and $e_o$, representing external input and output events, respectively, becoming $t(e_i,e_o)$. These events are included in quantum or classical places according to the specification. When one or both events are missing, this is marked by the symbol “-”.

For example, the model shown in Figure 3 can be described by the sequences

$${\sigma }_1=t_{11}(-,e_1)\ast t_{14}(c_1,-),$$

(34)

$${\sigma }_2=t_{21}(e_{2}i,e_1)\ast t_{14}(c_2,-).$$

(35)

The entanglement sequence is

$$t_0(e_1.e_2)\&t_0(e_2,e_1).$$

(36)

Transitions $t_{13}$ and $t_{23}$ are externally controlled without the controls represented in Figure 3. Classical transitions can be delayed by clock ticks, which are kinds of external time input events.

2.6. Reachability Graphs

The execution of transitions changes the states of classical and quantum components. The Classical or Quantum PNs states are represented by markings. Reachability graphs are used to determine the markings that can be reached during program execution. A reachability graph analysis approach can be used to determine and enforce the desired control requirement for a composed classical quantum model.

Some sequences of transitions provide cyclic behaviors, while others determine acyclic behaviors. The interface(s) between classical and quantum tasks creates a frontier that must be analyzed for quantum-centric application verification.

Unlike bounded numerical PNs, where the state numbers are finite, the current approach involves infinite numbers of states for classical and quantum parts. As a consequence, the term state label is more appropriate for the reached markings than reached states.

In qubit implementation, the state is considered its probability on the basic axis. In qumode implementation, the physical state is defined by the photons’ position and momentum. The vector $|\Psi \rangle$ is used as the quantum program state, a replacement of the real physical state.

3. Materials and Methods

Distributed quantum-centric applications are composed of classical parts and quantum parts. In the current approach, the classical parts are modeled by OETPNs and the quantum parts by QPNs. All components must cooperate to fulfill the specifications and the requirements of the application.

3.1. Parameterized Quantum Circuits (PQCs)

A unitary matrix $U\left(\theta \right)$ can be parameterized by a parameter $\theta$ [23]. This performs the relation

$$|\Psi \left(\theta \right)\rangle =U\left(\theta \right)|{\Psi }_0\rangle$$

(37)

A classical part of a quantum-centric computing program provides the parameter $\theta$. The model shown in Figure 4 starts from the initial quantum state $M\left(p_0\right)=|{\Psi }_0\rangle$ and the classical state $M\left(p_1^c\right)={\theta }_0$.

Typically, $|{\Psi }_0\rangle$ is the initial state obtained from n qubits, each in state $|0\rangle$, forming the product state $|00\cdots 0\rangle$. In some cases, the required initial state is obtained by multiplying by a unitary matrix.

Changing the variational parameters while a QPU executes a quantum program modifies its quantum state.

The quantum part state is $[M\left(p_0\right),M\left(p_1\right),M\left(p_2\right)]$. When the quantum program begins, its state changes instantly to $\left[\right|{\Psi }_0\rangle ,|{\Psi }_1\rangle ,|{\Psi }_2\left({\theta }_0\right)\rangle ]$. The mapping $ma{p}_{1-0}=I$ reloads place $p_0$ with the initial value in an ideal QPU (with I being the identity matrix). In a real QPU, however, noise leads to the relation $|{\Psi }_0\rangle =U_I\left(\zeta \right)|\Psi \rangle$, where $\zeta$ represents the noise effect in time and $U_I\left(\zeta \right)$ is the practical approximation of the resulting unitary matrix that replaces the ideal I matrix. If the quantum program interacts with a classical program, their interaction must occur within the quantum fidelity period.

The execution of classical transition $t_1^c$ results in

$$\left[\right|{\Psi }_0\rangle ,|{\Psi }_1\rangle ,|{\Psi }_2\left({\theta }_0\right)\rangle ]\to \left[\right|{\Psi }_0\rangle ,|{\Psi }_1\rangle ,|{\Psi }_2\left(\theta \right)\rangle ].$$

(38)

The execution of $t_2^c$ before $t_1^c$ provides the measurement v of $|{\Psi }_2\left({\theta }_0\right)\rangle$. Conversely, if $t_1^c$ is executed first, the measurement of $|\Psi (\theta )\rangle$ is provided.

As was shown, a quantum program model can describe the joining of qubit vectors (e.g., transitions $t_{11}$ or $t_{21}$ in Figure 3) or split the qubit vector (e.g., transitions $t_{14}$ and $t_{13}$ or $t_{24}$ and $t_{23}$ in Figure 3). The split qubits (or vectors) can be measured separately during quantum program execution. Consequently, the place sizes or the token sizes that can be set in a place may vary depending on the developer’s needs.

3.2. QPN Models with Qumodes

Our earlier QPN models were based on discrete qubits in Hilbert space. In these models, places store quantum states using V vectors of dimension m and/or $|\Psi \rangle$ vectors of dimension $2^m$. State evolution is modeled by transitions performing unitary operations either on individual qubits or collectively on multiple qubits.

The current approach extends the previous definition of QPNs to include one or both types of quantum variables: discrete qubits and qumodes. The V vectors can consist of qumodes or, collectively, multi-qumodes. In this case, Hilbert space is replaced by Fock space, and the unitary operations are adjusted accordingly. As mentioned earlier, cutoff dimensions $n_c$ must be introduced, which set the size of multi-qumodes to $n_c^m$.

The equivalent qubit parameterized unitary matrix for a qumode can be obtained by a sequence of displacement and rotation $D\left(\alpha \right)\ast R\left(\theta \right)$.

The overall structure of QPN models remains the same, as do the sequences of transitions describing the evolution. In the case of discrete qubits, measurement often requires multiple shots, whereas for qumodes, a single shot is sufficient.

3.3. Temporal Analysis of DQCPN Model

A temporal analysis should verify the state changes of the quantum program in relation to its interaction with the classical program. Consider the double communication program shown in Figure 3. The initial states of $QP{U}_1\&QP{U}_2$ are

$$\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_1\rangle ,|{\Psi }_{12}\rangle ,|{\Psi }_{13}\left({\theta }_2^0\right)\rangle ];\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_2\rangle ,|{\Psi }_{22}\rangle ,|{\Psi }_{23}\left({\theta }_1^0\right)\rangle ].$$

(39)

According to the Classical Petri Net principle of atomic transitions, transitions $t_{13}$ and $t_{23}$ cannot occur simultaneously. They are concurrent; therefore, their corresponding events are ordered by the “happen before” relation represented by $“\to ”$: either $t_{13}\to t_{23}$ or $t_{23}\to t_{13}$. The QPN reachability graph contains the states

$$\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_1\rangle ,|{\Psi }_{12}\rangle ,|{\Psi }_{13}\left({\theta }_2^1\right)\rangle ];\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_2\rangle ,|{\Psi }_{22}\rangle ,|{\Psi }_{23}\left({\theta }_1^0\right)\rangle ],$$

(40)

and

$$\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_1\rangle ,|{\Psi }_{12}\rangle ,|{\Psi }_{13}\left({\theta }_2^0\right)\rangle ];\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_2\rangle ,|{\Psi }_{22}\rangle ,|{\Psi }_{23}\left({\theta }_1^2\right)\rangle ],$$

(41)

before reaching the final state

$$\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_1\rangle ,|{\Psi }_{12}\rangle ,|{\Psi }_{13}\left({\theta }_2^1\right)\rangle ];\left[\right|{\Phi }^{+}\rangle ,|{\Psi }_2\rangle ,|{\Psi }_{22}\rangle ,|{\Psi }_{23}\left({\theta }_1^2\right)\rangle ].$$

(42)

Both measuring events must occur within the fidelity periods of the QPUs to ensure computational correctness.

The partial ordering involved in entanglement in quantum programs can be determined by inference of EPNL relations. So, the construction of reachability graphs can be obtained under the constraints given by EPNL. Due to the entanglement requirement, the constraint $t_{13}\to t_{23}$ must be implemented for Figure 3.

A quantum-centric program consists of a QPN and a Classical Petri Net, modeled here by OETPN. The interface between the QPN and the OETPN includes classical control places and classical measurement places.

3.4. QPN Definition

Figure 5 illustrates a QPN model composed of four places and a transition. The places represented by circles model the system state described either by a Hilbert vector denoted by $|\Psi \rangle$ or by an array of qubits or qumodes denoted by V, as shown in Figure 6.

A vector $V=\left[\right|q_0\rangle ,|q_1\rangle ,\cdots ,|q_{m-1}\rangle ]$ can be converted into the corresponding vector $|\Psi \rangle$ by the relation

$$|\Psi \rangle =|q_0\rangle \otimes |q_1\rangle \otimes \cdots \otimes |q_{m-1}\rangle .$$

(43)

System change is performed by transitions, denoted here by $t_k$, which modify the states of the system. When particular qubits or qumodes of a vector are involved, the corresponding mappings are marked on the arcs. A descriptive representation can be seen in Figure 7.

If the detailed relations performed on qubits or qumodes composing a vector V are

$$|q_0^{\prime }\rangle =U_0|q_0\rangle ,|q_1^{\prime }\rangle =U_1|q_1\rangle ,\cdots ,|q_{m-1}^{\prime }\rangle =U_{m-1}|q_{m-1}\rangle ,$$

(44)

these lead to a new vector $V^{\prime }$. The corresponding vector $|{\Psi }^{\prime }\rangle$ can be directly determined by a composed unitary matrix U given by

$$U=U_0\oplus U_1\oplus \cdots \oplus U_{m-1}.$$

(45)

When the unitary matrices depend on parameters, they can be provided by control places. For example, a rotation angle $\theta$ may be used in a unitary matrix through sine and cosine functions, yielding $U\left(\theta \right)$.

In this approach, the mappings multiply the input tokens stored in the transition input places by unitary matrices. More details are given in [24].

The formal definition of $QPN$ is

$$QPN=(N,G,Inp,Out,Map,Q{M}^0,init,end,Q{M}^f)$$

(46)

where the following apply:

• N = (P, T, F) is a bipartite oriented graph (i.e., net with two disjoint sets of nodes).
• $P=\{p_1,p_2,...,p_m\}$ is a finite set of places, with $m\ge 1$.
• $T=\{t_1,t_2,...,t_n\}$ is a finite set of transitions, with $n\ge 1$.
• $F\subseteq P\times T\cup T\times P$ is the flow relation.
• $G=[g_1,g_2,\dots ,g_m]$ is a vector containing the sizes of the vectors $V_i(i=1,2,\dots ,m$) stored in the corresponding places; for qumodes, the cutoff dimensions must be included.
• $Inp=\{p_1^c,p_2^c,\dots \}$ is a set of input channels providing the parameters $\left(\theta \right)$ of unitary matrices.
• $Out=\{t_1^c,t_2^c,\dots \}$ is a set of output channels providing the measurements of some qubits.
• $Map$ is the set of mappings (i.e., pair $(map{\Psi }_k^v\left(\right),map{V}_k^v\left(\right))$) assigned to arcs linking the transitions with places; if one of them is missing, it is denoted by $null$.
• $Q{M}^0$ is a matrix with initialized values (i.e., the initial quantum superposed states).
• init is the initialization method.
• end is the stop method.
• $Q{M}^f$ is a matrix storing the values of the final quantum superposed state (i.e., the result matrix).

Some important relations related to QPNs are

• °t$=\{p\in P|(p,t)\in F\}$ describes the transition t input place set;
• $t^{\circ }=\{p\in P|(t,p)\in F\}$ describes the transition t output place set.

QPN tokens are quantum superposed vectors stored in places and transformed by transitions implementing unitary matrices. Let $|{\psi }_1\rangle ={\sum }_{i=0}^{r-1}{c}_i^1|q_i\rangle$ and $|{\psi }_2\rangle$ be two vectors in Hilbert space or Fock space. Then,

$$|{\psi }_2\rangle =A|{\psi }_1\rangle =A{\displaystyle \sum _{i=0}^{r-1}}{c}_i^1|q_i\rangle ={\displaystyle \sum _{i=0}^{r-1}}{c}_i^{1}A|q_i\rangle$$

(47)

Above, A is a matrix that generates a transformation of a quantum superposed state. $A{A}^{†}=A^{†}A=I$, where $A^{†}$ is the conjugate transpose of A. Such matrix A is called unitary. This property of A guarantees that the transformation $C_2^T=A·C_1^T$ with $C_i=[c_0^i,c_1^i,\dots ,c_{r-1}^i]$$(i=1,2)$ is valid. For simplicity reasons, only particular cases of unitary matrices are used in this work.

Similar quantum operations can also be defined for qumodes and multi-qumodes.

3.5. Quantum Tasks with Repeated Operation Execution

Figure 8 shows a theoretical QPN model that requires the periodic execution of operations $U_1$ and $U_2$, followed by transition $t_3$, which measures the state of $|{\Psi }_2\rangle$. The model contains conflicting transitions $t_2$ and $t_3$. The decision whether to continue the quantum process or to stop it and measure place $p_2$ is difficult to implement. Another challenge is to change the state of place $p_1$.

Until quantum technology permits the modification of a quantum register qubit (currently forbidden by the no-cloning principle), the model shown in Figure 9 can be used. The number of times n that the operations $U_1$ and $U_2$ are executed is fixed and predefined.

3.6. Quantum Iterative Task Execution

Some applications, like machine learning, require the iterative execution of quantum tasks with different parameters. Figure 10 displays a quantum task that executes the operations modeled by transitions $t_1$ and $t_3$ dependent by the parameters ${\theta }_1$ and ${\theta }_2$ set by a classical task. For a two-qubit register, an example of $U_2\left({\theta }_1\right)$ is

$$U_1\left({\theta }_1\right)=\left[\begin{array}{cccc}cos\left({\theta }_1\right)& -sin\left({\theta }_1\right)& 0& 0\\ sin\left({\theta }_1\right)& cos\left({\theta }_1\right)& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right].$$

(48)

This operation rotates the first qubit by an angle determined by the parameter used to set the QLC assigned to transition $t_1$. In an iterative execution, the parameters and the QLCs are set before the quantum task begins.

3.7. Distributed Quantum-Centric Petri Nets (DQCPN)

A DQCPN model consists of cooperating QPNs and OETPNs. A QPN has quantum places $P^Q$ and transitions $T^Q$, while an OETPN has classical places $P^C$ and transitions $T^C$. OETPN models can be distributed and implemented on a classical computer network, while QPNs can be distributed and implemented on a set of cooperating QPUs. OETPNs and QPNs can interact through quantum–classical interfaces:

$$DQCPN=(QPN,OETPN),$$

(49)

where

$$QPN=\{QP{N}_1,QP{N}_2,...,QP{N}_{qn}\},$$

(50)

$$OETPN=\{OETP{N}_1,OETP{N}_2,...,OETP{N}_{cn}\}.$$

(51)

Here $qn$ and $cn$ represent the numbers of QPU components and OETPN components, respectively.

The interface between two QPNs contains quantum transitions that implement entangled quantum places. Classical places and classical transitions compose the interfaces between two OETPNs. The frontier between a QPU and a classical computing component is represented by classical places, while the quantum–classical interface is implemented by measuring transitions of quantum places.

3.8. Quantum Processor Unit (QPU) Model

Figure 11 displays the generic template of a quantum task implemented on a Quantum Processor Unit. The node specifications are as follows:

• Input quantum places: $p_{i1}$ and $p_{i2}$.
• Output quantum places: $p_{o1}$ and $p_{o2}$.
• Internal initial places (corresponding to internal qubits): $p_0,p_1,\dots ,p_k,\dots$ Their type is quantum.
• Entangled qubits places: $p_{e1}$ and $p_{e2}$. Their type is quantum.
• Measured places (qubits): $p_{m1}$ and $p_{m2}$. Their type is classical vector.
• Control places: $p_{c0}$, $p_{c1}$, $p_{c2}$, and $p_{c3}$. Their type is classical vector. They can be used to set QLC parameters or for the selection of QLCs.
• Measurement control places: $p_{cs}$. There can be multiple classical measurement control places.
• Transition parameters: ${\theta }_0,{\theta }_1,{\theta }_2,$ and ${\theta }_3$. These determine the unitary matrices performed by transitions. They are classical vectors and define the types or behaviors of the involved unitary matrices.

Execution of a program built using this template is performed under the following assumptions:

• No noise is present; thus, the quantum process can last as long as necessary.
• Transitions are executed under the All at Once principle.
• Once a stable state is reached, it can be changed by the control places or by changes in input places’ states, leading to another stable state.
• Quantum measurements do not stop the QPU process.
• Classical measurements stop the measured qubit but not the unmeasured qubits.
• A complex quantum program can be implemented on more QPUs by linking their input and output places. Each QPU executes a quantum task, and the set of quantum tasks run concurrently.

3.9. QPN Model of a Quantum Task

A quantum program is composed of a set of distributed, concurrent, and communicating quantum tasks. Typically, each quantum task is deployed on a QPU; however, this is not mandatory—multiple tasks can be implemented on the same QPU.

The $QPN$ model of a quantum task is composed of the tuple

$$QPN=(N,G,type,\mathcal{U},map,P^Z,P^I,P^C,P^O,T^M,P^M)$$

(52)

where the following apply:

• N = (P, T, F) is the earlier defined net (Section 3.4).
• $G=[g_0,g_1,\dots ,g_{m-1}]$ is the earlier defined vector (Section 3.4).
• $type$ is a mapping assigning types to places: $type:P\to \{quantum,classical\}$.
• $\mathcal{U}$ is a set of unitary matrices corresponding to quantum logic circuits available in the QPU, which can be assigned to transitions through the mapping $map:T\to \mathcal{U}$.
• $P^Z=\{p_0^Z,p_1^Z,...\}\subset P$ is a set of qubits or qumodes (usually initialized in the quantum state $|0\rangle$).
• $P^I=\{p_0^I,p_1^I,...\}\subset P$ is a set of input places receiving quantum vector information from other quantum tasks (QPUs).
• $P^C=\{p_0^C,p_1^C,...\}\subset P$ is a set of input control places used for transition control. They contain parameters from the set $\Theta =\{{\theta }_1,{\theta }_2,...,\}$ used in the transition unitary matrices.
• $P^O=\{p_0^O,p_1^O,...\}\subset P$ is a set of output places used for sending quantum vectors to other quantum tasks (i.e., QPUs).
• $P^M=\{p_0^M,p_1^M,...\}\subset P$ is a set of measurement places that store classical information from measured qubits or qumodes for output QPU use.
• $T^M=\{t_0^M,t_1^M,...\}\subset T$ is a set of controlled transitions used to measure their input places, storing the information in $P^M$ as either quantum or classical type.

A quantum task begins when control place $p_0^C$ receives parameters. The enabled transitions, conventionally partitioned in steps, are executed. The quantum task reaches a balanced state that persists until one of the input places from $P^I\cup P^C\cup p^M$ receives an event that changes its state (Algorithm  1).

Algorithm 1 QPU or quantum task executor

Input: $P,T,P^Z,P^I,p^M,T^M,F,\mathcal{U},type,map;$ Initialization: $P^Z,P^I,P^C,P^M$ while time horizon do    for all $t\in T$ do      if t enabled then         * execute t;      end if;    end for;    * $send\left(P^O\right)$;    * $send\left(P^M\right)$;    $write\left(\right|{\Psi }_i\rangle ),i=0,1,...,m-1$;    WAIT(input event); end while; END algorithm;

3.10. Optimization of DSs

A quantum approach of combinatorial problems is based on the Quantum Approximate Optimization Algorithm (QAOA) [49]. Dynamic optimization problems with continuous variables are more challenging, particularly in open systems.

Variational Quantum Algorithms (VQAs), frequently used for optimization, are hybrid algorithms that employ both quantum and classical computing to find approximate solutions. These can be either gradient-based or gradient-free methods [30].

Evolutionary Systems (ESs) and their extensions Quantum Evolutionary Systems (QESs) are also commonly used in DS optimization. More details are given in [24].

Genetic Algorithms (GAs) and Quantum Genetic Algorithms (QGAs) are based on individuals grouped into populations that are iteratively improved using performance evaluations [50].

Unlike GAs, QGAs require the quantum implementation of individuals and the execution of genetic operations such as mutation, permutation, crossover, and combination. These operations can be efficiently implemented and controlled on a quantum computer (QC) or a QPU. Performance-based individual selection increases the chance of choosing better candidates. Performance evaluation requires adding unitary vectors multiplied by sub-unitary coefficients, which can be implemented through a unitary matrix applied to output variables.

For optimal control, Particle Swarm Optimization (PSO) has been used. A historical perspective on PSO development is given in [51].

PSO is a metaheuristic global optimization paradigm valued for its ease of application to complex multi-dimensional problems unsolvable by traditional deterministic algorithms [51,52]. Various methods have been developed to avoid local optima and improve search speed. Applications of PSO in multiple fields are analyzed in [53].

A quantum variant, Quantum Particle Swarm Optimization (QPSO), is described in [54,55,56]. Both classical PSO and QPSO benefit from features inspired by natural organisms. PSO models particles as moving in Newtonian space, characterized by position and velocity [52].

PSO has been enhanced with quantum features, yielding QPSO [55]. Quantum entanglement has been incorporated for quantum-inspired PSO [57]. Cooperative swarm intelligence is another application of QPSO [57]. QPSO can also be applied successfully to multi-task problems [58].

4. Experiments

As an application of DQCPNs, an Urban Vehicle Traffic Control (UVTC) system is chosen. Links between quantum computing and traffic management can be found in [59].

According to [60], a key component for the study and development of intelligent transportation systems is traffic modeling, which provides a framework for better investigating and testing the state of the road in real time and accurately predicting future traffic. Colored Petri Nets and Complex Event Processing are used for this purpose, representing the modeling of the city map and its vehicle traffic. Remarkably, here, the scalability challenge can be addressed by classical (Colored) Petri Nets, so their extension to QPNs is expected to also retain this feature.

The proposed QPN is a distinct type of PN model that retains most of the PN features. Supervised machine learning requires model training, where the high speed of quantum simulations constitutes a relevant benefit. The DQCPN approach supports the distributed implementation of UVTS, as well as model training.

The Urban Vehicle Traffic System (UVTS) is a modern and complex problem involving variations in traffic flow that require timely reactions under temporal constraints [61]. The UVTS can be described as vehicle flows that vary probabilistically in space and time [62]. Traffic flow parameters can be changed and controlled at intersections.

The current approach considers a network of simple intersections with two phases of controllable duration. The template of such an intersection is shown in Figure 12, where for direction i $(i=1,2,3,4)$, the flow states are denoted by $x_i$, the input flows by $u_i$, and the output flows by $e_i$.

The relations describing the dynamics of the intersection in Figure 12 consist of incoming flows, internal flows, and outgoing exit flows. An incoming input flow $u_i$ in iteration k is split into two directions, $u_{i,f}$ and $u_{i,r}$, as

$$u_i\left(k\right)=s_i\left(k\right)·u_{i,f}\left(k\right)+(1-s_i\left(k\right))·u_{i,r}\left(k\right),$$

(53)

according to the split coefficient $s_i\left(k\right)$ of input flow $u_i\left(k\right)$ at time k.

The intersection flows are controlled by a signal $\gamma$, with ${\alpha }_{\gamma }$ and ${\beta }_{\gamma }$ representing phase duration parameters. All intersections are assigned the same cycle duration.

The flows for the horizontal directions $i=1,3$ (modulo 4) in iteration k are described by

$$x_i(k+1)=x_i\left(k\right)+min\{u_{i,f}\left(k\right),{\alpha }_{\gamma }\left(k\right)\}+min\{u_{i+1,r}\left(k\right),{\beta }_{\gamma }\left(k\right)\}-e_{i+2}\left(k\right),$$

(54)

where $x_i\left(k\right)$ is the flow state at time k and $e_{i+2}\left(k\right)$ is the exit flow. The notation $min\{a,b\}$ means the minimum of a and b.

The flows for the vertical directions $i=2,4$ (modulo 4) in iteration k are described by

$$x_i(k+1)=x_i\left(k\right)+min\{u_{i,f}\left(k\right),{\beta }_{\gamma }\left(k\right)\}+min\{u_{i+1,r}\left(k\right),{\alpha }_{\gamma }\left(k\right)\}-e_{i+2}\left(k\right).$$

(55)

Exit flows $e_i\left(k\right)$ are constrained by a value ${\varrho }_i$ representing the maximum lane exit capacity:

$$e_i\left(k\right)=min\{x_i\left(k\right),{\varrho }_i\}.$$

(56)

An UVTS composed of four intersections, $I_1,I_2,I_3$, and $I_4$, is shown in Figure 13. This system is used for optimal control with the goal of achieving maximum throughput.

Each intersection $I_i$ has two input flows ($in{p}_{i,j};j=1,2$) and two output flows ($ou{t}_{i,j};j=1,2$) coming from or going outside the controlled area. Here $j=1$ is used for horizontal flows and $j=2$ for vertical flows.

The incoming flows in the system $in{p}_{i,j}$ ($i=1,2,3,4;j=1,2$) may vary, but the control system modifies control ${\gamma }_i$ ($i=1,2,3,4$) such that the UVTS achieves the highest possible throughput, for the current demands, as assessed by

$$J={\displaystyle \sum _{i=1}^4}{\displaystyle \sum _{j=1}^2}ou{t}_{i,j}^2.$$

(57)

For simplicity, the input flow splits $s_{i,j}$ ($i=1,2,3,4;j=1,2,3,4$) are considered constant.

The flows of the UVTS model can be implemented by QPNs using different types of places and their corresponding transitions:

• Single qubits in Hilbert space with multiple shots;
• Multi-qubits (discrete) in Hilbert space with a single shot;
• Single qumodes in Fock space with a single shot;
• Multi-qumodes in Fock space with a single shot.

In this approach, each QPU implements an intersection, and the entire UVTS is implemented in four linked QPUs.

An input flow $u_i$ split into $u_{i,f}$ and $u_{i,r}$ according to a parameter $s_i$ set in control place $p_c$ is represented in Figure 14.

Figure 15 shows the QPN model representing the exit flow $e_{i+2}$, composed of the previous flow ($x_i$), the forward input flow ($u_{i,f}$), and the right input flow ($u_{i+1,r}$).

By combining these components, the QPN model shown in Figure 16 is obtained. Place $p_0$ represents the initial value $|0\rangle$ of a qubit or qumode. It is used by the mapping assigned to $t_0$ for setting in $p_1$ the initial value $x_i^{\prime }$ of $x_i$, according to the value loaded in $p_{c0}$. Place $p_i$ receives the input value $u_i$, which is split by transition $t_i$ according to the split value $s_i$ set in place $p_{c,s_i}$. A similar role is played by nodes $p_{i2},t_{i2}$, and $p_{c,s,i+1}$.

Transitions $t_1$ and $t_2$ model the increase in flow $x_i$ by the input flow in phases one and two, respectively. The increase values are set in $p_{c1}$ and $p_{c2}$. Transition $t_3$ models the exit flow stored in $p_4$, measured by $t_m$, and sent forward by $t_4$. The time when the exit flow is measured is controlled by place $p_{cm}$.

The execution of the above QPN model can be divided in steps:

• Step 1 executes concurrently transitions $t_0,t_{i1},$ and $t_{i2}$, producing flows $x_i$, $u_{i,f}$, $u_{i,r}$, $u_{i+1,r}$, and $u_{i+1,f}$.
• Step 2 executes transition $t_1$, increasing flow $x_i$ with $u_{i,f}$ when phase 1 is open.
• Step 3 executes transition $t_2$, which adds right flow $u_{i+1,r}$ during phase 2.
• Step 4 executes transition $t_3$, releasing the vehicle flow to the next intersection or out of the system.
• Step 5 models the exit flow by transition $t_4$ and place $p_o$.

Finally, transition $t_m$ is executed, and exit flows $e_{i+2,m}$ are measured.

4.1. Lane Flows: Implementation and Simulation

Quantum model implementation and simulation of UVTSs can be performed using either discrete variables or continuous variables for flow modeling. Discrete variables can be implemented with one qubit per flow or with multiple qubits per flow. In the latter approach, the time for performing arithmetic operations (see [63]) can be utilized in the classical style. Another approach is based on qumodes, using one qumode per flow or multiple qumodes per flow.

4.1.1. One-Qubit-per-Flow Implementation

Each of the flows mentioned above is implemented by one qubit. Instead of the well-known Bloch sphere, the qubit is represented on a circle. Figure 17 illustrates a qubit constrained to a circle (plane) described by

$$|q\rangle =\alpha |0\rangle +\beta |1\rangle =sin(\theta \left)\right|0\rangle +cos\left(\theta \right)|1\rangle .$$

(58)

The qubit measurement is obtained by projecting it onto the $|1\rangle$ axis. Multiple execution shots are required to obtain reliable flow measurements. A mapping from the flow domain to the qubit measurement domain converts a flow variable into a qubit, or vice versa. For example, a flow range of $[0,15]$ vehicles/minute corresponds to the qubit measurement range $[0,1]$.

For the input split model shown in Figure 14, an implementation based on one qubit per flow is proposed, as illustrated in Figure 18. It describes a qubit $|s\rangle ={\alpha }_s|0\rangle +{\beta }_s|1\rangle$ that controls two entangled inputs $|u_i\rangle ={\alpha }_u|0\rangle +{\beta }_u|1\rangle$ and $|u_i^{\prime }\rangle ={\alpha }_u|0\rangle +{\beta }_u|1\rangle$, defined by the pair $|s\rangle$ and $|s^{\prime }\rangle$, where $|s^{\prime }\rangle =X·|s\rangle$.

The model shown in Figure 14 was practically implemented based on the relations

$$\begin{array}{c}\hfill u=u_f+u_r,\\ \hfill |u\rangle ={\alpha }_u|0\rangle +{\beta }_u|1\rangle ,\\ \hfill |u_f\rangle ={\alpha }_f|0\rangle +{\beta }_f|1\rangle ,\\ \hfill |u_r\rangle ={\alpha }_r|0\rangle +{\beta }_r|1\rangle ,\end{array}$$

(59)

with the split flows being given by

$$\left[\begin{array}{c}|u_f\rangle \\ |u_r\rangle \end{array}\right]=\left[\begin{array}{cc}R\left({\theta }_f\right)& \mathbf{0}\\ \mathbf{0}& R\left({\theta }_r\right)\end{array}\right]·\left[\begin{array}{c}|s\rangle \\ |u\rangle \end{array}\right].$$

(60)

Using the split relations ${\beta }_f+{\beta }_r={\beta }_u$ and ${\beta }_f={\beta }_s·{\beta }_u$, the rotation angles ${\theta }_f$ and ${\theta }_r$ can be determined:

$${\theta }_f=arccos({\beta }_u·{\beta }_s);{\theta }_r=arccos\left({\beta }_u(1-{\beta }_s)\right).$$

(61)

A lane exit flow $|e_{i+2}\rangle$ opposite entrance i is determined by the relations

$$\begin{array}{c}\hfill |\gamma \rangle ={\alpha }_{\gamma }|0\rangle +{\beta }_{\gamma }|1\rangle ,\\ \hfill |x_i\rangle ={\alpha }_{x,i}|0\rangle +{\beta }_{x,i}|1\rangle ,\\ \hfill |u_{i,f}\rangle ={\alpha }_{i,f}|0\rangle +{\beta }_{i,f}|1\rangle ,\\ \hfill |u_{i+1,r}\rangle ={\alpha }_{i+1,r}|0\rangle +{\beta }_{i+1,r}|1\rangle ,\\ \hfill |e_{i+2}\rangle ={\alpha }_{e,i+2}|0\rangle +{\beta }_{e,i+2}|1\rangle ,\end{array}$$

(62)

with $i\in \{1,2,3,4\}$ and $i+1$ taken from modulo 4. An exit flow $|e_{i+2}\rangle$ from one intersection becomes the input flow of the next. Assuming that a phase is open when $\gamma =|1\rangle$ and closed when $\gamma =|0\rangle$, the coefficients ${\alpha }_{\gamma }$ and ${\beta }_{\gamma }$ determine the entrance and exit of the lanes.

In Figure 16, the input splits are controlled by $|s_i\rangle$ and $|s_{i+1}\rangle$, while the crossings are controlled by $|{\gamma }_{if}\rangle$ and $|{\gamma }_{ir}\rangle$. The rotation angles of transitions $t_1$ and $t_2$ are

$$\begin{array}{c}{\theta }_{i,f}=arccos\left(min\{{\beta }_{i,f},{\beta }_{\gamma }\}\right),\hfill \end{array}$$

(63)

$$\begin{array}{c}{\theta }_{i,r}=arccos\left(min\{{\beta }_{i+1,r},{\alpha }_{\gamma }\}\right).\hfill \end{array}$$

(64)

Place $p_0$ is initialized to $|0\rangle$, and transition $t_0$, controlled by place $p_{c0}$, injects into place $p_1$ the initial value of flow state $x_0$. Input place $p_{i1}$ receives the split value $|u_{i1}\rangle$. Transition $t_1$, controlled by place $p_{c1}$, sets the qubit $|x^{\prime }\rangle$ in place $p_2$, representing the sum of the two previous qubits. The input value $|u_{i2}\rangle$ is added to $|x^{\prime }\rangle$, controlled by the state $|0\rangle$ of $|\gamma \rangle$. It is assumed that $|u_1\rangle$ enters during phase one on $|1\rangle$ and $|u_2\rangle$ during phase two on $|0\rangle$. The exiting vehicle flow of a lane, with state $|x^{″}\rangle$, is modeled by transition $t_3$. Vehicles exit in both phases, represented by $|0\rangle$ and $|1\rangle$. The rotation angle of transition $t_3$ is fixed and identical for all flows moving forward, denoted by ${\theta }_e$.

4.1.2. Multi-Qubits-per-Flow Implementation

Using four qubits to represent a vehicle flow can cover the range $[0,15]$ vehicles/minute. The number of times these operations are applied is set in the control places $p{c}_0,p{c}_1,p{c}_2,p{c}_3,p{c}_{s,i}$, and $p{c}_{s,i+1}$.

4.1.3. One-Qumode-per-Flow Implementation

A qumode can represent a vehicle flow if a scaling function is applied.

Let $q{m}_i={[c_0,c_1,\cdots ,c_7]}^T$ of dimension 8 be a variable modeling a vehicle flow $x_i$, and let $\mathcal{L}(·.)$ be a function that converts the measured value into the corresponding flow by the relation

$$x_i=\mathcal{L}\left(q{m}_i\right)=1+({\displaystyle \sum _{k=0}^7}{c}_k·2^k)·15/128.$$

(65)

The initialization of flow $x_i^0$ corresponds to a qumode value $q{m}_i^0$, obtained as

$$x_i^0=\mathcal{L}\left(q{m}_i^0\right);q{m}_i^0=R\left(\theta \right)D\left(\alpha \right)|0\rangle .$$

(66)

The parameters $\alpha$ and $\theta$ can be determined using Particle Swarm Optimization (PSO) or a Genetic Algorithm (GA) so that the resulting qumode $q{m}_i^0$ is an acceptable approximation of $x_i^0$ (i.e., $x_i^0\cong \mathcal{L}\left(q{m}_i^0\right)$).

The input flow split can be simulated using two entangled qumodes. A beamsplitter gate provides two exit qumodes that are separately rotated, one in the positive direction and the other in the negative direction.

Flow addition or subtraction can be simulated by positive or negative displacement and rotation, respectively.

In conclusion, using qumodes does not require changing the implementation logic. Only the mappings assigned to transitions must be modified for qumode operations.

4.2. Intersection Model

By joining the flow inputs in a vector U, the lane flow states in a vector X, the lane exits in a vector E, and the phase controls $\gamma ({\alpha }_{\gamma },{\beta }_{\gamma })$ of the two phases, the composed (concentrated) QPN model of the QPU that integrates the crossroad is obtained. These vectors correspond to the relations

$$\begin{array}{c}\hfill |U\rangle =|u_1\rangle \otimes |u_2\rangle \otimes |u_3\rangle \otimes |u_4\rangle ,\\ \hfill |X\rangle =|x_1\rangle \otimes |x_2\rangle \otimes |x_3\rangle \otimes |u_x\rangle ,\\ \hfill |E\rangle =|e_1\rangle \otimes |e_2\rangle \otimes |e_3\rangle \otimes |e_4\rangle ,\\ \hfill |S\rangle =|s_1\rangle \otimes |s_2\rangle \otimes |s_3\rangle \otimes |s_4\rangle ,\\ \hfill |E_m\rangle ={[e_{m2},e_{m2},e_{m3},e_{m4}]}^T.\end{array}$$

(67)

The vector $|U^{*}\rangle$ describes the split input vector containing pairs $(u_{if},u_{ir})$ for $i=1,2,3,4$. Some exit flows are measured, and some outputs of an intersection are linked to inputs of other intersections.

For practical reasons, the qubit implementation was performed using V vectors instead of $|\Psi \rangle$ vectors. Detailing the two phases and representing separately the input vehicle flows used in the second phase by $U^{\prime }$, the QPN model of all four lanes integrated into an intersection is shown in Figure 19.

Each QPU integrates the QPN model of an UVTS intersection. The vectors of an intersection’s four lanes are denoted by $U,X,E,$ and $\gamma$. Place $p_0$ integrates four qubits initialized at $|0\rangle$. Controlled transition $t_0$ sets in place $p_2$ state $X=\left[\right|x_1\rangle ,|x_2\rangle ,|x_3\rangle ,|x_4{\rangle ]}^T$.

Input place $P_i$ receives four qubits $U=\left[\right|u_1\rangle ,|u_2\rangle ,|u_3\rangle ,|u_4{\rangle ]}^T$, which are split by transition $t_i$ according to the split values $S=\left[\right|s_1\rangle ,|s_2\rangle ,|s_3\rangle ,|s_4{\rangle ]}^T$ provided by place $P_{c1}$. Thus, place $P_1$ contains eight qubits $U^{\prime }=\left[\right|u_{13}\rangle ,|u_{12}\rangle ,|u_{24}\rangle ,|u_{23}\rangle ],|u_{34}\rangle ,|u_{31}\rangle ,|u_{42}\rangle ,|u_{41}{\rangle ]}^T$.

Some of these inputs are used by controlled transition $t_1$ (modeling phase 1), while the other four are used by transition $t_2$ (phase 2). Both phases are controlled by places $P_{c2}$ and $P_{c3}$, which store the control qubit $|\gamma \rangle$. Transition $t_3$ models the four exit flows. These are measured by transition $t_m$ and sent out through transition $t_4$ via place $P_o$.

The intersection model can be implemented with either four qubits per vehicle flow or one qumode per vehicle flow. The vectors and the operations assigned to transitions must be adapted accordingly.

4.3. UVTS QPN Model

Figure 20 displays a QPN model integrating the QPN models of all four intersections. If the previous vectors are joined according to their roles, we obtain the vectors of the QPN model corresponding to the entire UVTC system. They are denoted by

$$\begin{array}{c}\hfill \mathcal{U}={[U_1,U_2,U_3,U_4]}^T,\\ \hfill \mathcal{S}={[S_1,S_2,S_3,S_4]}^T,\\ \hfill {\mathcal{U}}_f={[U_{1,f},U_{2,f},U_{3,f},U_{4,f}]}^T,\\ \hfill {\mathcal{U}}_r={[U_{1,r},U_{2,r},U_{3,r},U_{4,r}]}^T,\\ \hfill \mathcal{X}={[X_1,X_2,X_3,X_4]}^T,\\ \hfill \mathcal{E}={[E_1,E_2,E_3,E_4]}^T,\\ \hfill \Gamma =[{\gamma }_1,{\gamma }_2,{\gamma }_3,{\gamma }_4].\end{array}$$

(68)

The qubits or qumodes initialized in place $P_0$ at state $|0\rangle$ are mapped by controlled transition $T_0$ into place $P_1$, according to the required states $X_i,i=1,2,3,4$, transmitted through place $P_{c0}$. Place $P_i$ is initialized at $|0\rangle$ for all four qubits, vectors of qubits, or qumodes.

Transition $T_i$ sets in $P_{i+}$ the external inputs according to the information received through place $P_{ci}$. The internal inputs stored in $P_{i+}$ (i.e., $|u\rangle$) are provided by transition $T_4$ from the exit flow lanes.

Transition $T_s$ splits the input flows, storing them in place $P_2$, denoted by $U^{*}$. Transition $T_1$ models phase 1 of all intersections, while $T_2$ models the opposite phases. Transition $T_3$ models the lane exits of all intersections. Transition $T_4$ models the feedback of exit flows converted into internal input flows. $T_4$ links the exit flows with the corresponding input flows according to the UVT topology depicted in Figure 13.

Information stored in place $P_6$ can be measured at the request of the classical component.

Table 2. Node significance for one qubit per flow of Figure 20 model.

Node	Token	Operation	Dimension	Domain	Significance
$P_0$	$V_X$	init	$16\times 2$	Quantum	$|0\rangle$ Initialization
$P_{c0}$	${\Theta }_X$	-	$16\times 2$	Classical	State initialization
$T_0$	-	$U\left({\Theta }_x\right)$	$16\times 2$	Quantum	Initialization
$P_1$	$|\mathcal{X}\rangle$	-	$16\times 2$	Quantum	Flow states
$P_{c1}$	${\Gamma }_1$	-	$16\times 2$	Classical	Phase 1 parameter
$T_1$	-	$U\left({\Theta }_1\right)$	$4\times 4$	Quantum	Phase 1 open
$P_2$	$|{\mathcal{X}}^{\prime }\rangle$	-	$16\times 2$	Quantum	Flow states
$P_{c2}$	${\Gamma }_2$	-	$16\times 2$	Classical	Phase 2 parameter
$T_2$	-	$U\left({\Theta }_2\right)$	$4\times 4$	Quantum	Phase 2 open
$P_3$	$|\mathcal{X}″\rangle$	-	$16\times 2$	Quantum	Flow states
$P_{c3}$	${\Theta }_3$	-	$16\times 2$	Classical	Outflow parameter
$T_3$	-	$U\left({\Theta }_3\right)$	$4\times 4$	Quantum	Outflow move
$P_4$	$|\mathcal{E}\rangle$	-	$16\times 2$	Quantum	Exit flows
$T_4$	-	$join$	$16+16$	Quantum	Flow moves
$P_5$	$\left[\right|{\mathcal{U}}_i\rangle |\mathcal{E}\rangle ]$	join	$16\times 2$	Quantum	Input flows
$P_{cs}$	${\Theta }_s$	-	$16\times 2$	Classical	Split parameter
$T_s$	-	$U\left({\Theta }_s\right)$	$4\times 4$	Quantum	Flow split
$P_6$	$\left[\right|{\mathcal{U}}_f\rangle |{\mathcal{U}}_r\rangle ]$	-	$16\times 2$	Quantum	Input flows
$P_{me}$	1	-	1	Classical	Measurement
$P_{mu}$	1	-	1	Classical	Measurement
$T_{me}$	-	$measurement$	$4\times 4$	Quantum	Collapse
$T_{mu}$	-	$measurement$	$4\times 4$	Quantum	Collapse
$P_{m1}$	${\mathcal{E}}_m$	-	16	Classical	Measured ${\mathcal{E}}_m$
$P_{m2}$	${\mathcal{U}}_m$	-	$16\times 2$	Classical	Measured $({\mathcal{U}}_{mf},{\mathcal{U}}_{mr})$

shows the nodes, their sizes, and the operations involved for the one-qubit-per-flow implementation. It can be extended for the four-qubits-per-flow or one-qumode-per-flow implementations.

Figure 21 shows the architecture of the distributed quantum-centric application solving the optimal control of the UVT problem. The classical computing components receive the inputs $Inp$, the current flow states $\mathcal{X}$, and the input splits S of U. These are sent to the control component, which fills the control places of the QPUs. An initial control set $\Gamma$ is also provided. The quantum computing process is then started. After a specified delay, Control measures exit lane flows ${\mathcal{E}}_m$, which are used to compute input splits and lane exit flows.

The optimization component finds control $\Gamma$ by using the measured values ${\mathcal{E}}_m$. The control problem of UVT with QPN models consists of finding intersection phase controls ${\gamma }_i(i=1,2,3,4)$ for a given initial flow $X_i(i=1,2,3,4)$, input splits $S_i(i=1,2,3,4)$, and input demand flows $in{p}_{ij}(i=1,2,3,4;j=1,2)$ such that the highest throughput (see Equation (54)) is achieved.

The optimization problem was solved using the Particle Swarm Optimization (PSO) algorithm and the Genetic Algorithm (GA), with comparable results. A GA individual or PSO particle represents the vector $\Gamma$.

The current problem reduces to finding the phase control vector

$$\Gamma =\left[\right|{\gamma }_1\rangle ,|{\gamma }_2\rangle ,|{\gamma }_3\rangle ,|{\gamma }_4\rangle ].$$

(69)

That is, finding $\Gamma =[({\alpha }_1,{\beta }_1),({\alpha }_2,{\beta }_2),({\alpha }_3,{\beta }_3),({\alpha }_4,{\beta }_4)]$ in a four-dimensional search space.

The Quantum Computing System (QCS) reaches the initial equilibrium state by executing the sequence

$$\sigma =((T_0\ast T_1\ast T_2\ast T_3)\&(T_i\ast T_4))\ast T_5\ast T_s\ast (T_{me}\&T_{mu}).$$

(70)

During an experimental scenario, the inputs $Inp\left(\tau \right),S\left(\tau \right)$ and the control $\Gamma \left(\tau \right)$ are fixed, leading the system to states $X\left(\tau \right),U\left(\tau \right)$ for $\tau =1,2,\dots$, converging to equilibrium states $X^0,U^0$. The QCS then performs the relation ${\mathcal{E}}_m=QCS(Inp,\mathcal{X},S,\Gamma )$.

The classical control component implements the Algorithm 2:

Algorithm 2 Classical control

Control($Inp\left(0\right),{\mathcal{X}}^0,U\left(0\right),\Gamma \left(0\right),S\left(0\right)$) Input: $Inp\left(0\right),{\mathcal{X}}^0,U\left(0\right),\Gamma \left(0\right),S\left(0\right),max;$ Output: ${\mathcal{X}}^0,U^0,\Gamma \left(0\right),S\left(0\right)$; Initialization: $\tau =0;\mathcal{X}=\mathcal{X}\left(0\right);\Gamma =\Gamma \left(0\right);U=U\left(0\right);S=S\left(0\right);$ *calculate ${\Theta }_0,{\Theta }_i,{\Theta }_3,{\Theta }_S$; set ${\Theta }_1=0;{\Theta }_2=0;$ while $(\tau ⩽max)$ do    set $P_{c0},P_{ci},P_{c1},P_{c2},P_{c_3},P_{cs}$ with ${\Theta }_0,{\Theta }_i,{\Theta }_1,{\Theta }_2,{\Theta }_3,{\Theta }_S;$    $shotQCS$; /quantum tasks execution    set $P_{me},P_{mu}$; /measurement request    $read\left({\mathcal{E}}_m\right);$    $read\left(U_m\right)$;    $U=G(Inp,\mathcal{E});$    * calculate ${\Theta }_1,{\Theta }_2$;    $\mathcal{X}=\mathcal{E};$    $write\left(\mathcal{E}\right)$;    $\tau ++;$ end while; ${\mathcal{X}}^0=\mathcal{X};{\mathcal{E}}^0=\mathcal{E};U^0=U;$ $write:\mathcal{E},\mathcal{X},U;$ END algorithm;

A mapping $U=G(Inp,\mathcal{E})$ is used to convert the output flows into input flows of neighbor intersections.

Being a hybrid implementation, the reachability graph must contain both classical and quantum states. The marking is $M=[M_C,M_Q]$, where

$$M_C=[m\left(P_{c0}\right),m\left(P_{ci}\right),m\left(P_{c1}\right),m\left(P_{c2}\right),m\left(P_{c3}\right),m\left(P_{cs}\right),m\left(P_{me}\right),m\left(P_{mu}\right),m\left(P_{m1}\right),m\left(P_{m2}\right)],$$

(71)

and

$$M_Q=[m\left(P_0\right),m\left(P_i\right),m\left(P_1\right),m\left(P_2\right),m\left(P_3\right),m\left(P_4\right),m\left(P_{i+}\right),m\left(P_5\right),m\left(P_6\right)].$$

(72)

The reachability graph of the hybrid implementation can be expressed as $M_Q^0\to M_C^0\to M_Q^1\to M_C^1\to M_Q^2\to M_C^2\to \cdots$, where the superscript denotes the iteration.

The QPN model of the UVTS can be implemented using either discrete or continuous variables, as described in [22]. A discrete-variable QPN was used in [24].

4.4. Dynamic System Optimal Control

The Evolutionary System (GA or PSO) used for heuristic optimization has the role of finding optimal control $\Gamma$ of the UVTS in state $\mathcal{X}$ for given $Inp$ and split S. It implements the Algorithm 3:

Algorithm 3 Evolutionary system

Evolutionary system($Inp\left(0\right),{\mathcal{X}}^0,U\left(0\right),S\left(0\right)$) Input: $Inp\left(0\right),{\mathcal{X}}^0,U\left(0\right),S\left(0\right);$ Output: $\Gamma \left(0\right)$; Initialization: $k=0;\mathcal{X}=\mathcal{X}\left(0\right);\Gamma =\Gamma \left(0\right);U=U\left(0\right);S=S\left(0\right);$ * the initial population ${\mathcal{P}}^0;$ while $(k⩽max)$ do    $\mathcal{E}=Control(Inp,\mathcal{X},U,S)$;    * calculate J;    $write\left(\mathcal{J}\right)$;    $k++;$    * Improve Population $\mathcal{P}$ end while; $write(\Gamma )$; END algorithm;

4.5. Experimental Results

The experiments were partitioned into three scenarios starting from initial flow state $|0\rangle$ and applying three vectors of outside inputs:

• Scenario 1: UVTS cycles 0 to 6.
• Scenario 2: UVTS cycles 7 to 11.
• Scenario 3: UVTS cycles 12 to 17.

All the input splits were $1/\sqrt{2}$.

Figure 22, Figure 23, Figure 24 and Figure 25 display the evolution of flow $x_3$ of intersection $I_1$. The other flows have similar evolution. For one qubit per flow or one qumode per flow, a scale factor of 15 is used to obtain the real value of the vehicle number per minute.

The lane modeled by one qubit per flow is displayed for Scenario 2 in Figure 22. The orange curve shows flow $x_3$ at the end of each cycle, while the blue curve represents its values at intermediate steps. The initial state was $x_3\left(0\right)=0.2604446$. The input sequences for the six cycles were $in{p}_{11}=\{0.2,0.5,0.5,0.5,0.5,0.5\}$ and $in{p}_{12}=\{0.1654699,0.1660795,0.5196776,0.6025595,0.6268274,0.6339387\}$. The phase controls of the four intersections were $\gamma =\{0.532,0.498,0.498,0.498,0.498,0.498\}$.

The lane modeled by four qubits per flow is displayed for Scenario 2 in Figure 23. The red curve shows $x_3$ at the end of each cycle, while the blue curve represents intermediate values. The initial state was $x_3\left(0\right)=3.906669$. The input sequences were $in{p}_{11}=\{3,7.5,7.5,7.5,7.5,7.5\}$ and $in{p}_{12}=\{2.4820485,2.4911925,7.795164,9.0383925,9.402411,$$9.5090805\}$, with $\gamma =\{0.532,0.498,0.498,0.498,0.498,0.498\}$.

The lane modeled by one qumode per flow is displayed for Scenario 2 in Figure 24. The goal was to replicate the same evolution obtained with one qubit per flow. While the qubit implementation uses the rotation gate $R\left(\theta \right)$, the qumode implementation applies a displacement $D\left(\alpha \right)$ followed by $R\left(\theta \right)$. The values of $\alpha$ and $\theta$ were determined using PSO and GA, minimizing at each cycle the deviation $\left|\right|x_{qm}\left(\tau \right)-x_{qb}\left(\tau \right)\left|\right|$, where $x_{qm}\left(\tau \right)$ is the qumode-based flow and $x_{qb}\left(\tau \right)$ is the qubit-based flow. The total fitness fraction assessing the deviation between qubit and qumode simulations was 0.2098.

Figure 24 shows the qumode-based lane simulation in gray, with the corresponding qubit-based simulation in blue. The input sequences, initial state, and controls were identical to those of the qubit simulation.

Table 3. Quantum operation parameters for qumode simulation.

Cycle	Step 1	Step 2	Step 3	Step 4
6	(0.247, −0.631)	(0.000, 3.188)	(0.000, 0.498)	(0.000, −3.065)
7	(0.216, 0.766)	(0.202, −2.745)	(0.000, −0.128)	(0.000, 0.602)
7	(0.258, −3.226)	(0.949, −2.174)	(0.000, −2.290)	(0.000, −0.906)
9	(0.322, −2.568)	(1.013, −4.133)	(0.000, −3.153)	(0.000, 1.999)
10	(0.867, −1.105)	(0.000, 3.330)	(0.000, 0.066)	(0.000, −0.645)
11	(0.538, 4.272)	(0.000, −1.758)	(0.000, 0.152)	(0.000, 1.706)

shows the pairs of parameters $(\alpha ,\theta )$ used for displacement and rotation in each QPN step of vehicle traffic simulation.

Figure 25 shows the evolution of the controlled UVTS: blue for input evolution, orange for lane flow evolution, and green for throughput. UVTS throughput was divided by 5 to use the same vertical axis.

UVTS throughput was analyzed under three input vectors:

• $U^1=\{0.2,0.7,0.1,0.5,0.3,0.7,0.1,0.6\}$;
• $U^2=\{0.5,0.5,0.4,0.4,0.6,0.6,0.4,0.5\}$;
• $U^3=\{0.1,0.3,0.2,0.2,0.3,0.2,0.1,0.2\}$.

Table 4. Optimal control parameters.

Method	Scenario	${\mathit{\alpha }}_{\mathit{\gamma },1}$	${\mathit{\alpha }}_{\mathit{\gamma },2}$	${\mathit{\alpha }}_{\mathit{\gamma },3}$	${\mathit{\alpha }}_{\mathit{\gamma },4}$	Fitness	Generation
GA	1	0.516	0.457	0.343	0.422	3.1989	16
PSO	1	0.568	0.481	0.407	0.388	3.1989	3
GA	2	0.536	0.447	0.585	0.433	3.8971	20
PSO	2	0.574	0.564	0.475	0.475	3.8971	5
GA	3	0.703	0.669	0.518	0.195	1.5989	9
PSO	3	0.738	0.632	0.512	0.257	1.5989	2

summarizes the results obtained using the GA and PSO methods.

5. Discussion

The proposed approach uses general quantum gates, ignoring the logical quantum circuit synthesis and the involved compilation and transpilation processes. We are aware that the performance of quantum computers depends not only on the necessary physical qubits or qumodes but also on the gate error rates, which were not subjects of the current research study. According to [4], the classical processors work synergistically with quantum processors for generating control logic, providing storage and networking services at runtime. The application quality depends on the classical software and how it is linked to quantum software.

Solving a problem starts with its specification, and after its analysis, an algorithm or a set of algorithms is deduced. Some functions are determined that must be implemented on Quantum and Classical Processing Units. Which of them have to be implemented on QC and which on CC constitutes a question that the developer must answer. QC implementation benefits from the opportunity to quickly obtain the solution to some complex problem that must obey real-time requirements. The feasibility analysis would provide the answer if the required architecture met the expected results.

In the above-mentioned reference, quantum temporal cohesion is defined as executing an operation on multiple qubits in the same time span. Quantum spatial cohesion is assessed by the existence of a correlation between neighboring qubits that interact. Quantum coupling is assessed by the degree of interdependence between different modules that affect the interface of the relevant components. The current approach considers a mixed quantum and classical implementation of distributed complex applications, so temporal and spatial coherence should be assessed by the involved QPUs cooperating with classical components. A similar assessment should be used for mixed coupled components.

The verification of quantum-centric applications involves the verification of the quantum parts and the classical parts, as well as their interactions. Besides the state space dimensions, which are usually large, there is an explosion of state space size that makes the direct verification of all the possible reachable states impossible. Using some state labels having kinds of shared features or common links can lead to affordable verification methods. The inherent quantum randomness can be included in the state representatives. Even some precedence relations can be defined and analyzed in relation to sets of concurrent quantum and classical operations.

All the implementations are affected by quantum execution errors. The desired precision determines the number of necessary experiments. The precision assessment must begin with the sequence of the transitions that are executed and the precision of the operations involved. For example, the sequence for reaching the initial equilibrium state of the UVTS (see Equation 70) provides the operations that are executed. Their precision depends on the quantum computer that executes these operations.

6. Conclusions

The goal of unitary development of quantum-centric software using a qubit-based or qumode-based approach mixed with classical computing components was attained. The proposed example for experiments shows a similarity of information flows and vehicle flows. Also, both must be controlled to reach the goals. There is a common view/model for one qubit per flow of information/vehicles, multi-qubits per flow of information/vehicles, or one qumode per flow of information/vehicles. The same graph can be used for the construction of different models of computation. Developers can decide which kinds of information flows are most suitable for their applications. The PNs can be extended and adapted for catching the quantum and classical states, as well as the necessary operations and interactions. They can display the details at different levels and so facilitate development processes.

The QPU pattern helps the quantum implementation of distributed software and the control of quantum processing. The partitioning of applications on quantum tasks and classical tasks facilitates the design, the functions deployment and their behavior verification.