Large-scale photonic cluster state generation

Abstract

Methods and apparatus for generating multidimensional photonic cluster states use a recurrent quantum photonic neural network (QPNN) including a nonlinear component and a delay device. Using a recurrent QPNN, unit cells may be constructed and connected deterministically with near-unity efficiency. By recurrently feeding back select output photons into the quantum photonic neural network during subsequent operations, the QPNN both generates new unit cells and links them to the existing unit cells, thereby generating multidimensional photonic cluster states with high generation rates and arbitrarily large in scale.

Description

[0001] LARGE-SCALE PHOTONIC CLUSTER STATE GENERATION

[0002] RELATED APPLICATION

[0003] This application claims the benefit of the filing date of Application No. 63 / 645,511, filed 10 May 2024, the contents of which are incorporated herein by reference in their entirety.

[0004] FIELD

[0005] The invention relates generally to photonic cluster states used in fields such as quantum computation and communication. More specifically, the invention relates to generating multidimensional photonic cluster states at high generation rates and arbitrarily large in scale.

[0006] BACKGROUND

[0007] Photonic cluster states (i.e., large-scale maximally entangled states of light) have been proposed as a fundamental resource for measurement-based quantum optical computation and communication protocols since they provide an inherent and necessary tolerance to both photon loss and decoherence of multipartite quantum entanglement. To date, cluster states have been limited to around ten photons and millihertz (mHz) generation rates due to the difficulty of efficiently and deterministically entangling photons in a controlled manner.

[0008] Currently, protocols for photonic cluster state generation rely on either solely linear optics or manipulating the spins of sold-state quantum emitters (e.g., quantum dots), e.g., [1], Neither protocol has led to large-scale cluster state generation since those based on linear optics are probabilistic, with a low success probability for each entanglement event, while the spin-state of quantum dots decoheres rapidly (about 100 ns), significantly limiting the number of operations that can be completed. In a photonic cluster state, photonic qubits must be entangled by applying controlled-PHASE operations between them. With a purely linear-optical apparatus, these operations are intrinsically probabilistic and thus require a significant, currently unavailable, resource overhead to generate large-scale cluster states. In contrast, other approaches have mapped the controlled- PHASE operations onto single-photon quantum emitters such that they can be applied deterministically, then transferred to the emitted photons. These approaches require active control of the internal states of the quantum emitters which is difficult to achieve experimentally and limited by the short decoherence times of these states. Specifically, the emitted photons will only be entangled in a cluster state as long as the emitter remains coherent. Thus, there is a limit to the number of photons that can be clustered together with these approaches. Furthermore, it remains difficult to reach this limit due to the significant experimental complexity of actively controlling the internal spin states of a single-photon quantum emitter.

[0009] SUMMARY

