iconOpen Access

ARTICLE

Foundations of Photonic Quantum Computation. Part 1. Introduction to Quantum Operators

Martin Bombardelli1,2,3, Gérard Fleury1, Philippe Lacomme1,*, Bogdan Vulpescu2

1 UMR 6158 LIMOS, Université Clermont Auvergne, 1 Rue de la Chébarde, Aubière, France
2 UMR 6533 LPCA, Université Clermont Auvergne, 4 Av. Blaise Pascal, Aubière, France
3 CGI 10 Rue Eric de Cromières, Clermont-Ferrand, France

* Corresponding Author: Philippe Lacomme. Email: email

Journal of Quantum Computing 2026, 8, 13-54. https://doi.org/10.32604/jqc.2026.075438

Abstract

This work aims to present the fundamental concepts necessary for performing computations on photonic quantum computers by detailing the gates specific to this architecture and introducing the relationships between standard Pauli gates and their counterparts in photonic systems. Physical considerations related to the optical components are addressed. Theoretical aspects concerning quantum operators are presented, and applied sections demonstrating implementations using the Perceval library developed by Quandela are given. This paper provides a comprehensive, state-of-the-art description of photonic quantum gates in a formal way. The main contribution of this paper is to allow researchers with prior knowledge of the gate model of quantum computing to have a comprehensive understanding of how some photonic quantum computers work. Three optical components are used in this document: beam splitters, phase shifters and permutation components. Most of the more common quantum gates are built from the physical description of these components and the associated physical laws. Extensive focus is placed on controlled gates, which have more complicated constructions. Two different constructions of the CNOT gate are given to show how versatile photonic quantum computers can be. The main drawback of this type of controlled gate is discussed, namely the probabilistic nature of its implementation.

Keywords

Introduction; photonic; quantum computing; encoding; gate model; physics

1  Introduction

1.1 Photonic Quantum Computing

Simulating quantum physics on a computer is widely believed to be an algorithmically difficult task. This was already the case as early as 1980, which led Manin [1,2] to briefly mention the idea of using quantum systems to build quantum automata. The same year, Benioff [3] introduced quantum Turing machines. One of the problems that arise when one wants to simulate quantum physics accurately is the amount of memory needed to fully represent the quantum state of the system [4]. This difficulty in simulating quantum systems led Richard Feynman to imagine a “computer” made of and for quantum systems in his foundational article “Simulating Physics with Computers” [5]. The concept was then extended to what is known as gate model quantum computing (QC) by David Deutch [6]. The first advantage of this quantum model of computation was found by leveraging the query model on Deutsch’s problem. QC allows us to check if a given function f:{0,1}{0,1} is constant (f(0)=f(1)) or if it is balanced (f(0)f(1)) in one query whereas its classical counterpart needs two measurements. An extended version was then proposed in [7], achieving an even greater improvement over the classical counterpart.

Building on these early successes, researchers came up with other quantum algorithms which had a lower algorithmic complexity than their classical counterparts. The canonical and most famous examples are Grover’s [8] search algorithm and Shor’s factoring algorithm [9].

Photonic QC is one of many physical realizations of a quantum computer. The first proposal came from [10], which introduced “dual-rail encoding,” making it possible to encode qubits into Fock states [11]. This led Knill, Laflamme, and Milburn to develop an entire protocol for physically realizing a gate-model quantum computer using optical components, known as the KLM protocol [12]. This protocol was further developed in the following years in [13,14]. This model was refined in [15] into a more complex model of photonic QC, called one-way QC or measurement-based QC, which lies outside the scope of this work.

Photons have proven to be good candidates for the main applications of quantum information. First, they have been used to simulate Hamiltonian dynamics with good precision and high success probability on a 4-qubit photonic silicon chip [16]. Photonic quantum information has applications to cybersecurity with many examples of quantum key distribution being achieved using photons [1719]. In the field of optimization, although no advantage has been found yet, several promising papers aim to reduce the qubit count required to use photonic quantum computers to solve hard optimization problems [2022].

Another reason to consider photons a powerful quantum resource is that Scott Aaronson and Anton Arkhipov proposed a protocol for demonstrating quantum supremacy, called boson sampling, which can be implemented using photons and linear optical components [23]. In 2020, ref. [24] reported a claim of quantum computational advantage using this protocol.

1.2 Understanding Modes and Defining Qubits from Modes

To create qubits in a photonic quantum computer, the first method proposed was path encoding, introduced by [10]. The locations of the photons—referred to as spatial modes—define the state of the qubit. Spatial modes can, for instance, correspond to optical fibers. For convenience, throughout this chapter, we use the term mode to refer specifically to spatial mode.

To describe a system composed of photons and modes. We use the notation |n0,n1,,nm101(m1) where 0,1,,(m1) denote the spatial modes occupied by n0,n1,,nm1 photons. This type of states is referred to as Fock state.

To define a Qubit, let us now consider a specific case where a single photon is distributed over two modes. The definition of the two basic states of a qubit in the dual rail encoding relies on the location of the said photon.

|0=|1,001

|1=|0,101

When the photon is in mode 0, this corresponds to the Fock state |1,001 sometimes written simply as |1,0 (although this notation should be avoided to prevent confusion between qubit states and Fock states).

Remark

When possible and in cases where ambiguity may arise, we use the notation |n0n1nm1f to indicate explicitly that the set of modes corresponds to a Fock state.

It is also common to omit the commas between each component of the state, so that |n0,n1,,nm1f is often written as |n0n1nm1f.

The Fock state |1,001is encoding the qubit state |0 and a representation is provided in Fig. 1.

images

Figure 1: Qubit state |0=|1001.

Similarly, the Fock state |0101 is encoding the qubit state |1 and a representation is provided in Fig. 2.

images

Figure 2: Qubit state |1=|0101.

This encoding is called the dual mode encoding. But there exist many other possibilities to encode qubits, qudits or even continuous variable quantum information! [25].

1.3 Creation and Annihilation Operators for the Modes

The creation and annihilation operators associated with a mode a are denoted a^a and a^a, respectively. Their actions are as follows:

•   The creation operator a^0 allows the transition from |00 to |10 in spatial mode 0. For example, a^0 transforms the vacuum state |0001 into |1001.

•   The annihilation operator a^0 allows the transition from |10 to |00. For example, a^0 transforms |1001 into the vacuum state |0001.

These operators correspond to the emission or annihilation of a photon in a given mode. They play a crucial role when describing the operation of complex optical components.

2  The Generic Beam Splitter Component

2.1 Physical Description of the Action of the Beam Splitter

A beam splitter is an optical component used in photonic circuits. Let Ea and Eb denote the amplitudes of the two input electric fields, and Ec and Ed the amplitudes of the two output fields, as illustrated in Fig. 3. Let rac and rbd be the reflection coefficients, tad and tbc the transmission coefficients. We assume that the magnitudes are restricted to |rac|,|rbd|,|tad|,|tbc|[0, 1].

images

Figure 3: Representation of a beam splitter with two input modes and two output modes.

The output field amplitudes can be expressed in terms of the input amplitudes through the so-called continuity relations:

Ec=racEa+tbcEb(1)

Ed=tadEa+rbdEb(2)

where

rac: is the contribution of Ea found at the output Ec

rbd: is the contribution of Eb found at the output Ed

tad: is the contribution of Ea found at the output Ed

tbc: is the contribution of Eb found at the output Ec

The conservation of energy (proportional to the squared modulus of Ex) leads to:

|Ea|2+|Eb|2=|Ec|2+|Ed|2(3)

Using (1) and (2), the action of the beam splitter can be described in matrix form based on the field amplitudes of each mode, as shown in Fig. 4.

images

Figure 4: Action of a beam splitter.

Let us note:

U=[ractbctadrbd]

If the entire input field is injected into mode a, the input amplitudes satisfy

|Ea|2=1,|Eb|2=0,

which is consistent with the normalization condition Ea2+Eb2=1, then we have:

(ractbctadrbd).(Ea0)=(EcEd)

It follows that:

rac.Ea=Ec(4)

tad.Ea=Ed(5)

Staying in the case of one single input (here in a), we have |Eb|2=0, applying to (3) gives:

|Ea|2=|Ec|2+|Ed|2(6)

because (4) and (5):

|Ea|2=|racEa|2+|tadEa|2

So

|Ea|2=(|rac|2+|tad|2).|Ea|2

Because we consider that we have an input in a, we have Ea0 and we can divide both terms of the equation by |Ea|2

1=|rac|2+|tad|2(7)

By the applying the same process this time with Ea=0 and Eb0:

(ractbctadrbd).(0Eb)=(EcEd)

One would obtain:

1=|rbd|2+|tbc|2(8)

Given (1) and (2), it is possible to calculate:

|Ec|2=|racEa+tbcEb|2=|racEa|2+|tbcEb|2+racEa(tbcEb)+tbcEb(racEa)

Similarly

|Ed|2=|tadEa|2+|rbdEb|2+tadEarbdEb+rbdEbtadEa

Adding both equations together:

|Ec|2+|Ed|2=(|rac|2+|tad|2)|Ea|2+(|rbd|2+|tbc|2)|Eb|2+racEa(tbcEb)+tbcEb(racEa)+tadEarbdEb+rbdEbtadEa=(|rac|2+|tad|2)=1(see ((7)))|Ea|2+(|rbd|2+|tbc|2)|Eb|=12+(tadrbd+ractbc)EaEb+(rbdtad+tbcrac)EaEb

So

|Ec|2+|Ed|2=|Ea|2+|Eb|2+(tadrbd+ractbc)EaEb+(rbdtad+tbcrac)EaEb

Reminder

According to (3), we should have:

|Ea|2+|Eb|2=|Ec|2+|Ed|2

By substituting |Ec|2+|Ed|2 using the above relation:

|Ea|2+|Eb|2=|Ea|2+|Eb|2+(tadrbd+ractbc)EaEb+(rbdtad+tbcrac)EaEb

We get:

(tadrbd+ractbc)EaEb+(rbdtad+tbcrac)EaEb=0

Since this expression must hold for any choice of Ea and Eb, it implies the two following relations:

(tadrbd+ractbc)=0(9)

(rbdtad+tbcrac)=0(10)

Theorem 1: U is unitary.

Proof: Consider the matrix:

UU=[ractadtbcrbd][ractbctadrbd]

UU=[racrac+tadtadractbc+tadrbdtbcrac+rbdtadtbctbc+rbdrbd]

UU=[|rac|2+|tad|2ractbc+tadrbdtbcrac+rbdtad|tbc|2+|rbd|2]

Using (7)(10), we directly get:

UU=[1001]

Therefore, the beam splitter’s operation is unitary. □

2.2 Parameterization of the Beam Splitter Matrix U

The gate U representing the action of a beam splitter can then be denoted as BS:

BS=(ractbctadrbd)

There are several conventions for the beam splitter, some of which belong to U(2) but not to SU(2). The goal of this section is to understand how those different conventions appear and why different forms exist.

Theorem 2: ϕadϕbdϕac+ϕbc=π with ϕij is the phase of the exponential form of tij.

Proof: As a starting point, let us take the relation demonstrated in the preceding section:

tbc.rac+rbd.tad=0

As all the coefficients are complex numbers, each one can be represented in its exponential form so we can be written:

|tbc|ei.ϕbc.|rac|.ei.ϕac+|rbd|.ei.ϕbd.|tad|.ei.ϕad=0

|tbc|.|rac|.ei.(ϕacϕbc)+|rbd|.|tbd|.ei.(ϕadϕbd)=0

So

|tbc|.|rac|.ei.(ϕacϕbc)=|rbd|.|tad|.ei.(ϕadϕbd)

|tbc|.|rac|=|rbd|.|tad|.ei.(ϕadϕbdϕac+ϕbc)

|rac||tad|=|rbd||tbc|.ei.(ϕadϕbdϕac+ϕbc)

It is now possible to analyze:

|rac||tad|=|rbd||tbc|.ei.(ϕadϕbdϕac+ϕbc)

All magnitudes are positive real numbers, so ei.(ϕadϕbdϕac+ϕbc) can only take the value 1.

From this we find the first important relation:

ϕadϕbdϕac+ϕbc=π(11)

Theorem 3: r2+t2=1 with t:=|tad|=|tbc| and r:=|rac|=|rbd|.

Proof: To find the second important relation, let us start with:

|rac||tad|=|rbd||tbc|

Squaring both sides of the equation gives:

|rac|2|tad|2=|rbd|2|tbc|2

Using (7) and (8):

1|tad|2|tad|2=1|tbc|2|tbc|2

i.e.,

1|tad|21=1|tbc|21

It follows that

|tad|=|tbc| and we note t:=|tad|=|tbc|

The equation |rac||tad|=|rbd||tbc| can be rewritten |rac|t=|rbd|t which implies that:

|rac|=|rbd| and we note r:=|rac|=|rbd|

Recalling (8)

|rac|2+|tad|2=1

And using the new notation leads to the second important relation:

r2+t2=1(12)

Remark on the Physical Meaning of the Coefficients r and t

The coefficients r2=R and t2=T correspond to:

The reflectance R=PreflectedPIncoming

The transmittance T=PTransmittedPIncoming

We can also define:

The absorbance A=PAbsorbedPIncoming where all the P values represent powers.

Energy conservation requires R+T+A=1 and throughout this document, we consider lossless beam splitters (i.e., A=0)

By taking the complex form of its coefficients, the BS operator can be parameterized as:

BS=(|rac|.ei.ϕac|tbc|.ei.ϕbc|tad|.ei.ϕad|rbd|.ei.ϕbd)

And by definition of r and t:

BS=(r.ei.ϕact.ei.ϕbct.ei.ϕadr.ei.ϕbd)

Thus, the BS operator is completely defined by the six parameters:

r,t,ϕac,ϕbc,ϕad,ϕbd

And by applying the two important relations (11) and (12):

r2+t2=1

ϕadϕbdϕac+ϕbc=π

We would like to reduce the number of parameters of BS.

To do this, we start by using (11):