[0010] One aspect of the invention relates to a method for generating a multidimensional photonic cluster state, comprising: using an emitter to emit photons; using apparatus comprising a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type, wherein: (i) when the input is one photon the QPNN routes the photon to the delay device; (ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cell; repeating (i) and (ii) to generate a plurality of unit cells; routing at least one photon from each unit cell through the delay device and the QPNN according to a timing protocol implemented by a controller to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

[0011] In various embodiments the selected multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state. In some embodiments, all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

[0012] In one embodiment the selected multidimensional cluster state type is a tree-type cluster state, the method comprising: (i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device; (ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the tree-type cluster state are formed; (iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and (iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

[0013] In one embodiment the delay device comprises a plurality of optical delay lines and an optical switch.

[0014] In one embodiment the plurality of optical delay lines are static delay lines.

[0015] In one embodiment the at least a portion of the plurality of optical delay lines are dynamic delay lines.

[0016] In one embodiment the delay device comprises a quantum memory.

[0017] In one embodiment an uppermost two optical modes of the QPNN are optically connected to the input of the delay device.

[0018] In one embodiment the emitter emits single photons in accordance with the timing protocol.

[0019] In one embodiment, when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell.

[0020] Another aspect of the invention relates to an apparatus for generating a multidimensional photonic cluster state, comprising: an emitter that emits photons; a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type; and a controller; wherein: (i) when the input is one photon the QPNN routes the photon to the delay device; (ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cell; wherein (i) and (ii) are repeated to generate a plurality of unit cells; wherein the controller implements a timing protocol that routes at least one photon from each unit cell through the delay device and the QPNN to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

[0021] In various embodiments the selected multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state.

[0022] In some embodiments, all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

[0023] In one embodiment the selected multidimensional cluster state is a tree-type cluster state, wherein the apparatus implements operations comprising: (i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device; (ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the treetype cluster state are formed; (iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and (iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

[0024] In one embodiment, the delay device comprises a plurality of optical delay lines and an optical switch.

[0025] In one embodiment the plurality of optical delay lines are static delay lines.

[0026] In one embodiment at least a portion of the plurality of optical delay lines are dynamic delay lines.

[0027] In one embodiment the delay device comprises a quantum memory.

[0028] In one embodiment an uppermost two optical modes of the QPNN are optically connected to the input of the delay device.

[0029] In one embodiment the emitter emits single photons in accordance with the timing protocol.

[0030] In one embodiment, when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell. Another aspect of the invention relates to non-transitory computer readable storage media for use with a processor and a photonic cluster state generator, the storage media storing computer code compatible with the processor, the code containing instructions to direct the processor to implement a timing protocol for photonic cluster state generator to generate a selected photonic cluster state type; wherein photonic cluster state generator includes an emitter that emits photons, a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type; wherein the stored instructions control operation of the photonic cluster state generator, comprising:

[0031] (i) when the input is one photon the QPNN routes the photon to the delay device;

[0032] (ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cell; and repeating (i) and (ii) to generate a plurality of unit cells; routing at least one photon from each unit cell through the delay device and the QPNN according to a timing protocol implemented by a controller to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

[0033] In various embodiments the stored instructions control operation of the photonic cluster state generator wherein the multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state. In some embodiments, all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

[0034] In one embodiment the stored instructions control operation of the photonic cluster state generator wherein the selected multidimensional cluster state type is a tree-type cluster state; including: (i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device; (ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the tree-type cluster state are formed; (iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and (iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

[0035] In one embodiment the stored instructions control operation of the photonic cluster state generator wherein, when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell.

[0036] BRIEF DESCRIPTION OF THE DRAWINGS

[0037] For a greater understanding of the invention, and to show more clearly how it may be carried into effect, embodiments will be described, by way of example, with reference to the accompanying drawings, wherein:

[0038] Figs. 1A and IB are diagrams showing examples of unit cells of different shapes, according to embodiments.

[0039] Fig. 1C is a diagram of a large-scale photonic cluster state generator, according to one embodiment.

[0040] Fig. ID is a schematic representation of generation of a tree-type cluster state with two branches and a depth of two, according to one embodiment.

[0041] Fig. IE is a diagram of a large-scale photonic cluster state generator, according to one embodiment.

[0042] Figs. IF and 1G are schematic representations of generation of unit cells of a tree-type cluster state, according to embodiments.

[0043] Fig. 2 and Fig. 3 are diagrammatic representations of protocols according to embodiments for generating tree-type cluster states with b = 2, d = 4, and with b = 3, d = 2, respectively, wherein, at the top, the tree is drawn where circles denote photons and edges denote entanglement, each photon is labelled as (r, c), where r is the number at the left and c is the column (numbers in circles), and below the tree steps of the protocol are given as a time series wherein each table corresponds to a different step j of the protocol and at any given time the table states which photon is routed to which delay line.

[0044] Fig. 4 is a diagram of photonic cluster state generator, according to one embodiment.

[0045] Fig. 5 is a diagram of a timing protocol for a tree-type photonic state cluster generator showing a procedure for generating a tree state with branching vector b = [2,2], according to one embodiment.

[0046] Fig. 6 is a diagram of an arbitrary tree shape where branching changes through the rows of the tree, with steps of the timing protocol given in tables as a time series, wherein the tree is drawn with branching vector b = [2,4,2], according to one embodiment.

[0047] Fig. 7 is a diagram of a quantum photonic neural network architecture wherein each network features a number of linear layers which may be formed by meshes of Mach-Zehnder interferometers; e.g., as shown in the inset, constructed from two phase shifters , 20 and two 50:50 directional couplers, and a nonlinear component between each consecutive pair of layers.

[0048] Fig. 8 is a plot of a training curve for a two-layer quantum photonic neural network used in a tree-type cluster state generation protocol according to one embodiment.

[0049] Fig. 9 shows Hinton diagrams of output states generated (right column) and the ideal targets (left column), when following a protocol for a b = 2, d = 2 tree-type cluster according to one embodiment, wherein each output state is shown as a pure state density matrix (i.e., p = I 'X 'L where the size of each square represents the magnitude of the matrix element, the shading denotes the phase).

[0050] Figs. 10A-10E show training of a 2-layer, 6-mode QPNN for a tree-type photonic cluster state generator, wherein Fig. 10A is a plot showing minimization of the network cost (i.e., average error) during 200 optimization trials of 1,000 epochs (i.e., iterations) each for three scenarios: practical (0.213 + 0.106 dB), state-of-the-art (SOTA, 0.021 + 0.010 dB), and future (0.0021 + 0.0010 dB) MZI losses; dashed lines denote the loss limit (i.e., minimum achievable cost due to loss); and Figs. 10B-10E show Hinton diagrams for further analyses of the SOTA trial from Fig. 10A.

[0051] Figs. 11A-11D are a series of plots showing performance metrics for a one-way quantum repeater, over a 300 km communication channel, where a QPNN-based tree-type photonic cluster state generator is placed at each node for models with practical, state-of-the-art (SOTA), and future MZI losses, compared with an equivalent scheme that uses a single photon as the logical qubit; wherein the number of photons in the tree, the repetition rate of the protocol used to generate it, the effective loss of the logical qubit between nodes, and the resultant communication rate across the entire channel, are shown in Figs. 11A to 11D, respectively; at the discontinuities, where the optimal tree shape changes, horizontal triangles indicate that the elements of b have changed, but not the depth, and vice versa for the vertical triangles, and vertical tick marks highlight threshold node distance, beyond which the loss introduced by the fiber channel surpasses that from the generator; and in Fig. 11A inset tree diagrams show how the tree shape changes.

[0052] DETAILED DESCRIPTION OF EMBODIMENTS

[0053] Described herein are methods and apparatus for generating multidimensional photonic cluster states using quantum photonic neural networks. According to embodiments, multidimensional photonic cluster states may be generated with high generation rates and may be arbitrarily large in scale. For example, the generation rates may be limited by the speeds of the single-photon sources and switches used in the apparatus, which in principle can accommodate GHz photon emission rates. Thus, cluster state generation rates achieved according to embodiments may be determined by how fast the required number of photons are emitted and routed, which may be many orders of magnitude faster than existing protocols (e.g., at least MHz as compared with mHz in existing protocols), regardless of the scale of the state. It is noted that many cluster states may be formed from elementary unit cells of a few entangled photons that are then entangled with each other to construct the multidimensional cluster. Embodiments described herein may be extended to any cluster state that can be broken down into unit cells. Thus, whereas certain embodiments described herein relate to tree-type cluster states, it will be appreciated that the invention is not limited thereto as the concepts and methods may be extended to other types of cluster states, such as, for example star-, ring-, line-, square-, lattice-, cylindrical-, etc. type cluster states, some of which may contain an arbitrary number of unit cells, which may be all identical or of various forms, that together may make the resultant state arbitrarily large. The rapid generation of multidimensional photonic cluster states as described herein is expected to provide significant advances in fields such as quantum computing and communications.

[0054] As used herein, the term "unit cell" refers to a combination of two or more photons that are entangled according to a selected shape, wherein a plurality of unit cells of one or more selected shapes is used to generate a selected multidimensional photonic cluster state type. Non-limiting examples of unit cells having shapes with two, three, and four photons (black dots), which may be used to generate tree-type cluster states, are shown in Fig. 1A, and non-limiting examples of unit cells having shapes with three, four, five, and six photons, which may be used to generate other types of cluster states, are shown in Fig. IB.

[0055] As described herein, by using a recurrent quantum photonic neural network (QPNN), unit cells may be constructed and connected deterministically (i.e., with near-unity efficiency and not probabilistically), in contrast to prior approaches. According to embodiments, a QPNN is a photonic circuit comprising layers of linear interferometric meshes interspaced with single-site quantum optical nonlinearities (e.g., nonlinear-optical elements or non-Gaussian operations), which act like an activation function in a neural network. This architecture results in a device that can learn to perform specific functions, such as to create a unit cell of entangled photons that are intrinsically robust to experimental imperfections. By recurrently feeding back select output photons into the QPNN during subsequent operations, the network both generates new unit cells and links them to the existing unit cells thus growing the cluster states. Implementations require specially designed QPNNs and unique feedback (timing) protocols, embodiments of which are described herein.

[0056] Embodiments enable a passive QPNN to generate arbitrarily sized cluster states, and the network may be made smaller and less complex with the addition of active switches. As noted above, a QPNN according to embodiments generates unit cells with near-unity efficiency and at high rates, at least in part because a QPNN as described herein relies on passive nonlinear interactions that, unlike prior approaches, (1) are not purely linear and (2) do not rely on active control of the internal state of quantum emitters (e.g., quantum dots). Whereas linear networks can entangle photons, at best they do so with a low success probability because the requisite nonlinearity that generates photon-photon interactions arises only due to quantum interference, an inherently probabilistic process. However, as described herein, the addition of nonlinearity to the linear mesh circumvents this challenge and enables deterministic and efficient entanglement. These efficient multi-photon interactions are also possible using quantum emitters, which act as an intermediate stage when their spin-state is entangled with the photons. However, in this case the time available to generate the cluster state is limited by the coherence time of the emitter, typically on the order of tens of nanoseconds, meaning that only few-photon cluster states can be made before the state of the emitter is scrambled. In contrast, the passive nonlinearity of embodiments described herein enables arbitrarily long-time operation. This enables recurrent operation of the QPNN which, to the best of the inventors' knowledge, has not been previously described, and hence arbitrarily large scaling of the cluster states. Reference [2] discusses the implementation of a recurrent photonic network for processing quantum states, referred to as a quantum optical recurrent neural network, however, this architecture is fundamentally different from a QPNN as described herein. For example, the architecture in [2] does not contain an element that is analogous to a passive nonlinearity as described herein and thus cannot deterministically entangle photons. Thus, embodiments described herein are the first to apply recurrent operation of a QPNN that, according to the above definition, contains nonlinear-optical elements or non-Gaussian operations.

[0057] Protocol 1

[0058] A timing protocol for generating a photonic cluster state, according to one embodiment, and a large-scale photonic cluster state generator, according to one embodiment, will now be described. As described, the timing protocol may be used to generate a triangular shaped unit cell of a tree-type cluster state, as shown in Fig. ID. However, the protocol may be adapted to generate other shapes of unit cells and other types of cluster states. Tree-type cluster states provide a loss tolerance that is suitable for large-scale quantum computation and communication.

[0059] Referring to Fig. 1C, which is a diagram of a photonic cluster state generator, a single photon source 100 emits photons that are used to construct the cluster state. In some embodiments a deterministic single photon source may be used, which provides on-demand single photons at specific times defined by the protocol. The single photons pass through a Hadamard gate 110 to prepare them in the |+) = ^= (|0) + |1)) state, where {| 0), | 1)} are the computational basis states (i.e., those following the encoding of quantum information). As an example, dual-rail encoding may be used to encode the quantum information. Once prepared in the |+) state, the single photon reaches a quantum photonic neural network (QPNN) 112. In one embodiment the QPNN is trained to perform two different operations depending on the input it receives. For example, if only one photon is input, residing in the source modes (i.e., the upper two optical modes at the input of the QPNN in this example), then the QPNN routes that photon alone through the network to the feedback modes (i.e., the upper two optical modes at the output of the QPNN in this example). If three photons reach the input of the network together (e.g., as may be required to generate a unit cell of a tree-type cluster state), the QPNN entangles these photons to generate the unit cell of the cluster state. When these two operations are combined with a timing protocol, implemented by a delay device, e.g., a switch 114 and at least two delay lines 116a, 116b (which may be of the same length), the photons may be recurrently routed through the QPNN 114 to build the entire cluster state from the bottom up. The photon source 100, the at least two delay lines 116a, 116b, and the switch 114, and optionally the QPNN 112 may be connected to a controller 180. Control lines (i.e., connections) from the controller to various components are shown with dashed lines. The controller may execute an algorithm including a timing protocol that controls operation of the photon source, the QPNN, and the switch to direct the cluster state generator to generate cluster states with specific structures, and may control the QPNN during training to generate a selected cluster state type.

[0060] Fig. ID is a schematic representation showing an example of a tree-type cluster state generation with single photons 120a, 120b, 120c as input to the QPNN 112, a unit cell 122 as output, and a tree-type cluster state 124 with two branches and a depth of two. With reference to Fig. ID, in one embodiment all the photons in the bottom row of the cluster state may be generated first. These photons are routed through the QPNN 112 and through the delay lines back to the input. Since there are multiple delay lines, a timing protocol forces each pair of consecutively-emitted photons to reach the input of the QPNN together, where a newly-emitted photon joins them. This allows the first two unit cells at the bottom of the cluster to be formed. In doing so, the top photon of each unit cell is then similarly routed back to the input of the QPNN through the delay lines. Just as before, these two photons, as well as a newly emitted photon, reach the input of the QPNN simultaneously, and the final unit cell of the cluster state is formed.

[0061] A more detailed description will now be provided. First, a deterministic, on-demand single photon source may be used which allows a photon to be generated at any point in the timing protocol. Let Zltsrepresent the base time interval of the source, such that photon generation events occur Atsapart at minimum. Let At^ represent the delay time provided by the ithdelay line in the jthstep of the protocol. If b is the number of branches for the tree-type unit cell and d is the tree depth, then d(b — 1) + 1 delay lines are required for the protocol. In some embodiments the delay lines may be dynamic, such that the time delay they impart is tunable, in which case the protocol instead requires just one static delay line and b — 1 dynamic delay lines. In either case, a switching scheme at the output of the QPNN routes the photons from the feedback optical modes to any of the delay lines, as well as one extraction line for the final photon. Altogether, the time delay of the ithdelay line is given by

[0062] At^ = (bd+ fo-'-1(l - i)) Ats, (Eq. 1) where any given tree has bdphotons in its bottom row. Following these definitions, in one embodiment, which may be at least partially implemented in an algorithm executed by a controller, in the the protocol proceeds as follows:

[0063] 1. This is step j = 1. Starting from the bottom of the tree, trigger the photon source to emit photons at intervals spaced by Ats. Between each interval, the switch switches to a different delay line, starting with At^ and incrementing to At^, then repeating until all bdphotons in the bottom row have been emitted. 2. Increment j by 1. Noting that At^ is constant regardless of j, switch the other b — 1 delay lines in accordance with Eq. 1. Trigger the photon source to emit photons at intervals of b^~1Atssuch that they arrive simultaneously with the photons from the previous step at the input of the QPNN. Between each interval, the switch switches to a different delay line, starting with At^ and incrementing to At^ until all bd~i photons in the row for step j have been emitted.

[0064] 3. Repeat the previous instruction over d steps, ensuring that when the final unit cell is generated, the photon in the feedback modes is routed to an extraction line rather than the delay lines.

[0065] Overall, the protocol according to the above embodiment takes dbdAtsto complete. Examples are shown diagrammatically in Fig. 2 for b = 2, d = 4 and in Fig. 3 for b = 3, d = 2. In Figs. 2 and 3, at the top, the tree is drawn where circles denote photons and edges denote entanglement. Each photon is labelled as (r, c), where r is the row (numbers at the left) and c is the column (numbers within circles). Below the tree, the steps of the protocol are given as a time series. Each table corresponds to a different step j of the protocol. At any given time, the table states which photon is routed to which delay line. In Fig. 2, the final step is the extraction of the root (0,0) photon at 64Ats. In Fig. 3, the final step is the extraction of the root (0,0) photon at 18zlts.

[0066] Protocol 2

[0067] An alternative timing protocol will now be described, again using tree-type cluster states as an example, embodiments of which may be more useful in circumstances where larger-scale QPNNs are accessible. The protocol is described with reference to the cluster state generator of Fig. IE. The protocol may be adapted to generate other shapes of unit cells and other types of cluster states. Embodiments of the protocol may be at least partially implemented in an algorithm executed by a controller.

[0068] In this protocol, rather than connecting the single pair of feedback modes of the QPNN to a large switch and d(b — 1) + 1 delay lines, the QPNN is instead scaled up such that it has b pairs of source modes and b pairs of feedback modes, the latter of which are respectively connected to b delay lines. In this embodiment, the b delay lines may be static, and the QPNN may be trained to route the photons to the appropriate delay lines based on where input photons are received. Fig. IE is a diagram of an apparatus, i.e., a cluster state generator, according to one embodiment that may be used to implement this protocol. To simplify the diagram, the embodiment is shown with two pairs of source modes and two pairs of feedback modes, and two pairs of delay lines, and a controller is not shown. The embodiment includes a pair of photon sources 130, a pair of Hadamard gates 132, a QPNN 134, and two or more delay lines 136a, 136b. For example, referring to Fig. IE, when a photon is emitted from one of the photon sources 130 and arrives at a given pair of source modes at the input of the QPNN 134, this photon will be routed to the corresponding pair of feedback modes at the output once the unit cell is generated. Additionally, the QPNN may be trained to route single photons alone through it, from a given set of source modes to its corresponding feedback modes, without changing their state. Similarly to protocol 1 described above, this is necessary at the start when the initial photons are first input to the recursive scheme. In contrast to protocol 1, this is also required during photonic cluster state generation with protocol 2. Since the delay lines 136a, 136b are static, the photons are looped through the delay lines and QPNN multiple times so that lagging photons catch up to the earlier photons for future unit cell generation steps. Overall, protocol 2 embodiments use fewer delay lines where none needs to be dynamic. However, it requires larger QPNNs with more complex training sets.

[0069] Figs. IF and 1G are schematic representations showing examples of unit cell generation for a tree-type cluster state based on protocol 2. In Fig. IF, single photons 140a 140b, 140c are input to the QPNN 134, where single photon 140a enters the upper pair of source modes. In this case, a unit cell 142 will be generated where a photon exits at the upper pair of feedback modes. Conversely, in Fig. 1G, since single photon 140d enters the QPNN 134 at the lower pair of source modes, the generated unit cell 144 includes a photon output at the lower pair of source modes.

[0070] Protocol 3

[0071] Another embodiment of a timing protocol for generating cluster states is described with respect to the cluster state generator of Fig. 4, using a tree-type cluster state as an example (as shown in the upper right of the figure with increasing darkness as the tree is built). However, the protocol may be adapted to generate other shapes of unit cells and other types of cluster states. The protocol, and variations thereof, may be at least partially implemented in an algorithm executed by a controller.

[0072] Referring to Fig. 4, the generator includes a single photon source 400, a Mach-Zehnder interferometer (MZI) 410 programmed to act as a Hadamard gate H, a QPNN 412, at least two delay lines 416, a switch 414, and a controller 420. The MZI 410 and QPNN 412 are shown with exploded views. Control lines (i.e., connections) from the controller to various components are shown with dashed lines. Photons are shown as gray dots, only one of which is labelled 430 to maintain clarity of the figure. The switch 414 and delay lines 416 route photons through the generator to generate a selected cluster state type, which for this description is a tree-type cluster state. The controller 420 controls source 400 and switch 414 to emit photons at times required by the timing protocol and subsequently direct them to the appropriate delay lines 416. The controller 420 may be connected to the delay lines 416 if they are dynamic and thus require active tuning. The controller may be connected to the QPNN 412 to actively tune its components during training, or to statically hold trained parameters during generation. In this embodiment, the role of the QPNN is to entangle a parent photon, the newly emitted one that enters at the top, with all children photons that simultaneously enter the network. It does so by applying CZ gate operations between the parent and each child. If the parent photon enters alone, the QPNN performs an identity operation instead. Together, these operations ensure that the QPNN forms all unit cells of cluster states that have arbitrary shapes, in addition to arbitrary scale, even when there are multiple kinds of unit cells within a single cluster state. Trees are defined by branching vectors b of length d, where d is the tree depth. Starting from the root photon, residing in row 0 at the top, each element bj specifies the number of branches stemming from each photon in row j (i.e., parents) to row j + 1 (i.e., children). For a given tree shape, the timing protocol specifies delay lines of certain lengths and instructs the switch how to direct children photons through the delay lines such that they meet their parents at the QPNN, where they become entangled. The time delay enacted by the ithdelay line while emitting photons in row j of the tree is given by where bd= 1, and delay lines are numbered from i = 1 to i = b^ . The first delay line, At^ is the same for all j because it is reused in each of the d stages of the protocol. In fact, the total time required to generate a tree, defined as

[0073] AtT= (j[i=o bk)dAts, (Eq. 3) can also be expressed as dAt^ If the physical delay lines are static, then the maximum number of lines required is bk, assuming that none can be reused in different steps of the protocol. If they are dynamic, this number is reduced to max{i}. For Ndphysical delay lines, regardless of whether they are dynamic, the switch paired with them must be 1 x (TVd+ 1). Fig. 5 is a diagrammatic representation of a timing protocol for, as an example, a tree with branching vector b = [2,2], assuming that the delay lines can be dynamically tuned, for the case where there are two delay lines required with a 1 X 3 switch, based on the implementation shown in Fig. 4. In Fig. 5, at (i) to (iv) individual photons from row 2 of the tree are emitted in subsequent timesteps t, separated by Ats, the time between source triggers. The photons then traverse through the QPNN which acts as an identity operation. The switch is adjusted at each timestep, directing each pair of consecutive photons to each of the two delay lines (21 ’ and At^ ), such that the latter photon catches up to the former. At (v) and (vi) delayed photons arrive at the QPNN input with a newly emitted photon such that all three are subsequently entangled. The top photon is routed to a delay line by the switch while the other photons proceed to the output of the generator. These operations are separated by 2Ats, and the shorter delay line (211^) is adjusted to accommodate this change (see the lower line in (vi)). At (vii) the root photon of the tree, (0,0), is emitted such that it arrives at the QPNN simultaneously with its children. The switch ensures the root is routed to the output alongside its children after they become entangled.

[0074] In more detail, starting at t = 021 tsin Fig. 5(i), photon (2,0) at the bottom left of the tree is emitted by the source, routed through the QPNN, which acts as the identity, and toward the switch. As shown in the tree diagram, both photons (2,0) and (2,1) must be entangled with photon (1,0), which means they should later arrive at the input of the QPNN simultaneously. Therefore, photon (2,0) is directed to delay line At^ = 4Ats, which is one timestep longer than At^ = 3Ats, the shorter delay line that photon (2,1) is routed to in Fig. 5(ii). In the next two timesteps (Fig. 5(iii) and 5(iv), photons (2,2) and (2,3) are routed the same way. As shown in Fig. 5(v), photon (1,0) is emitted such that it joins its children photons, (2,0) and (2,1), in the QPNN where it becomes entangled with each of them. The children photons no longer have other photons to entangle with, and are thus directed to the output of the generator. The parent photon (1,0) must eventually join its sibling (1,1) at the QPNN, and is thus directed to the long delay line, still of length 4Ats, to wait for it to catch up. Two timesteps later (Fig. 5(vi), photon (1,1) is entangled with its children and directed to the shorter delay line which has been reduced in length = 2Ats). This ensures that photon (1,1) arrives with its sibling (1,0) at t = 8Ats, shown in Fig. 5(vii), to become entangled with their parent photon (0,0). Since (0,0) is the root of the tree, the switch directs it to the output of the generator as well.

[0075] The protocol described above may be extended, as follows, to a general protocol that is suitable for generating trees of any shape. The protocol always constructs the tree from the bottom (row j = d) to the top (row j = 0). Each stage of the protocol corresponds to the jthrow of the tree, including all timesteps where a photon in that row is emitted by the single-photon source.

[0076] 1. There are Hfc o ^ / < photons in the bottom row ( / = d) of the tree. Emit each of these photons in subsequent timesteps t, separated by Ats, the time allotted to the source. Each emitted photon enters the QPNN alone such that the network applies an identity operation where the photon is simply routed through to its output. Following the QPNN, the photon is routed by the switch to one of bd-±delay lines, starting at line i = 1 incrementing each timestep to line i = then repeating. As calculated from Eq. 2, each subsequent delay line is Atsshorter than the previous.

[0077] 2. For each jthrow of the tree, from j = d — 1 to j = 1, emit a new photon at the singlephoton source in intervals of This parent photon will then arrive with its bj children photons at the input of the QPNN such that the network entangles them according to the target tree shape (i.e. a CZ gate operation is performed between the parent and each child). All children photons are routed to the output of the generator. The parent photon is routed by the switch to one of bj_±delay lines, starting at line i = 1 (At incrementing each interval to line i = then repeating. As calculated from Eq.

[0078] 2, each subsequent delay line is (Flfc ) bfe)Atsshorter than the previous.

[0079] 3. At the top row (j = 0) of the tree, the root photon is emitted to join its b0children at the input of the QPNN, where again, the QPNN entangles them according to the target tree shape. Rather than routing the root photon through the unnecessary delay line, the switch routes it to the output of the generator with its children.

[0080] Fig. 6 is a diagram of an example of an arbitrary tree shape where the branching changes through the rows of the tree, with steps of the timing protocol given in tables as a time series. In Fig. 6, the tree is drawn with branching vector b = [2,4,2], wherein each photon is labelled as (r, c), where r is the row (numbers at the left) and c is the column (numbers within circles). Below the tree, the timing steps of the protocol are given wherein each table corresponds to each jthrow of the tree. At any given time t, the table states which photon is emitted and which delay line it is routed to. The lengths of each delay line are noted at the bottom of each table. The final step is the extraction of the root (0,0) photon at 48Ats. Implementation

[0081] Single Photon Source

[0082] As discussed above, deterministic, on-demand single photon sources may be triggered to emit single photons at specific times defined by the protocols. Single photon sources may be based on solid-state quantum emitters capable of on-demand operation while producing highly indistinguishable photons [3], Such photon sources may be incorporated in photonic integrated circuits on a chip [4-6], Therefore, embodiments may be implemented using single photon sources as standalone components or using single photon sources combined on chip with other components of the generator in a photonic integrated circuit.

[0083] Quantum Photonic Neural Network

[0084] A generalized QPNN according to one embodiment is shown in the diagram of Fig. 7. Referring to Fig. 7, a QPNN includes a number of layers, where each layer is constructed from a linear optical mesh of Mach-Zehnder interferometers. Photons are routed through the linear layers of the network, preparing the photons for the nonlinear components in the network, and arranging photons in the correct output ports at the end. As shown in the expanded inset in Fig. 7, in one embodiment a Mach-Zehnder interferometer (MZI) may include two reconfigurable phase shifters parameterized as cf> and 20 and two 50:50 directional couplers which are used in training the QPNN to perform a desired operation. Between each consecutive pair of layers, a nonlinear component is added in each optical mode. The nonlinear component may be active or passive. However, passive nonlinearities (e.g., those not limited by decoherence times) may be preferable in embodiments where the goal is to achieve high efficiency and scalability. The optical nonlinearities may be analogous to an activation function of a neural network and thus impart learning capabilities to the QPNN.

[0085] Referring now to the QPNN as shown in Fig. 4, 412, the constituent linear and nonlinear transformations are labelled as U and Z, respectively. Multiplying these transformations in order produces the system function of an L-layer QPNN. When modeling this operation, the procedure of

[0010] may be followed to incorporate photon routing errors and loss in a component-by-component manner, leading to imbalance throughout the circuit that matches experimental conditions (see Example 4 for more details). Once constructed, the system function may be applied to any given input state |in)kto produce an output state |out)k= S | in)k. To teach a QPNN to perform some desired operation, its variational parameters ;, 0; (i.e. the MZI phase shifts) may be trained until each fcthoutput produced matches the fcthtarget state |targ)k. Mathematically, this involves minimizing the cost function

[0086] (Eq. 5) a measure of the network error evaluated by comparing all K output states to the corresponding targets. For the tree generator, input-target state pairs are selected such that the QPNN learns to perform a photon-number-dependent amount of CZ gates as required by the generation protocol. The simplest set of states is formed by considering all possible logical inputs, but optimization efficiency may be improved by training using only the subset of states where the photon entering at the top of the QPNN is in state | + ), as this is true at all stages of the protocol.

[0087] The linear optical mesh of MZIs used to create the linear layers of a QPNN may be realized in a variety of ways. For example, they may be fabricated on-chip in a photonic integrated circuit. Alternatively, when information is encoded using the temporal degree of freedom, rather than spatial, the operation carried out by a mesh of MZIs can instead be performed by just a single MZI together with a pair of optical switches and an optical fiber loop time delay. Overall, the linear optical components required to realize a QPNN are straight-forward to implement.

[0088] The nonlinear components may be implemented with a structure that mediates strong photon-photon interactions such that they become deterministically entangled. Such interactions may be few-photon optical nonlinearities, characterized in that the nonlinear component operates differently on a single photon than it does on two photons, typically due to photon-photon interactions. Embodiments may be implemented with a component that mediates strong few-photon Kerr nonlinearities, wherein, for example, an ideal nonlinear component has an effective nonlinear phase shift of it (i.e., one photon experiences 0 phase shift, yet two photons together each experience a it phase shift). In other embodiments components with weaker nonlinear phase shifts may also be used without degrading network performance. For example, QPNNs may enact deterministic quantum logic operations with, e.g., an order-of-magnitude less than the ideal phase shift, provided that the network can be made larger. The type of nonlinear component that is optimal for use with a QPNN may depend on the specific application. There are a variety of technologies that may be used to implement nonlinear components. Nonlinearities with effective strengths equivalent to a n Kerr nonlinearity may be achieved using electromagnetically induced transparency [7] and the saturation of atoms [8], As to the Kerr nonlinearity, a variety of schemes may be used to sufficiently strengthen its effect at the few-photon level. These include the use of integrated nanophotonic cavities with high quality factors designed specifically for this purpose and temporal trapping [9], Alternatively, a nonlinear component may also be realized using quantum dots, a type of solid-state quantum emitter, similar to a single atom, that when coupled to a nanophotonic structure acts as a fundamental quantum light-matter interface on a semiconductor chip. Quantum dots may be used to mediate interactions between photons that scatter from them producing nonlinear responses including nonlinear phase shifts and the generation of strong photon correlations. For example, one scheme that forms a perfect n nonlinear phase shift uses a three-level quantum dot coupled to a cavity with strengths that have been demonstrated experimentally

[0013] , However, it will be appreciated that this scattering is passive, rather than active, such that the desired response does not rely on control of the internal spin states of the quantum dot, and thus is not limited by the decoherence times of these states.

[0089] Switches & Delay Lines

[0090] The optical switches and delay lines are the least specific components of the photonic state generator as there are many methods to implement the required functionality. To maximize the performance of the generator, however, the switch speed should be as fast as possible. With faster switching speeds, the photons can be emitted at higher repetition rates, the delay lines can be shorter, and the overall generation speed increases as a result. Optical switches may be based on a variety of operating principles and may achieve sub-picosecond and sub-femtosecond switching times.

[0091] Embodiments of the protocols described above may be implemented using static delay lines or dynamic delay lines, or a combination thereof. For example, embodiments may be based only on static fiber optic delay lines, or on optical fiber delay lines that impart tunable, programmable delays. Optical delay lines may be implemented on-chip, typically using waveguides or gratings designed for this purpose.

[0092] In other embodiments the delay lines may be implemented using quantum memories that store the quantum state of a photon, then release it after the required time delay so that the photon then continues back to the input of the QPNN. Quantum memories may be implemented in various technologies, e.g., based on atomic vapours, or integrated on-chip. Quantum memories provide a more compact option for integrating dynamic delay lines on-chip.

[0093] Controller

[0094] One or more elements of apparatus used to generate photonic cluster states may be connected to a controller that exerts at least partial control of operation of the one or more elements during training of the QPNN and / or during photonic cluster state generation. For example, one or more of the photon source 100, the QPNN 112, two or more delay lines, and the switch 114 of the embodiment of Fig. 1C may be connected to a controller 180. Similarly, one or more of the photon source 130 and the QPNN 134 of the embodiment of Fig. IE, or one or more of the photon source 400, the two or more delay lines 416, the QPNN 412, and the switch 414 of the embodiment of Fig. 4 may be connected to a controller 420. The controller may include a computer, a processor, etc., and a memory device that stores computer readable code, i.e., a program, algorithm, etc., that, when executed by the computer, causes the controller to implement control operations. The controller may include a display device and an input device such as a keyboard and / or mouse that allows user interactions, e.g., to input parameters for training the QPNN and for generating selected photonic cluster states. The controller may execute a user interface such as a graphic user interface (GUI) to facilitate interaction with a user. Examples of control operations include, but are not limited to, synchronize the photon source (emitter) with other elements for photonic cluster state generation, configure photonic elements within the QPNN during training, and control connections of the switch 114 or 414 for proper routing of photons to the delay lines. For example, the controller may perform operations such as, but not limited to, executing an algorithm comprising a timing protocol that generates a selected photonic cluster state (such as, for example, tree-, star-, ring-, line- , square-, lattice-, cylindrical-, etc. type cluster state). In some embodiments, the algorithm may include processing steps based on any one of Protocols 1, 2, and 3 described above, including combinations thereof.

[0095] Software

[0096] The timing protocols described herein (Protocols 1, 2, and 3), and variants and adaptations thereof, may be implemented in non-transitory computer readable storage media for use with a processor (e.g., a controller) and a photonic cluster state generator, the storage media storing computer code compatible with the processor, the code containing instructions to direct the processor to implement the timing protocol for the photonic cluster state generator to generate a selected photonic cluster state type. The photonic cluster state generator may be based on one or more of the embodiments described herein, or variants thereof.

[0097] Embodiments will be further described by way of the following non-limiting examples.

[0098] Example 1

[0099] This example provides preliminary results from a simulation of a tree-type cluster state generator based on an embodiment of protocol 1 in which an ideal model of the QPNN (see [5], n Kerr nonlinearity) was used for simplicity. The simulation software applied was based on that described in [6], written in Python (version 3.10.2) using Numpy (version 1.22.2) for mathematical operations and NLopt (version 2.6.1) for optimization procedures. Performance-sensitive operations were translated to C using Cython (version 0.29.30).

[0100] Fig. 8 shows an example of a training curve for a two-layer QPNN used in the tree-type cluster state generation Protocol 1. The network was trained in 25 trials to route single input photons from the source modes to the feedback modes, and thus the switch and delay lines, as well as to generate a three-photon tree unit cell (b = 2) when three photons were input. To the left of the vertical dashed line an optimizer performed a global optimization routine, while to the right it performed a local optimization routine. The optimization scheme was similar to those presented in [5, 6],

[0101] The network was trained not only to generate the tree unit cell when three photons were input, but also to route a single photon through the network to the switch and delay lines if just a single photon was input. As demonstrated by these results, the optimizer was able to train networks of just two layers (i.e., the smallest possible network size) to achieve errors approaching the roundoff limit of the numerical simulations.

[0102] Once the network was trained, it was used in the generation protocol. Fig. 9 shows the output states that were formed as the protocol progressed through generating a tree-type cluster state of b = 2, d = 4 (e.g., see 124 in Fig. IB). In Fig. 9 the left column shows the output states generated and the right column shows the ideal target states. Each output state is shown as a pure state density matrix (i.e., p = | 'X 'I using Hinton diagrams, where the size of each square represents the magnitude of the matrix element, while the shading denotes the phase). Since the basis for the full tree-type cluster (bottom row) is exponentially larger than those for the unit cell (middle row) and single photon (top row), it is omitted from the axis labels. From a comparison of the left and right columns it is evident that the generator works according to its operating principle where the error of the full cluster is very low (< IO-10).

[0103] Example 2

[0104] This example describes training and evaluation of QPNN models that incorporate relevant experimental imperfections such as component losses.

[0105] Three QPNN models were trained to perform the functionality required for the tree state generator, each in 200 optimization trials of 1,000 epochs (i.e., iterations). Referring to Fig. 10A, each model considered different amounts of MZI loss: that calculated from components demonstrated on a single integrated platform ("practical"; black)

[0011] , from state-of-the-art ("SOTA"; gray) components independent of platform, and from one order-of-magnitude better than the SOTA as a look ahead ("future"; light gray). QPNNs with less loss are able to reach lower operational errors. However, regardless of the loss model, it was found that a QPNN can be trained to nearly the corresponding loss limit (dashed horizontal lines in Fig. 10A), which is the expected result in the best-case scenario where all components introduce the same amount of loss (i.e., balanced) and there are no photon routing errors. Specifically, the practical, SOTA, and future models get to within approximately 0.014, 0.003, and 0.001 of their corresponding limits.

[0106] Across Figs. 10B-10E, the best trial achieved with the SOTA model (heavy gray line in Fig. 10A) was selected and investigated to determine how a trained QPNN responds to all inputs that it would encounter in the tree generation protocol. For each input state (vertical axes), the output state (horizontal axes) is shown in the form of a Hinton diagram where the size (shade) of each box shows the probability amplitude (phase) of each coefficient. The Hinton diagrams resolved in the X- basis for each QPNN operation required by the generation protocol, where at all steps the uppermost photonic qubit is |+) at the input (vertical axis), yet belongs to a superposition of |+) and |— ) at the output (horizontal axis). The boxes in the Hinton diagrams show the difference in magnitude of each probability amplitude when the output state is conditioned on measuring the input number of photons in a logical configuration of output ports (the difference is marginal for the SOTA model). Each box is shaded according to its argument, which is always within TT / 100 of either 0 or n up to an insignificant global phase. When a photonic qubit is missing at any input or output port of the network, 0 is written in its place. The output state produced by the QPNN appears identical to the target in all cases. Quantitatively, in Fig. 10A the optimized cost (0.138) is nonzero, yet the fidelity, defined as the average probability that each output state matches each target when the output is logical (i.e., containing the same number of photons as the number that were input, arranged according to the same dual-rail encoding), is calculated as 99.996%. Together, these measures suggest that nearly all of the error accumulated in the cost function can be attributed to photon loss within the QPNN, and this amounts to boxes that are slightly reduced in size across Figs. 10B-10E, even though this is not visually evident. Again, these results demonstrate that QPNNs can be trained to perform all functionalities required by the tree state generator with loss-limited performance.

[0107] While the operations shown in Figs. 10C and 10D do not show up nominally in the generation protocol, they become important when photons are lost while the tree is being formed. Even when a photon is lost during generation, the loss tolerance of the tree remains intact so long as the appropriate CZ operations act on the remaining photons, and an identity operation replaces those that can no longer occur

[0012] , That is, whether a tree is generated in full before losing any photons, or if some of the photons are lost while generating the tree and others are lost after, the resultant tree will have the same effective loss as long as these conditions are met. Additionally, the general capability of the QPNN to adapt to the number of photons that are input, always performing CZ operations between the top control photon and all targets that simultaneously arrive, extends the generation protocol to all branching vectors. If in one row of the tree the branching is less than other rows, the QPNN operates on less photons each timestep while that row is being formed. This demonstrates that a nonlinear photonic circuit is able to perform photon-number-dependent operations. It also demonstrates a surprising finding wherein multiple logical quantum circuits can be mapped to the QPNN, e.g., for two different circuits that use the same number of photons, entering from different ports (see Figs. 10C and 10D).

[0108] Performance of the tree state generator embodiment in its entirety was evaluated. To complete the model of the generator, loss introduced by components outside of the QPNN was included. For the switch, losses were modelled based on simplified meshes of MZIs with one phase shifter each, as these suffice to perform routing from one port to another. Since the switch must operate on the order of the source rate (1 / Zlts= 100 MHz), the loss values reported in

[0011] were used, where the phase shifters are electro-optic and can thus reach tens of GHz in bandwidth. The delay lines were assumed to be SMF-28 optical fibers (Corning, Inc., Arizona, USA) that have 0.17 dB / km loss and a group index of 1.462 at 1550 nm. With these fibers

[0011] also reports 0.12 dB loss when coupling to or from the QPNN chip, which were included in the model since the photons travel to and from the delay lines, and at the output of the generator. The additional loss values were held constant even as the loss varied in the QPNN when considering each of the practical, SOTA, and future models. All of these loss values were used to quantify the transmissivity of photons through each component of the generator, and these were multiplied to calculate the overall transmissivity, which quantified the probability that the photons survive the generator.

[0109] The first metric considered was the fidelity of the resultant tree state as its depth scales. In constructing a tree of n total photons, the QPNN is applied n times such that the overall fidelity is Tn, where T is the fidelity of the QPNN. While independent of photon loss, the fidelity quantifies the similarity between the resultant tree state and that which was targeted by the protocol. It was found that the fidelity remained > 90% on average for all three models for trees with up to 127 photons. All models failed to achieve a perfect unit fidelity due to photon routing errors and imbalanced component losses. The loss imbalance plays a more significant role in the practical model, where the standard deviation of the loss per MZI was 0.106 dB, whereas in the other models the deviation was < 0.01 dB. Since the fidelities for the SOTA and future models overlapped it was inferred that the absolute value of the MZI loss for SOTA components is sufficiently low such that routing errors dominate the resultant fidelity, indicating that fidelity may be improved if routing errors are reduced.

[0110] To fully characterize the performance of the generator the tree fidelity was paired with the rate at which trees can be generated. Specifically, the repetition rate (1 / Zltr) of the protocol was combined with all relevant loss in the generator to calculate the generation rate: the rate at which full trees (i.e., not missing any photons) can be produced. Varying the loss per MZI, assuming that at any point the QPNN is trained to the loss limit, showed how the generation rate scales with the tree depth. Starting with 7-photon trees (d = 2), it was found that using a practical experimental platform, the QPNN-based generator reached rates on the order of 1 kHz, 5 orders of magnitude greater than the current standard of about 10 mHz. As low-loss components become further integrated (SOTA), the tree size can be more than doubled to 15 photons, or increased by roughly an order of magnitude to 63 photons, while still achieving near 100 kHz and 50 mHz generation rates, respectively. The latter rate can be increased by 3 orders of magnitude (~ 50 Hz) if the loss per MZI is reduced by just one order of magnitude (future model). Together, the results demonstrate the efficacy of the QPNN-based approach, emphasizing the improved performance that can be attained when trees are fused using efficient, high-fidelity operations. It was also found that this is maintained as the branching is increased. Example 3

[0111] This example describes and evaluates performance of a tree state generator according to embodiments provided herein implemented in a practical application, namely, a 300 km fiber optic communication channel, such as within a quantum network. The goal is to efficiently transmit quantum information across the channel by leveraging the loss tolerance of generated tree states. To do so, the channel is considered as a one-way quantum repeater with a variable number of equidistant nodes. Each node includes a QPNN-based tree state generator and performs Bell state measurements between pairs of trees. For each incoming tree that has accumulated loss on the way, the node prepares a new tree to replace it, and uses a Bell state measurement to transfer the logical qubit from the old tree to the new tree. As the distance between nodes increases, less total nodes span the communication channel, yet more loss is accumulated during node-to-node propagation. The analysis focusses on understanding the balance between loss from generation and that from propagation, and thus assumes that the single-photon sources, detectors, and Bell state measurements are perfect.

[0112] Simulation results are presented in Figs. 11A-11D. At each node separation distance (shown in Figs. 11A-11D) the branching vector of the tree used was varied in the one-way quantum repeater scheme to minimize the effective loss of the logical qubit. This was repeated for each QPNN loss model (practical, SOTA, and future; see Fig. 10A) with trees that were constrained to max{ >} < 4 (solid lines), then compared with the simpler 2-branch trees considered previously (dashed lines), as well as the case where each node generates and performs Bell measurements between single photons. In Fig. 11A, the total number of photons in each optimized tree is plotted as the distance between nodes increases, or equivalently, as the number of nodes decreases. Somewhat counterintuitively, it was found that the optimal tree decreases in size as the nodes become further separated, either due to reduced branching (triangles pointing horizontally inwards) or reduced depth (triangles pointing vertically inwards). This may be related to the fact that the loss during generation decreases with the tree size. As the distance between nodes increases, more loss is accumulated in propagation, and this is counteracted by reducing generation loss to maintain optimal performance. In no case was it found that the optimal tree shape changes before the loss attributed to propagation outweighs that from generation, the point of which is marked with vertical ticks in Figs. 11A-11D.

[0113] The repetition rate for generating each optimal tree, as shown in Fig. 11B, is effectively a mirror image of the number of photons since it takes longer to generate larger trees. However, recalling the discussion of Eq. 3, the duration of the generation protocol tends to scale polynomially with the branching and exponentially with the depth. In Figs. 11A-11D, it can be seen that this only becomes advantageous for the future loss model, specifically as it tends toward branching vectors with some 3-branch rows for node distances < 10 km (see insets of Fig. 11A). Therefore, as MZI losses continue to be reduced, increasing the scale of the QPNN to enable more complex branching will no longer be prohibitive to optimizing the tree shape.

[0114] In Figs. 11C and 11D, the optimized node-to-node effective loss and corresponding communication rate for the entire channel are respectively shown for each model. The latter combines the repetition rate for the optimized tree shape with the effective loss to summarize the performance of the repeater overall. Here, it was found that a tree generator constructed on a current practical platform is too lossy to provide improved signal transmission when compared with the use of individual photons as the information carriers. Conversely, a generator built from current SOTA components can achieve roughly a 55% increase in communication rate (62 Hz to 96 Hz) by decreasing the effective loss to 9% from 14%, when there are 92 nodes spaced 3.26 km apart. With one order of magnitude reduction in the loss per MZI (i.e., future), the communication rate at this node distance increases by nearly two orders-of-magnitude to > 20 kHz (> 30 kHz) with just 2% (3%) node-to-node effective loss for trees with max{b} < 4 (2), far surpassing the optimal results achievable with individual photons alone.

[0115] Example 4

[0116] This example provides an overview of methods that were employed in embodiments described herein.

[0117] Network Simulations

[0118] QPNN simulations were facilitated by the quotonic (vl.0.0) package, a python (v3.10.2) framework designed by the inventors to efficiently model and train the networks. It relies on jax (v0.4.30) for numerical computation and optax (vO.2.3), with the default Adam optimizer and exponential decay scheduler, to perform each optimization routine. Given that Adam is a gradientbased optimization algorithm

[0014] , the version of autograd native to jax was used to compute analytical gradients of the cost function (Eq. 5) while training the network. Each optimization trial began by selecting random linear unitary transformations from the Haar measure, for each layer, and performing Clements decomposition

[0015] to extract the initial phase shift parameters 4>,, 0,, as this improves convergence speed. Training proceeded for a set number of epochs that was calibrated empirically for each model. All simulations were conducted on the Frontenac Platform computing cluster offered by the Centre for Advanced Computing at Queen's University at Kingston, Kingston, Ontario, Canada.

[0119] Modeling Network Imperfections

[0120] To model imperfections in the QPNN, the procedure of

[0010] was followed such that each individual component introduces its own amount of loss or routing errors, selected from a distribution, as is typically the case experimentally. Routing errors arise from imbalance in the nominally 50: 50 directional couplers (DCs) that form each MZI, which is often reported in the literature at approximately 5%. It follows that the splitting ratio for each DC is selected from a normal distribution centered at 0.5 with a width of 0.05. Similarly, the loss introduced by each MZI is sampled from a normal distribution with a mean (standard deviation) of 0.213 (0.106) dB, 0.021 (0.010) dB, 0.0021 (0.0010) dB for the practical, SOTA, and future models, respectively. The practical model was calculated using losses reported in

[0011] where the phase shifters and DCs that form each MZI were integrated on the same platform. For the SOTA model, the DC loss from

[0011] (0.0005 + 0.0002 dB) was used, but with the 0.01 dB loss thermo-optic phase shifters of

[0016] substituted. The future model simply reduced the loss per MZI by one order of magnitude in dB.

[0121] Evaluating Network Fidelity

[0122] The fidelity of a QPNN trained to perform a mapping between K input ( | in)) and target ( | targ)) state pairs is given by where S (Eq. 4) describes the network and CB is the set of computational basis states, all those that abide by the logical dual-rail encoding of the photonic qubits. That is, the fidelity quantifies the similarity between the actual output and the target state, if no photons have been lost and the output remains dual-rail encoded. Calculating Tree State Generator Metrics

[0123] Following the formalism of

[0012] , a tree with branching vector b contains total photons that together encode one logical qubit. When each individual photon has a probability e0of being lost, the effective loss (i.e., the probability that the information is lost) is given by

[0124] Ceff = 1 - (1 - e0)Pind, (Eq- 8) which combines the probability that the root photon survives (1 — e0) with the probability that its state can be recovered via indirect measurement, Pind. The latter is calculated using a recursive relation find = [(1 - to + e0R1)b° ~ (60Ri)b°](l - e0+ e0R2)bl, (Eq. 9) where Rj is the probability of a successful indirect measurement on a photon in the jthrow of the tree, expressed as for j < d, with Rd= 0, bd= 0 taken as the initial values. In Figs. 11A-11D a search was performed over all branching vectors with max{ >} < 4 up to maximum depths of 8 and 6, respectively, and eeffwas evaluated for each. The branching vectors were constrained as such since only QPNN simulations up to 10 X 10, operating on 5 dual-rail photonic qubits, could be performed in a reasonable amount of time. That being said, it is clear from the results that this search domain well- encapsulates the optimal tree shapes for the analysis of Figs. 11A-11D. With eeffdefined, the communication rate in Fig. 11D is the product of the effective transmission (1 — eeff) with the repetition rate (1 / Zltr). In contrast, the generation rate is the product of the joint probability that each photon survives the generator with the repetition rate. If each of the n photons in the tree experiences the same amount of loss in the generator, e0, then this joint probability is simply (1 — e0)n. Computational modelling of different amounts of loss experienced by each individual photon was performed to more accurately describe the generation rate.

[0125] All cited publications are incorporated herein by reference in their entirety. EQUIVALENTS

[0126] It will be appreciated that modifications may be made to the embodiments described herein without departing from the scope of the invention. Accordingly, the invention should not be limited by the specific embodiments set forth, but should be given the broadest interpretation consistent with the teachings of the description as a whole.

[0127] REFERENCES

[0128] 1. Cogan, D., Su, Z.-E., Kenneth, O. & Gershoni, D. Deterministic generation of indistinguishable photons in a cluster state. Nature Photonics 17, 324-329 (2023).

[0129] 2. Prins, R. de, Sande, G. V. der & Bienstman, P. A quantum optical recurrent neural network for online processing of quantum time series. (2023). Quantum Physics, arXiv:2306.00134vl [quant-ph], https: / / doi.org / 10.48550 / arXiv.2306.00134

[0130] 3. Senellart, P., Solomon, G. & White, A. High-performance semiconductor quantum-dot singlephoton sources. Nature Nanotechnology 12, 1026-1039 (2017).

[0131] 4. Chanana, A. et al. Ultra-low loss quantum photonic circuits integrated with single quantum emitters. Nature Communications 13, 7693 (2022).

[0132] 5. Kim, J.-H. et al. Hybrid integration of solid-state quantum emitters on a silicon photonic chip. Nano Letters 17, 7394-7400 (2017).

[0133] 6. Uppu, R. et al. Scalable integrated single-photon source. Science Advances 6, eabc8268 (2020).

[0134] 7. Zuo, Y. et al. All-optical neural network with nonlinear activation functions. Optica 6, 1132- 1137 (2019).

[0135] 8. Guo, X., Barrett, T. D., Wang, Z. M. & Lvovsky, A. I. Backpropagation through nonlinear units for the all-optical training of neural networks. Photon. Res. 9, B71-B80 (2021).

[0136] 9. Yanagimoto, R., Ng, E., Jankowski, M., Mabuchi, H. & Hamerly, R. Temporal trapping: A route to strong coupling and deterministic optical quantum computation. Optica 9, 1289-1296 (2022).

[0137] 10. Ewaniuk, J., et al. Imperfect quantum photonic neural networks. Advanced Quantum Technologies 6, 3, 2200125 (2023). https: / / doi.org / 10.1002 / qute.202200125

[0138] 11. Alexander, K., et al. A manufacturable platform for photonic quantum computing. arXiv:2404.17570 [quant-ph] (2024). https: / / arxiv.org / abs / 2404.17570

[0139] 12. Varnava, M., et al. Loss tolerance in one-way quantum computation via counterfactual error correction. Physical Review Letters 97, 120501 (2006). https: / / doi.org / 10.1103 / PhysRevLett.97.120501 13. Basani, J.R., et al. Universal logical quantum photonic neural network processor via cavity- assisted interactions. arXiv:2410.02088 [quant-ph] (2024). https: / / doi.org / 10.48550 / arXiv.2410.02088

[0140] 14. Kingma, D.P., et al. Adam: A method for stochastic optimization. arXiv:1412.6980 [cs.LG] (2017). https: / / arxiv.org / abs / 1412.6980

[0141] 15. Clements, W.R., et al. Optimal design for universal multiport interferometers. Optica 3, 1460- 1465 (2016). https: / / doi.Org / 10.1364 / OPTICA.3.001460

[0142] 16. Parra, J., et al. Ultra-low loss hybrid ITO / Si thermo-optic phase shifter with optimized power consumption. Optics Express 28, 9393-9404 (2020). https: / / doi.org / 10.1364 / OE.386959

Claims

CLAIMS1. A method for generating a multidimensional photonic cluster state, comprising: using an emitter to emit photons; using apparatus comprising a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type, wherein:(i) when the input is one photon the QPNN routes the photon to the delay device;(ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cellrepeating (i) and (ii) to generate a plurality of unit cells; routing at least one photon from each unit cell through the delay device and the QPNN according to a timing protocol implemented by a controller to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

2. The method of claim 1, wherein the selected multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state.

3. The method of claim 1, wherein all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

4. The method of claim 1, wherein the selected multidimensional cluster state type is a treetype cluster state, the method comprising:(i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device;(ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the tree-type cluster state are formed;(iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and(iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

5. The method of claim 1, wherein the delay device comprises a plurality of optical delay lines and an optical switch.

6. The method of claim 5, wherein the plurality of optical delay lines are static delay lines.

7. The method of claim 5, wherein at least a portion of the plurality of optical delay lines are dynamic delay lines.

8. The method of claim 1, wherein the delay device comprises a quantum memory.

9. The method of claim 4, wherein an uppermost two optical modes of the QPNN are optically connected to the input of the delay device.

10. The method of claim 1, wherein the emitter emits single photons in accordance with the timing protocol.

11. The method of claim 1, wherein when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell.

12. Apparatus for generating a multidimensional photonic cluster state, comprising: an emitter that emits photons; a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type; and a controller; wherein:(i) when the input is one photon the QPNN routes the photon to the delay device;(ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cell; wherein (i) and (ii) are repeated to generate a plurality of unit cells; wherein the controller implements a timing protocol that routes at least one photon from each unit cell through the delay device and the QPNN to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

13. The apparatus of claim 12, wherein the selected multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state.

14. The apparatus of claim 12, wherein all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

15. The apparatus of claim 12, wherein the selected multidimensional cluster state type is a tree-type cluster state, wherein the apparatus implements operations comprising:(i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device;(ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the tree-type cluster state are formed;(iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and(iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

16. The apparatus of claim 12, wherein the delay device comprises a plurality of optical delay lines and an optical switch.

17. The apparatus of claim 16, wherein the plurality of optical delay lines are static delay lines.

18. The apparatus of claim 16, wherein at least a portion of the plurality of optical delay lines are dynamic delay lines.

19. The apparatus of claim 12, wherein the delay device comprises a quantum memory.

20. The apparatus of claim 15, wherein an uppermost two optical modes of the QPNN are optically connected to the input of the delay device.

21. The apparatus of claim 12, wherein the emitter emits single photons in accordance with the timing protocol.

22. The apparatus of claim 12, wherein when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell.

23. Non-transitory computer readable storage media for use with a processor and a photonic cluster state generator, the storage media storing computer code compatible with the processor, the code containing instructions to direct the processor to implement a timing protocol for photonic cluster state generator to generate a selected photonic cluster state type; wherein photonic cluster state generator includes an emitter that emits photons, a recurrent quantum photonic neural network (QPNN) that includes a nonlinear component and a delay device, wherein the QPNN has at least one input optically connected to the emitter by source modes and at least another input connected to an output of the delay device, a plurality of optical modes comprising linear and nonlinear components, and an output comprising at least two feedback modes optically connected to an input of the delay device, wherein the QPNN is trained to perform different operations depending on an input it receives to generate a selected multidimensional photonic cluster state type; comprising: the stored instructions control operation of the photonic cluster state generator, wherein:(i) when the input is one photon the QPNN routes the photon to the delay device;(ii) when the input is a number of photons required to complete a unit cell of the selected multidimensional photonic cluster state type, wherein at least one photon of the number of photons is received from the delay device, the QPNN entangles the number of photons to generate a first unit cell; andrepeating (i) and (ii) to generate a plurality of unit cells; routing at least one photon from each unit cell through the delay device and the QPNN according to a timing protocol implemented by a controller to entangle the plurality of unit cells to generate the selected multidimensional photonic cluster state type.

24. The non-transitory computer readable storage media of claim 23, wherein the selected multidimensional cluster state type is selected from a star-, ring-, line-, square-, lattice-, and cylindrical-type cluster state.

25. The non-transitory computer readable storage media of claim 23, wherein all unit cells of the plurality of unit cells of the selected multidimensional cluster state type are not the same.

26. The non-transitory computer readable storage media of claim 23, wherein the selected multidimensional cluster state type is a tree-type cluster state; comprising:(i) generating photons in a bottom row of the tree-type cluster state and routing the photons through QPNN and the delay device;(ii) implementing the timing protocol using the delay device to route pairs of consecutively emitted photons to reach the input of the QPNN together, where each pair of photons is joined by a newly emitted photon in the source modes; wherein first unit cells corresponding to a first row of the tree-type cluster state are formed;(iii) routing a top photon from each first unit cell to the delay device using the timing protocol wherein pairs of the top photons and a newly emitted photon reach the input of the QPNN simultaneously and are entangled to form a second unit cell corresponding to a second row of the tree-type cluster state; and(iv) repeating (iii) for the top photons of unit cells to form the unit cells of all rows of the tree-type cluster state.

27. The non-transitory computer readable storage media of claim 23, wherein, when the input is a number of photons greater than one and less than the required number to complete the unit cell of the selected multidimensional photonic cluster state type; wherein at least one photon of thenumber of photons is received from the delay device, the QPNN entangles the number of photons to generate a partial unit cell.

Images