{r2+t2=1r=|rac|0ett>0θ[0,+π2],r=sin(θ)and t=cos(θ)withθ=arctan(rt)

One can now write:

BS=(r.ei.ϕact.ei.ϕbct.ei.ϕadr.ei.ϕbd)=(sin(θ).ei.ϕaccos(θ).ei.ϕbccos(θ).ei.ϕadsin(θ).ei.ϕbd)

In their paper, ref. [26] propose the change of variables:

ϕt=12(ϕadϕbc)

ϕr=12(ϕacϕbdπ)

ϕ0=12(ϕad+ϕbc)

To obtain

ϕac=ϕ0+ϕr

ϕad=ϕ0+ϕt

ϕbc=ϕ0ϕt

ϕbd=ϕ0ϕrπ

Verification

The verifications for ϕad and ϕbc are straightforward; let us detail ϕac and ϕbd

For ϕac:

ϕ0+ϕr=12(ϕad+ϕbc)+12(ϕacϕbdπ)

=12(ϕad+ϕbc+ϕacϕbdπ)

ϕ0+ϕr=12(ϕadϕac+ϕbcϕbdπ(11)π+ϕac+ϕac)

ϕ0+ϕr=ϕac

And for ϕbd:

ϕ0ϕrπ=12(ϕad+ϕbc)12(ϕacϕbdπ)π

ϕ0ϕrπ=12(ϕadϕac+ϕbcϕbdπ(11)+ϕbd+ϕbd+π)π=(2ϕbd+2π)2π

ϕ0ϕrπ=ϕbd

We can therefore rewrite by replacing each of the expressions:

BS=(sin(θ).ei.ϕaccos(θ).ei.ϕbccos(θ).ei.ϕadsin(θ).ei.ϕbd)=(sin(θ).ei.(ϕ0+ϕr)cos(θ).ei.(ϕ0ϕt)cos(θ).ei.(ϕ0+ϕt)sin(θ).ei.(ϕ0ϕrπ))

Thus, a common expression for the noiseless beam splitter becomes:

BS1BS=ei.ϕ0(sin(θ).ei.ϕrcos(θ).ei.ϕtcos(θ).ei.ϕtsin(θ).ei.ϕr)

We obtained an expression of BS using only 4 parameters:

θ,ϕ0,ϕr and ϕt

2.3 Important Remark on Different Conventions

The definitions of ϕr,ϕt and ϕ0 are not universal; for example, by changing the definition of ϕr:

ϕr=12(ϕacϕbd+π)

We would obtain:

BS2(θ,ϕr,ϕt,ϕ0)=ei.ϕ0(sin(θ2).ei.ϕrcos(θ2).ei.ϕtcos(θ2).ei.ϕtsin(θ2).ei.ϕr)

Or alternatively, by defining:

r2+t2=1θ[0,π],r=cos(θ2) and t=sin(θ2) with θ=arctan(tr)

One could also have obtained:

BS3(θ,ϕr,ϕt,ϕ0)=ei.ϕ0(cos(θ2).ei.ϕrsin(θ2).ei.ϕtsin(θ2).ei.ϕtcos(θ2).ei.ϕr)

In by using BS3 and considering ϕr=ϕt=ϕ0=0 and θ=π2, we obtain the expression of the Hadamard gate.

BS3(π2,0,0,0)=(cos(π4)sin(π4)sin(π4)cos(π4))=(22222222)=H

2.4 Quandela Conventions

Note that the conventions presented above are not exhaustive. Perceval, the library proposed by [27], offers by default three conventions.

Let us now consider, in each case, all phases set to zero.

Quandela Convention H:

BSH(θ[0;π],0,0,0)=(cos(θ2)sin(θ2)sin(θ2)cos(θ2))

In particular, BSH(π2,0,0,0)=H defines the Hadamard gate. This convention can be obtained with the same definitions of ϕr,ϕt and ϕ0 as in the BS1 convention but by choosing:

θ[0,π],r=cos(θ2)et t=sin(θ2)

Quandela Convention Rx:

BSRx(θ[0;π],0,0,0)=(cos(θ2)isin(θ2)isin(θ2)cos(θ2))

The operator BSRx is obtained by again choosing θ[0,π],r=cos(θ2) and t=sin(θ2), in the previous calculations, along with the selections of ϕt,r,0 given in Table 1.

images

New parameters for ϕt,r,0 to define BSRx

ϕt=12(ϕadϕbc),

ϕr=12(ϕacϕbd),

ϕ0=12(ϕad+ϕbcπ)

which can be rewritten

ϕac=ϕ0+ϕr

ϕbd=ϕ0ϕr

ϕad=ϕ0+ϕt+π2

ϕbc=ϕ0ϕt+π2

Table 1 provides the correspondence between the old definitions of ϕt,r,0 and the new definitions.

Quandela Convention Ry:

BSRy(θ[0;π],0,0,0)=(cos(θ2)sin(θ2)sin(θ2)cos(θ2))

This corresponds exactly to the RY gate according to IBM’s notation. This expression arises through similar transformations.

2.5 Symmetric Beam Splitter

A beam splitter is said to be symmetric if it is assigned r=12 and t=12. This corresponds to the photon having a “one in two chance of being reflected” and a “one in two chance of being transmitted”.

It means choosing θ=π4 in most conventions

In the first convention,

BS1(θ,ϕr,ϕt,ϕ0)=ei.ϕ0(sin(θ).ei.ϕrcos(θ).ei.ϕtcos(θ).ei.ϕtsin(θ).ei.ϕr)

From a mathematical point of view, we choose ϕr=ϕt=ϕ0=0 with θ=π4 and we obtain, for example:

BS1(π4,0,0,0)=1(12.112.112.112.1)=12(1111)=H

The values of the symmetric beam splitter in the Quandela convention (for θ=π2 and all phases equal to 0) are:

BSH(π2,0,0,0,0)=12(1111)

which represents the Hadamard gate

BSRx(π2,0,0,0,0)=12(1ii1)

BSRy(π2,0,0,0,0)=12(1111)

All these conventions are equivalent in the sense that one can be transformed into another.

Now, let us clarify a subtlety that was previously overlooked. The Perceval implementation is as follows:

BSRx(θ,Φtl,Φbl,Φtr,Φbr)=(ei.(Φtl+Φtr)cos(θ2)i.ei.(Φbl+Φtr)sin(θ2)i.ei.(Φbr+Φtl)sin(θ2)ei.(Φbl+Φbr)cos(θ2))

BSH(θ,Φtl,Φbl,Φtr,Φbr)=(ei.(Φtl+Φtr)cos(θ2)ei.(Φbl+Φtr)sin(θ2)ei.(Φbr+Φtl)sin(θ2)ei.(Φbl+Φbr)cos(θ2))

BSRy(θ,Φtl,Φbl,Φtr,Φbr)=(ei.(Φti+Φtr)cos(θ2)ei.(Φbl+Φtr)sin(θ2)ei.(Φbr+Φtl)sin(θ2)ei.(Φbl+Φbr)cos(θ2))

With the special cases:

BSH(θ,0,0,0,0)=BSH(θ)=12(cos(θ2)sin(θ2)sin(θ2)cos(θ2))(13)

BSRx(θ,0,0,0,0)=BSRx(θ)=12(cos(θ2)i.sin(θ2)i.sin(θ2)cos(θ2))(14)

BSRy(θ,0,0,0,0)=BSRy(θ)=12(cos(θ2)sin(θ2)sin(θ2)cos(θ2))(15)

It should be noted that the library allows passing 4 phases as parameters, which differs from the 3 phases described previously. Fig. 5 shows on the left the placement of these four phases the library uses, to be compared with the three parameters of the generic beam splitter on the right we described.

images

Figure 5: Differences between the phase parameters of the beam splitter provided by the Perceval library [27] and those considered previously.

The phases considered are those associated with each complex coefficient describing the action of the beam splitter, whereas Perceval adds a phase to each mode (inputs and outputs) that can be controlled using phase shifters (described in the next section). This allows them to obtain a more tunable beam splitter. By default, in the Quandela library, the parameters are θ=π2 and ϕ=0 for all ϕ, so that:

BSH(θ)=12(cos(θ2)sin(θ2)sin(θ2)cos(θ2))

BSH()=BSH(π2,0,0,0,0)=12(1111)

The notation BSH() corresponds to calling the procedure BSH() without specifying the parameters.

3  Photonic Circuit Representation and Two Other Optical Components

3.1 The Phase Shifter Component

Apart from the beam splitter, there is a second essential optical component that enables transformations on Fock states. One can also use phase shifters: a transparent plate acting on a single input mode and allowing the phase of the output mode to be changed if a photon is present. Physically, a phase shifter is a device that “slows down” the photon, creating a phase shift relative to the rest of the system. There are several ways to implement it. One way is simply to place a transparent plate in the photon’s path, as stressed in the figure below (Fig. 6).

images

Figure 6: Representation of a type of physical phase shifter.

The phase shifter acts on a single input mode and produces a single output mode. In other words, its action can be described in terms of Fock states. Recall that the basis states of qubits are encoded on two modes by

|0=|1001

And

|1=|0101

Let PSp(ϕ) denote the operator representing the application of a phase shifter with phase ϕ to mode p. Its action on Fock states can be described as follows:

PSp(ϕ)|0p|0p and PSp(ϕ)|1peiϕ|1p

Its action on Fock states can be described as follows:

PS1(ϕ)|0=PS1(|1001)=|1001=|0

This time, applying it to the qubit |1:

PS1(ϕ)|1=PS1(ϕ)|0101=eiϕ|0101=eiϕ|1

We thus have the action on qubits:

PS0(ϕ)=(ei.ϕ001) and PS1(ϕ)=(100eiϕ)

Reminders

According to the definition of Rz:

Rz(ϕ)=eiZθ2=(eiϕ200eiϕ2)

This corresponds (up to a global phase) to the P and R1 classical quantum gates:

P(ϕ)=R1(ϕ)=(100eiϕ)

The action of PS1(ϕ)is exactly that of the gate P(ϕ)=eiϕ2Rz(ϕ), and in matrix form:

(100eiϕ)=eiϕ2(eiϕ200eiϕ2)

We also immediately obtain:

PS1(ϕ)=R1(ϕ)=P(ϕ)

From a Fock state perspective, we have the following:

PS1(ϕ)|0=PS1(ϕ)|1001=There is no photonon mode 1 andPS1 acts on mode 1|1001=|0

PS1(ϕ)|1=PS1(ϕ)|0101=There is a photonon mode 1 andPS1 acts on mode 1eiθ|0101=eiθ|1

Theorem 4: Applying a phase shift to each mode is equivalent to applying a global phase shift to the qubit. Let |ψ=(αβ) be a qubit in an arbitrary state, then:

ei.ϕ.|ψ=PS0(ϕ).PS1(ϕ).(αβ)

Proof:

|ψ0=PS0(ϕ).PS1(ϕ).(αβ)

|ψ2=PS0(ϕ).(αei.ϕβ)

|ψ3=(ei.ϕαei.ϕβ)=ei.ϕ.(αβ)

3.2 Definition of the Permutation Component

The permutation “component” is an optical element whose action is very simple: it exchanges the number of photons between the modes given as parameters. It can be realized by redirecting the optical modes through the use of mirrors for instance.

For example, for PERM10:

|n0n101|n1n001

Another example involving more modes:

PERM2301(|n0n1n2n30123)=|n2n3n0n10123

2301 corresponds to the permutation

01232301

One can observe that PERM01=Id as it corresponds to the permutation:

0101

3.3 Graphical Representations of the Beam Splitter and the Phase Shifter

Photonic systems can be described using various graphical representations of their optical components. To recognize them, here are a few examples. In the following diagrams, each line represents an optical mode. Let us begin with the beam splitter, shown in Fig. 7 and let us continue with the phase shifter in Fig. 8.

images

Figure 7: Two representations of the beam splitter.

images

Figure 8: Two representations of the phase shifter.

We can also give a representation of the PERM component truly representing how the photons move from one mode to another. Like shown in Fig. 9.

images

Figure 9: A representation of PERM201.

3.4 Graphical Representations of a Photonic Circuit

Theses optical components can then be used in an optical circuit. The optical circuit will be composed of different lines representing different modes.

Then the components are placed onto the circuit. Like in gate model of quantum computation, the components are applied in order from left to right. To keep this in mind, we can imagine photons coming from the left of the circuit and moving along the lines until it reaches the end of the circuit.

An example of circuit with two Phase Shifters and two Beam Splitters BSRx is given in Fig. 10.

images

Figure 10: Representation of a quantum photonic circuit made with the Perceval library.

Note that the circuit does not directly produce the input Fock state. In some cases, we place it on the left side of the circuit.

4  Modelling Single-Qubit Gates

4.1 From a Unitary on Fock States to a Unitary on Qubits

Before starting to describe how to rebuild the quantum gates on qubits, it is important to understand the link between a unitary acting on Fock states and a unitary acting on qubits. To understand this, we will need to use the creation and annihilation operators.

Let U be a unitary matrix associated with an optical component or an optical circuit composed of two input modes 0 and 1 and two output modes out0 and out1. The effect of U is described by the following relation:

(a^out0a^out1)=U(a^0a^1)

where a^m is the annihilation operator on mode m.

To better understand what happens, we multiply both sides on the left by U.

U(a^out0a^out1)=(a^0a^1)

We then take the conjugate transpose of the equation:

(U(a^out0a^out1))=(a^0a^1)

(a^out0a^out1)(U)=(a^0a^1)

Applying the transposition ()T gives:

UT(a^out0a^out1)=(a^0a^1)

with U=(U11U12U21U22)

{a^0=U11a^out0+U21a^out1a^1=U12a^out0+U22a^out1

This if we rename the output mode with the same name as the corresponding input mode, we can rewrite the previous relations:

{a^0UU11a^0+U21a^1a^1UU12a^0+U22a^1

We now have an expression to describe how an operator a^0/1 is transformed by the circuit/component represented by U.

Let us consider an example with for instance:

U=BSH(π2)=12(1111)=(BSH(π2))T

Replacing U by BSH(π2) in the previous equation:

{a^0=12(a^out0+a^out1)a^1=12(a^out0a^out1)

We can rewrite the system as:

{a^0BSH(π2)12(a^0+a^1)a^1BSH(π2)12(a^0a^1)

Then we use theses relations to describe the effect of the component on a Fock state starting from:

|1101=a^0a^1|0001

We use the relations from the previous system to get the result after the component:

12(a^0+a^1)12(a^0a^1)|0001=12(a^0a^0+a^1a^1)|0001

=12|0001+12|1101

Starting with two photons on different modes, applying a beamsplitter to both modes results in getting either two photons in the first output mode or two photons in the second output mode. Never in between. This is known as the Hong Ou Mandel effect [28].

4.2 Realization of the X Gate

Our goal is to construct an X gate using the permutation component (Fig. 11). This representation should not be confused with that of a Beam Splitter. By swapping the modes and maintaining the convention that “mode 0 is the top mode in the diagram” we apply the transformation

PERM10:|n0n101|n1n001

images

Figure 11: Permutation of the two modes of a Fock state realizing the X gate.

For an arbitrary qubit state (α|0+β|1), this corresponds to the action of the Xgate:

PERM10(α|0+β|1)=PERM10(α|1001+β|0101)

=αPERM10(|1001)+βPERM10(|0101)

=α|0101+β|1001

=α|1+β|0

We indeed recover the effect of the Pauli-X gate (Fig. 12).

images

Figure 12: Equivalent of the X gate on qubits using PERM on the Fock state.

4.3 Realization of the SWAP Gate

We now focus on the standard SWAP gate applied to qubits. Compared to the X gate described earlier, we must redefine the permutation over all four modes, rather than just two.

To define a gate that swaps qubit 1 with qubit 2, i.e., performs the following operation:

SWAP|10=|01

One can use the following permutations:

01232301

A visualization is given in Fig. 13.

images

Figure 13: Mode permutations to define a permutation gate.

On an arbitrary 2-qubit state:

α|00+β|01+γ|10+μ|11

We apply PERM2301:

PERM2301(α|00+β|01+γ|10+μ|11)

=αPERM2301|00+βPERM2301|01+γPERM2301|10+μPERM2301|11

On Fock states

=αPERM2301|01010123+βPERM2301|01100123+γPERM2301|10010123+μPERM2301|10100123

=α|01010123+β|10010123+γ|01100123+μ|10100123

=α|00+β|01+γ|01+μ|11

This is exactly the expected action of SWAP on qubits.

4.4 Realization of the H Gate

Let us consider the expression obtained for the Beam Splitter introduced in Section 2 (see (13)) :

BSH=12(cos(θ2)sin(θ2)sin(θ2)cos(θ2))

If we choose θ=π2 and consider ϕ=0 for all the phases involved, then

BSH(θ=π2)=H=12(1111)

We immediately obtain the H gate and a representation is introduced in Fig. 14.

images

Figure 14: Realization of the H-gate with a beam splitter.

But this BSH matrix is not directly acting on qubits; here is how to analyze how it acts on qubits:

The matrix of BSH acts on Fock states, we use the formalism of the Section 4.1 which gave:

{a^0BSH(π2)12(a^0+a^1)a^1BSH(π2)12(a^0a^1)

Let us describe the effect on the basis states of a qubit:

|0=|1001=a^0|0001BSH(π2)12(a^0+a^1)|0001=12(|0101+|1001)=12(|0+|1)

|1=|0101=a^1|0001BSH(π2)12(a^0a^1)|0001=12(|0101|1001)=12(|0|1)

This is exactly what we would expect of H applied onto qubits.

4.5 Realization of Z Gate

To implement Z, one must apply a phase shift of π on mode 1 which is initially in the state |0101=|1 leading to:

PS1(π)|0=PS1(π).(|1001)=|1001=|0

PS1(π)|1=PS1(π).(|0101)=|0101=|1

This describes the action of the Z gate on all the basis states of a qubit therefore describing completely the action of Z. A representation of the circuit is given in Fig. 15.

images

Figure 15: Realization of the Z-gate with a phase shifter.

4.6 Realization of the Y Gate

To implement the Y gate, we use will use 3 optical components:

•   A Beam Splitter

•   2 Phase shifters

Reminder

Y|0=Y(10)=(0ii0)(10)=(0i)=i.|1

Y|1=Y(01)=(0ii0)(01)=(i0)=i.|0

Using this reminder, let us prove the following statement:

Theorem 5:

Y=PS1(π2).PS0(π2).PERM10

Proof: Let us consider |ψ=(αβ) an arbitrary qubit state, we will show that the action of the circuit and the Y gate are the same.

We have:

PS1(π2).PS0(π2).PERM10(α|0+β|1)

=PS1(π2).PS0(π2).PERM10(α|1001+β|0101)

=PS1(π2).PS0(π2).(α|0101+β|1001)

=PS1(π2).PS0(π2).(α|1+β|0)

=PS1(π2).PS0(π2)(βα)

=PS1(π2).(βei.t.π2α)

=(iβiα)

And by consequence

PS1(π2).PS0(π2).PERM10(αβ)=(iβiα)

And as:

Y(αβ)=(0ii0)(αβ)=(iβiα)

So we conclude that

PS1(π2).PS0(π2).PERM10=Y

This expression corresponds to the photonic circuit introduced in Fig. 16.

images

Figure 16: Photonic circuit for the Y gate on a qubit.

4.7 Realization of the RX(θ) Gate

Recall that according to (14), the definition of RX(θ) is:

RX(θ)=eiXθ2=(cosθ2i.sinθ2i.sinθ2cosθ2)

The Perceval computing library natively provides a gate named BSRx as the default convention for the Beam Splitter. However, the definition of the gate provided by the library is

BSRx=(cos(θ2)isin(θ2)isin(θ2)cos(θ2))

and does not directly correspond to the usual RX gate.

Theorem 6:

RX(θ)=PS0(π).BSRx(θ).PS0(π)

Proof: Once again, let us consider |ψ=(αβ) an arbitrary qubit state, We will show that the action of the circuit is the same as that of the RX gate.

We have:

RX(θ)(αβ)=(cosθ2isinθ2isinθ2cosθ2)(αβ)

=(αcosθ2iβsinθ2iαsinθ2+βcosθ2)

and we have:

PS0(π).BSRx(θ).PS0(π)(αβ)=PS0(π).BSRx(θ).(αβ)

Because

BSRx(θ)=(cosθ2isinθ2isinθ2cosθ2)

We have:

PS0(π).BSRx(θ).PS0(π)(αβ)=PS0(π).(αcosθ2+iβsinθ2iαsinθ2+βcosθ2)

PS0(π).BSRx(θ.)PS0(π).(αβ)=(αcosθ2iβsinθ2iαsinθ2+βcosθ2)

Therefore:

PS0(π).BSRx(θ).PS0(π)=RX(θ)

The photonic circuit representation is shown in Fig. 17.

images

Figure 17: Quantum circuit for the RX(θ) gate on qubits.

4.8 Realization of the RY(θ) Gate

Let us note that:

RY(θ)=(cosθ2sinθ2sinθ2cosθ2)

The definition of the component BSRy provided by the library [15] is exactly that of the standard RY gate and the photonic representation of the gate is shown in Fig. 18.

images

Figure 18: Representation of the photonic circuit associated with RY.

For completion, we can use the formalism of Section 4.1 on BSRy, thus get

{a^0BSRycosθ2a^0+sinθ2a^1a^1RY(θ)sinθ2a^0+cosθ2a^1

Starting from the two basis states of a qubit, we get:

|0=|1001=a^0|0001BSRy(cosθ2a^0+sinθ2a^1)|0001=cosθ2|1001+sinθ2|0101=cosθ2|0+sinθ2|1

|1=|0101=a^1|0001BSRy(sinθ2a^0+cosθ2a^1)|0001=sinθ2|1001+cosθ2|0101=sinθ2|0+cosθ2|1

This is exactly how the Ry gate acts on qubits.

4.9 Realization of the RZ(θ) Gate

To rebuild the RZ rotation gate, we start by recalling that

RZ(θ)=(ei.θ200ei.θ2)

Theorem 7:

RZ(θ)=BSH.PS0(π).BSRx(θ).PS0(π).BSH

Proof: Let us consider |ψ=(αβ). We have:

RZ(θ)(αβ)=(eiθ200eiθ2)(αβ)=(αeiθ2βeiθ2)

and

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=BSH.PS0(π).BSRx(θ).PS0(π)12(1111)(αβ)

=BSH.PS0(π).BSRx(θ).PS0(π)12(α+βαβ)

Because

PS0(π)|0=PS0(π)|1001=eiπ|1001=|0

PS0(π)|1=PS0(π)|0101=|0101=|1

We have

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=BSH.PS0(π).BSRx(θ).12((α+β)αβ)

Because

BSRx(θ)=(cosθ2i.sinθ2isinθ2cosθ2)

We have

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=BSH.PS0(π).(cosθ2isinθ2i.sinθ2cosθ2).12((α+β)αβ)

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=BSH.PS0(π).12((α+β)cosθ2+i(αβ)sinθ2i.(α+β)sinθ2+(αβ)cosθ2)

and

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=BSH.12((α+β)cosθ2i(αβ)sinθ2i.(α+β)sinθ2+(αβ)cosθ2)

and

BSH.PS0(π).BSRx(θ).PS0(π).BSH.(αβ)=12(1111).12((α+β)cosθ2i(αβ)sinθ2i.(α+β)sinθ2+(αβ)cosθ2)

=12((α+β)cosθ2i(αβ)sinθ2i.(α+β)sinθ2+(αβ)cosθ2(α+β)cosθ2i(αβ)sinθ2+i.(α+β)sinθ2(αβ)cosθ2)

=12(2.αcosθ22.i.αsinθ22.βcosθ2+2.β.i.sinθ2)

=(αcosθ2i.αsinθ2βcosθ2+β.i.sinθ2)

So

BSH.PS0(π).BSRx(θ).PS0(π).BSH.=(ei.θ2αei.θ2β)=RZ(θ)(αβ)=(αei.θ2βei.θ2)

The photonic representation of the gate is shown in Fig. 19.

images

Figure 19: Representation of the photonic circuit associated to RZ.

5  Modelling Controlled Gates

5.1 Realization of CX According to [14]

Consider the definition of CX as defined by [27] and originally proposed by [14], with a description provided in Fig. 20.

images

Figure 20: Ralph CNOT circuit from [14].

This figure presents a method for implementing a CNOT gate based on 6 modes representing two qubits and two auxiliary modes. The modes Ca and Cb correspond to the control qubit in the CNOT we wish to realize. Thus |01CaCb represents the Fock state associated with the control qubit in the state |1=|01CaCb. Similarly, we define Ta and Tb as the modes for the “Target” qubit. Additionally, we have two auxiliary modes Ac and At which act on the control and target qubits, respectively. Both auxiliary modes are initialized in the states |0Ac and |0At.

To explain the CNOT operation, we need to distinguish between the input and output parts of the CNOT for a given mode. For instance, we distinguish CaE, the first input mode for the control qubit, from CaS, the first output mode for the control qubit. Making this distinction allows us to express the output modes as functions of the input modes.

Before diving into the explanation of the CNOT operation, let us highlight two important elements:

•   Each Beam Splitter has a dashed side, which is the side that will receive a phase shift (the side that will receive the minus sign in the chosen convention).

•   We consider two types of Beam Splitters: some with a reflectivity of R=12 (symmetric Beam Splitters) and others with a reflectivity of R=13 (asymmetric Beam Splitters).

Notes

It is important to recall that for a Beam Splitter with reflectivity α, and whose graphical representation corresponds to the dashed side facing upward, two output states are defined:

•   The state C undergoes a phase shift of value −1 since it is on the dashed side, and the fraction of A that is reflected by the Beam Splitter is α;

•   The fraction of B that “passes through” the Beam Splitter is 1α.

This leads to the output C=α.A+1α.B with the phase of B unchanged since B corresponds to the side of the Beam Splitter without the dashed lines (Fig. 21).

images

Figure 21: Output amplitudes of a beam splitter with reflectivity α.

By observing Fig. 20, we can establish the following relations:

AcS=13(AcE+2CaE)

CaS=13(CaE+2AcE)

CaS=13(2CaE+AcE)

CbS=13CbE+12×(23TaE+23TbE)=13(TaE+TbECbE)

TaS=23×12CbE+(12×13×12firstpath+12×13×12secondpath)TaE+(12×13×12firstpath+(12)×13×12secondpath)TbE+23×12AtE

Giving:

TaS=13(CbE+TaE+AtE)

TbS=13(CbE+TbEAtE)

AtS=13(TaE+TbEAtE)

Remark

By choosing a different reflectivity R, we would obtain different values for each relation.

Example with R=14:

TaS=122CbE+32TaE+122AtE

Note 1

The creation and annihilation operators associated with a mode 0 are denoted a^0 and a^0, respectively, and their actions are as follows:

•   The creation operator a^0 allows the transition from |00 to |10 on the spatial mode 0. For example, a^0 transitions from |0001 (vacuum state) to |1001.

•   The annihilation operator a^0 allows the transition from |10 to |00. For example, a^0 transitions from |1001 to |0001(vacuum state).

Note 2

Strictly speaking, the creation operator on the output mode i should be denoted as ai

For convenience and simplicity, we will use the shorthand notation (i) for the creation operator on the output mode i.

For example:

(AcS)aAcS

The creation operator on the output modes can be deduced from the previous relations. For example, we have:

(AcS)Creation operator ofoutput mode AcS=13((AcE)+2(CaE))

The final state of a two-qubit system (4 modes), to which we add the two auxiliary modes that we reorganize for clarity, can be written as:

|ψin=α|00+β|01+γ|10+δ|01qubits|0005Fockstateofauxiliarymodes

This state can be described in terms of Fock states and creation operators by considering only the 4 output qubits. So the state:

|ψin=α|10101234+β|10011234+γ|01101234+δ|10011234|10101234

is rewritten:

|ψin=(α((CaS)(TaS)|00001234)+β((CaS)(TbS)|00001234)+γ((CbS)(TaS)|00001234)+δ((CbS)(TbS)|00001234))|001234

Now, let us consider each term separately.

For the first term

α((CaS)(TaS)|0000f)

=α((13((CaE)+2(AcE)))×(13((CbE)+(TaE)+(AtE)))|00001234)

=α3(((CaE)(CbE)+(CaE)(TaE)+(CaE)(AtE)+2(AcE)(CbE)+2(AcE)(TaE)+2(AcE)(AtE))|0000f)

For the second term

β((CaS)(TbS)|0000f)

=β((13((CaE)+2(AcE))13((CbE)+(TbE)(AtE)))|0000f)

=β3(((CaE)(CbE)+(CaE)(TbE)(CaE)(AtE)+2(AcE)(CbE)+2(AcE)(TbE)2(AcE)(AtE))|0000f)

For the third term

γ((CbS)(TaS)|0000f)

=γ(13(TaE+TbECbE)×13(CbE+TaE+AtE)|0000f)

=γ3(((TaE)(CbE)+(TaE)(TaE)+(TaE)(AtE)+(TbE)(CbE)+(TbE)(TaE)+(TbE)(AtE)(CbE)(CbE)(CbE)(TaE)(CbE)(AtE))|0000f)

For the last term

δ((CbS)(TbS)|0000f)

=δ(13(TaE+TbECbE)13(CbE+TbEAtE)|0000f)

=δ3(((TaE)(CbE)+(TaE)(TbE)(TaE)(AtE)+(TbE)(CbE)+(TbE)(TbE)(TbE)(AtE)(CbE)(CbE)(CbE)(TbE)+(CbE)(AtE))|0000f)

It is necessary to apply a post-selection on the resulting states to retain only the states having:

•   Exactly one photon on the control side (CaE) or (CbE) but not (CaE)(CbE)

•   Exactly one photon on the target side (TaE) or (TbE) but not (TaE)(TbE)

•   No photons on the auxiliary modes: remove all terms involving (AcE) or (AtE)

Thus, by grouping the four terms and removing the terms corresponding to the post selection conditions mentioned previously:

|ψout=α3(((CaE)(CbE)+(CaE)(TaE)+(CaE)(AtE)+2(AcE)(CbE)+2(AcE)(TaE)+2(AcE)(AtE)))

+β3(((CaE)(CbE)+(CaE)(TbE)(CaE)(AtE)+2(AcE)(CbE)+2(AcE)(TbE)2(AcE)(AtE))|0000f)

+γ3(((TaE)(CbE)+(TaE)(TaE)+(TaE)(AtE)+(TbE)(CbE)+(TbE)(TaE)+(TbE)(AtE)(CbE)(CbE)(CbE)(TaE)(CbE)(AtE))|0000f)

+δ3(((TaE)(CbE)+(TaE)(TbE)(TaE)(AtE)+(TbE)(CbE)+(TbE)(TbE)(TbE)(AtE)(CbE)(CbE)(CbE)(TbE)+(CbE)(AtE))|0000f)

After removing the terms, we obtain:

|ψout=α3((CaE)(TaE)|0000f)+β3((CaE)(TbE)|0000f)+γ3((TbE)(CbE)|0000f)+δ3((TaE)(CbE)|0000f)

|ψout=α3(|1010f)+β3(|1001f)+γ3(|0101f)+δ3(|0110f)

|ψout=13(α|00+β|01+γ|11+δ|01)

We almost recover the expected action of the CNOT gate: (α|00+β|01+γ|11+δ|01) up to a factor of 13.

Example

If we started from the state |ψ=|10 meaning γ=1 we obtain:

|ψout=13|11

We do not always find ourselves in this situation whenever we use our CNOT, and the value 13 is the probability amplitude associated with the success of the CNOT.

Remark

Ralph’s CNOT gate is a “simple” way to implement the CNOT gate on photonic computers using dual-rail encoding. However, the application of this gate succeeds only 1 time out of 9. This limitation is not an error rate that can be corrected with hardware improvements. It is a real fundamental limit intrinsic to the functioning of Ralph’s CNOT gate.

Note that the calculation starts by defining θ=2×arccos(13)1.91 where 1/3 is the reflectivity (the proportion of photons reflected by the Beam Splitter). Consider the circuit in Fig. 20, where we start with two qubits (a CNOT gate acts on two qubits), meaning 4 modes, and we need two auxiliary modes for this definition of the CNOT.

For two qubits in the state |00 as input, from the perspective of Fock states, we have the state:

|ψ0=|00(|11|02)controlqubit|0(|13|04)targetqubit|0|05

In this implementation (originally proposed by [14]), the two auxiliary modes are:

•   Mode 0 which appears in the first position in Fig. 20;

•   Mode 5 which appears in the last position in Fig. 20.

Conclusion for Ralph’s CNOT: The implementation of the CX gate proposed by [14] is limited to circuits that use only a single CNOT. When a circuit contains two CNOT gates, as shown in Fig. 22 and the success conditions depend on modes that are shared with the second CNOT. While the auxiliary modes do not create a problem, the modes shared between the two CNOTs cannot be post-selected in the middle of the circuit. The CNOT gate from [14] has a success probability of 19.

images

Figure 22: Incorporating two CNOT gates in a single circuit: infeasibility of implementation using the CNOT scheme by [14].

5.2 Implementation of the CXij of [13] Using the Library [27]

There exist different ways to implement the CX gates. One other way to implement it is to use the one of [13] called heralded CX.

The heralded CX gate was proposed by Knill in 2001, and its main advantage lies in the fact that it is sufficient to measure the auxiliary qubits to determine whether the CX operation was successful. Thereby allowing to put multiple of them in the same circuit. However, its success probability is only 227. To implement a photonic quantum circuit, the Perceval Library provides the CX gate from [13]. It is available in the “catalog” under the Name “heralded cnot”.

Just as for Ralph’s CX, two auxiliary modes are required, which in this case correspond to modes 4 and 5. Note that unlike the CX gate by [14], the heralded version requires both auxiliary qubits to be in state 1 at the input. Thus, the conditions for identifying a successful CNOT operation are that modes 4 and 5 must be equal to 1 at the output. There is no need to verify that we have exactly one photon on the modes representing the qubits.

An implementation using the library is given in (Appendix B).

5.3 Implementation the CX of Ralph and the Library [27]

The CX gate proposed by Ralph is also appearing in Perceval’s catalogue under the name “postprocessed cnot”. Therefore, you can easily build a quantum circuit using it. A code example is given in (Appendix A).

To implement this CX using the library, the only difference with the description given in Section 5.1 Realization of CX according to [14] lies in the location of two control modes. They are now located at positions 4 and 5. While in Section 5.1, the auxiliary modes were modes 0 and 5 Therefore, the conditions for identifying a successful CNOT operation are:

•   modes 0 and 1 define a qubit (have exactly one photon);

•   modes 2 and 3 define a qubit (have exactly one photon);

•   modes 4 and 5 are equal to 0.

5.4 Representation of Gates CZij and CYij

For two qubits i and j, the implementation of the gates CZij and CYij can be done simply since CZij=Hj.CXij.Hj and CYij=Sj.CXij.Sj=R1j(π2).CXij.R1j(π2)

5.5 Summary

Table 2 provides the correspondence between quantum operators on qubits and photonic components, along with the Perceval code associated with their implementation.

images

6  Conclusion

This article presents the foundational concepts of photonic quantum computing from an operator- and computation-oriented perspective, providing a state-of-the-art overview of quantum gates within a universal formalism. Beam splitters and phase shifters are introduced, along with a physical description of their action on spatial modes, offering a comprehensive view of photonic quantum computers. Each basic gate is expressed in matrix form, and we demonstrate how standard quantum computation gates can be implemented using photonic components. The gates are decomposed into optical elements according to the KLM protocol and employing dual-rail encoding. Basic elements for programming with Quandela’s Perceval library are included in the Appendix Section to facilitate practical implementation of these concepts. Particular emphasis is placed on different CNOT realizations, specifically the heralded CNOT and the Ralph CNOT, highlighting their differences, advantages, and limitations.

Acknowledgement: Authors have used ChatGPT to improve English skill.

Funding Statement: This work was done within the scope of a Ph.D which is funded by CGI for author Martin Bombardelli. Philippe Lacomme, Gerard Fleury and Bogdan Vulpescu are financed by a public laboratory in France (LIMOS, LIMOS and LPCA, respectively).

Author Contributions: The authors confirm contribution to the paper as follows: Conceptualization, Martin Bombardelli, Philippe Lacomme and Bogdan Vulpescu; methodology, Martin Bombardelli, Philippe Lacomme, Bogdan Vulpescu and Gérard Fleury; software, Martin Bombardelli, Philippe Lacomme and Bogdan Vulpescu; validation, Martin Bombardelli, Philippe Lacomme, Bogdan Vulpescu and Gérard Fleury; formal analysis, Martin Bombardelli, Philippe Lacomme, Bogdan Vulpescu and Gérard Fleury; investigation, Martin Bombardelli, Philippe Lacomme, Bogdan Vulpescu and Gérard Fleury. All authors reviewed and approved the final version of the manuscript.

Availability of Data and Materials: Not applicable.

Ethics Approval: Not applicable.

Conflicts of Interest: The authors declare no conflicts of interest.

Appendix A Ralph Cnot

import perceval as pcvl

import numpy as np

def toFockState(qubitState):

pe = {0: [1,0], 1: [0,1], 2: [0,1]}

res = pe [qubitState [0]] + pe [qubitState [1]] + pe [qubitState

[2]]

return res

def strState(state):

return str(pcvl.BasicState(state))

from perceval.components import PS, BS, PERM

import perceval as pcvl

import numpy as np

from perceval.components import BS

theta_13 = BS.r_to_theta(r=1/3)

cnot = (pcvl.Circuit(6, name =Ralph CNOT)

.add((0, 1), BS.H(theta_13, phi_bl = np.pi,

phi_tr = np.pi/2, phi_tl = -np.pi/2))

.add((3, 4), BS.H())

.add((2, 3), BS.H(theta_13, phi_bl = np.pi,

phi_tr = np.pi/2, phi_tl = -np.pi/2))

.add((4, 5), BS.H(theta_13))

.add((3, 4), BS.H()))

# 1.initialisation

istate = [0,1,0,1,0,0]

# 2.test of thecnot

circuit = pcvl.Circuit(6)

circuit.add(0,PERM([0,1,2,4,3,5]))

circuit.add(0,PERM([0,1,3,2,4,5]))

circuit.add(0,PERM([0,2,1,3,4,5]))

circuit.add(0,PERM([1,0,2,3,4,5]))

circuit.add(0,cnot)

circuit.add(0,PERM([1,0,2,3,4,5]))

circuit.add(0,PERM([0,2,1,3,4,5]))

circuit.add(0,PERM([0,1,3,2,4,5]))

circuit.add(0,PERM([0,1,2,4,3,5]))

# 3. Displaying the circuit

pcvl.pdisplay(circuit.compute_unitary())

print(““)

pcvl.pdisplay(circuit)

# 4. Simulation

p = pcvl.Processor(SLOS, circuit)

p.set_postselection(pcvl.PostSelect([0,1]==1 & [2,3]==1 & [4]==0 & [5]==0))

nsample = 50,000

from perceval.algorithm import Sampler, Analyzer

sampler = Sampler (p)

p.with_input (pcvl.BasicState ([0, 1, 0, 1, 0, 0]))

output = sampler.sample_count (1000)

pcvl.pdisplay (output[‘results’], output_format = pcvl.Format.TEXT)

Appendix B Heralded Cnot

import perceval as pcvl

import numpy as np

from perceval.components import PS, BS, PERM

import perceval as pcvl

import numpy as np

from perceval.components import BS

from perceval.components import catalog

cnot = catalog [‘heraldedcnot].build_circuit()

# 1.initialization

istate = [0, 1, 0, 1, 1, 1]

# 2.test of thecnot

circuit = pcvl.Circuit(6)

circuit.add(0,cnot)

# 3. Displaying the circuit

pcvl.pdisplay(circuit.compute_unitary())

print(““)

pcvl.pdisplay(circuit)

# 4calculation

p = pcvl.Processor(SLOS, circuit)

p.set_postselection(pcvl.PostSelect([4]==1 & [5]==1))

nsample = 50,000

from perceval.algorithm import Sampler, Analyzer

sampler = Sampler (p)

p.with_input (pcvl.BasicState (istate)) #Corresponds to logical

qubit state

output = sampler.sample_count (1000)

pcvl.pdisplay (output [‘results’], output_format =

pcvl.Format.TEXT)

print(‘end’)

Appendix C CCNOT

import perceval as pcvl

import numpy as np

from perceval.components import PS, BS, PERM

import perceval as pcvl

import numpy as np

from perceval.components import BS

from perceval.components import catalog

ccnot = catalog [toffoli].build_circuit()

# 1.initialisation

istate = [0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]

# 2.Cnot

circuit = pcvl.Circuit(12)

circuit.add(0,ccnot)

# 3.print of the circuit

pcvl.pdisplay(circuit.compute_unitary())

print(““)

pcvl.pdisplay(circuit)

# 4Computation

p = pcvl.Processor(SLOS, circuit)

p.set_postselection(pcvl.PostSelect([0,1]==1 & [2,3]==1 & [6]==0 & [7]==0 & [8]==0 & [9]==0 & [10]==0 & [11]==0))

nsample = 1000

from perceval.algorithm import Sampler, Analyzer

sampler = Sampler (p)

p.with_input (pcvl.BasicState (istate)) #Corresponds to logical

qubit state

output = sampler.sample_count (nsample)

print(output [‘results’])

pcvl.pdisplay (output [‘results’], output_format =

pcvl.Format.TEXT)

print(‘end’)

Appendix D Perceval Implementation of PERM1023

Step 1. Circuit Initialization

This can be done by initializing qubits and then converting them into a Fock state.

For example, starting from the state |10 the corresponding code would be:

qubit_istate = [1, 0]

istate = toFockState(qubit_istate)

Step 2. Define the circuit composed of 2 qubits, i.e., 4 Fock modes

circuit = pcvl.Circuit(4)

Step 3. Add an X gate to the circuit, applied to the first qubit

The associated code is:

circuit.add(0,PERM([1, 0, 2, 3]))

#orcircuit.add(0,PERM([1,0]))

Step 4. Display the circuit

pcvl.pdisplay(circuit.compute_unitary())

print(““)

pcvl.pdisplay(circuit)

Step 5. Perform the computation

backend = pcvl.BackendFactory().get_backend(Naive)

backend.set_circuit(circuit)

backend.set_input_state(pcvl.BasicState(istate))

Step 6. Define the possible output states

output_qubit_states = [

[x1,x2]

for x1 in [0, 1] for x2 in [0, 1]

]

Step 7. Display the results

for oqstate in output_qubit_states:

ostate = toFockState(oqstate)

a = backend.prob_amplitude(pcvl.BasicState(ostate))

print(strState(ostate), ->,strState(oqstate), a)

print(‘end’)

References

1. Manin Y. Computable and uncomputable. Moscow, Russia: Sovetskoye Radio; 1980. 128 p. [Google Scholar]

2. Anonymous. 40 years of quantum computing. Nat Rev Phys. 2022;4(1):1. doi:10.1038/s42254-021-00410-6. [Google Scholar] [CrossRef]

3. Benioff P. The computer as a physical system: a microscopic quantum mechanical Hamiltonian model of computers as represented by Turing machines. J Stat Phys. 1980;22(5):563–91. doi:10.1007/BF01011339. [Google Scholar] [CrossRef]

4. Buluta I, Nori F. Quantum simulators. Science. 2009;326(5949):108–11. doi:10.1126/science.1177838. [Google Scholar] [PubMed] [CrossRef]

5. Feynman RP. Simulating physics with computers. In: Feynman and computation. Boca Raton, FL, USA: CRC Press; 2018. p. 133–53. [Google Scholar]

6. Deutsch D. Quantum theory, the church-turing principle and the universal quantum computer. Proc R Soc Lond Ser A Math Phys Sci. 1985;400(1818):97–117. [Google Scholar]

7. Deutsch D, Jozsa R. Rapid solution of problems by quantum computation. Proc R Soc Lond Ser A Math Phys Sci. 1992;439(1907):553–8. doi:10.1098/rspa.1992.0167. [Google Scholar] [CrossRef]

8. Grover LK. A fast quantum mechanical algorithm for database search. In: Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing—STOC’96; 1996 May 22–24; Philadelphia, PA, USA. p. 212–9. doi:10.1145/237814.237866. [Google Scholar] [CrossRef]

9. Shor PW. Algorithms for quantum computation: discrete logarithms and factoring. In: Proceedings 35th Annual Symposium on Foundations of Computer Science; 1994 Nov 20–22; Santa Fe, NM, USA. p. 124–34. doi:10.1109/SFCS.1994.365700. [Google Scholar] [CrossRef]

10. Chuang IL, Yamamoto Y. Simple quantum computer. Phys Rev A. 1995;52(5):3489–96. doi:10.1103/physreva.52.3489. [Google Scholar] [PubMed] [CrossRef]

11. Fock V. Configuration space and second quantization. In: V.A. Fock-selected works: quantum mechanics and quantum field theory. Boca Raton, FL, USA: CRC Press; 2004. p. 191–220. doi:10.1201/9780203643204.ch5b. [Google Scholar] [CrossRef]

12. Knill E, Laflamme R, Milburn GJ. A scheme for efficient quantum computation with linear optics. Nature. 2001;409(6816):46–52. doi:10.1038/35051009. [Google Scholar] [PubMed] [CrossRef]

13. Knill E. Quantum gates using linear optics and postselection. Phys Rev A. 2002;66(5):052306. doi:10.1103/physreva.66.052306. [Google Scholar] [CrossRef]

14. Ralph TC, White AG, Munro WJ, Milburn GJ. Simple scheme for efficient linear optics quantum gates. Phys Rev A. 2001;65(1):012314. doi:10.1103/physreva.65.012314. [Google Scholar] [CrossRef]

15. Raussendorf R, Briegel HJ. A one-way quantum computer. Phys Rev Lett. 2001;86(22):5188–91. doi:10.1103/physrevlett.86.5188. [Google Scholar] [PubMed] [CrossRef]

16. Yu Y, Chi Y, Zhai C, Huang J, Gong Q, Wang J. Simulating Hamiltonian dynamics in a programmable photonic quantum processor using linear combinations of unitary operations. arXiv:2211.06723. 2022. [Google Scholar]

17. Riso AL, Thyagarajan K, Whiting C, Jimenez K. Constructing a photonic implementation of quantum key distribution. arXiv:2509.04389. 2025. [Google Scholar]

18. Zahidy M, Mikkelsen MT, Müller R, Da Lio B, Krehbiel M, Wang Y, et al. Quantum key distribution using deterministic single-photon sources over a field-installed fibre link. npj Quantum Inf. 2024;10(1):2. doi:10.1038/s41534-023-00800-x. [Google Scholar] [CrossRef]

19. Zhang Y, Ding X, Li Y, Zhang L, Guo YP, Wang GQ, et al. Experimental single-photon quantum key distribution surpassing the fundamental coherent-state rate limit. arXiv:2406.02045. 2024. [Google Scholar]

20. Baldazzi A, Azzini S, Pavesi L. Resource-efficient variational quantum solver for the travelling salesman problem and its silicon photonics implementation. arXiv:2511.02696. 2025. [Google Scholar]

21. Baldazzi A, Sanna M, Borghi M, Azzini S, Pavesi L. Four-qubit variational algorithms in silicon photonics with integrated entangled photon sources. arXiv:2501.01301. 2025. [Google Scholar]

22. Abbassi A, Dujardin Y, Gourdin E, Lacomme P, Prodhon C. Quantum approaches to the minimum edge multiway cut problem. arXiv:2601.00720. 2026. [Google Scholar]

23. Aaronson S, Arkhipov A. The computational complexity of linear optics. In: Proceedings of the Forty-Third Annual ACM Symposium on Theory of Computing. San Jose, CA, USA: ACM; 2011. p. 333–42. doi:10.1145/1993636.1993682. [Google Scholar] [CrossRef]

24. Zhong HS, Wang H, Deng YH, Chen MC, Peng LC, Luo YH, et al. Quantum computational advantage using photons. Science. 2020;370(6523):1460–3. doi:10.1126/science.abe8770. [Google Scholar] [PubMed] [CrossRef]

25. Romero J, Milburn G. Photonic quantum computing. arXiv:2404.03367. 2024. [Google Scholar]

26. Campos R, Saleh B, Teich M. Quantum-mechanical lossless beam splitter: SU(2) symmetry and photon statistics. Phys Rev A Gen Phys. 1989;40(3):1371–84. doi:10.1103/physreva.40.1371. [Google Scholar] [PubMed] [CrossRef]

27. Heurtel N, Fyrillas A, de Gliniasty G, Le Bihan R, Malherbe S, Pailhas M, et al. Perceval: a software platform for discrete variable photonic quantum computing. Quantum. 2023;7:931. doi:10.22331/q-2023-02-21-931. [Google Scholar] [CrossRef]

28. Hong C, Ou Z, Mandel L. Measurement of subpicosecond time intervals between two photons by interference. Phys Rev Lett. 1987;59(18):2044–6. doi:10.1103/PhysRevLett.59.2044. [Google Scholar] [PubMed] [CrossRef]


Cite This Article

APA Style
Bombardelli, M., Fleury, G., Lacomme, P., Vulpescu, B. (2026). Foundations of Photonic Quantum Computation. Part 1. Introduction to Quantum Operators. Journal of Quantum Computing, 8(1), 13–54. https://doi.org/10.32604/jqc.2026.075438
Vancouver Style
Bombardelli M, Fleury G, Lacomme P, Vulpescu B. Foundations of Photonic Quantum Computation. Part 1. Introduction to Quantum Operators. J Quantum Comput. 2026;8(1):13–54. https://doi.org/10.32604/jqc.2026.075438
IEEE Style
M. Bombardelli, G. Fleury, P. Lacomme, and B. Vulpescu, “Foundations of Photonic Quantum Computation. Part 1. Introduction to Quantum Operators,” J. Quantum Comput., vol. 8, no. 1, pp. 13–54, 2026. https://doi.org/10.32604/jqc.2026.075438


cc Copyright © 2026 The Author(s). Published by Tech Science Press.
This work is licensed under a Creative Commons Attribution 4.0 International License , which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
  • 35

    View

  • 17

    Download

  • 0

    Like

Share Link