The post An introduction to graph states appeared first on Peter Rohde.

]]>One especially useful class of quantum states is *graph states*, also known as *cluster states*. As the name suggests, a graph state |G\rangle is associated with a graph,

G=(V,E),

where the vertices (v\in V) represent qubits initialised into the

|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}

state, and edges (e\in E) represent the application of controlled-phase (CZ) gates between respective vertices, where,

\mathrm{CZ}=\mathrm{diag}(1,1,1,-1).

A graph state can therefore be expressed as,

|G\rangle = \left[ \prod_{e\in E} \mathrm{CZ}_e \right] |+\rangle^{\otimes |V|}.

Since CZ gates are diagonal and therefore commute with one another, the order in which they are applied is irrelevant, meaning there is great flexibility in the preparation of graph states and room for parallelisation in the application of the required CZ gates.

An important special case is the two-qubit graph state, which is locally equivalent to a maximally-entangled Bell pair. From the definition, a two-qubit graph state can be written,

\mathrm{CZ}|+\rangle|+\rangle = \frac{1}{2}(|0,0\rangle + |0,1\rangle + |1,0\rangle - |1,1\rangle).

Applying a Hadamard gate to either qubit we obtain,

H\cdot \mathrm{CZ}|+\rangle|+\rangle = \frac{1}{\sqrt{2}}(|0,0\rangle + |1,1\rangle),

the |\Phi^+\rangle Bell pair.

Note that while a two-qubit graph state is maximally entangled, graph states, in general, are not, whose entanglement structure is defined over graph neighbourhoods, which in general are not global. The exceptions are star and fully connected graphs, both locally equivalent to GHZ states, where the entire graph forms a single neighbourhood.

Graph states are incredibly useful as they enable measurement-based quantum computing (MBQC) [Raussendorf, Browne & Briegel (2003)], an alternative way of thinking about quantum computation to the regular circuit model. In MBQC, computation proceeds only by measuring qubits from a graph state of some topology (usually a lattice), where the order and basis in which qubits are measured dictates the implemented computation. This model for computation has no classical analogue and is uniquely quantum.

The universality of MBQC using graph states is easiest to demonstrate by considering its equivalence with the circuit model. Following the narrative of Nielsen (2005), this can be seen by noting that the following circuit for single-qubit quantum state teleportation relies on a resource of a |+\rangle state and a CZ gate.

Note that the local operation accumulated by the second qubit depends on the measurement outcome, m, of the first. This is a general feature of MBQC; feedforward is required to apply subsequent measurement-outcome-dependent local corrections whenever a measurement is performed.

Combining single-qubit teleporters in a linear chain enables a qubit to be successively teleported, each time accumulating local operations. It can be seen that the state acting as a resource for this succession of teleporters is identically a linear graph state.

This provides a means for building up single-qubit operations using a linear graph state. We must also introduce an entangling two-qubit gate to enable universality, which we will choose to be the CZ gate.

Now consider two linear graphs that teleport two input qubits, accumulating single-qubit operations along the way. At some point, we encounter a vertical bridge between these two linear graphs. As the qubits teleport past this bridge, they accumulate a CZ operation between them, as this is identically what the bridge represents.

Visually, we can see a direct connection between the circuit model and the MBQC model, where rows equate to logical qubits and columns to circuit depth. As columns of qubits are measured out from left to right, qubits are successively teleported from one column to the next, accumulating single-qubit operations along the way. When they encounter vertical bridges, the respective qubits acquire CZ operations, providing everything necessary for a universal quantum computation.

Measurement-based quantum computing could have equally been referred to as teleportation-based quantum computing.

Graph states are *stabiliser states*, meaning that an N-qubit state can be fully specified by N stabilisers, each of which is an N-fold tensor product of Pauli operators up to a factor of \{\pm 1,\pm i\}. A stabiliser is an operator under which the stabilised state is invariant, and the state is uniquely specified as the simultaneous +1 eigenstate of all N stabilisers,

S_i|\psi\rangle = |\psi\rangle,\,\,\forall\, i\in \{1,\dots,N\}.

Graph states have a stabiliser of the form,

S_i = X_i \bigotimes_{j\in n_i} Z_j

associated with every vertex i, where n_i denotes the neighbourhood of i, the set of vertices connected to i by an edge.

The structure of these stabilisers can be understood by noting that the |+\rangle state is stabilised by the X operator, X|+\rangle = |+\rangle. Upon applying a CZ gate between this qubit and a neighbour, the commutation relation,

\mathrm{CZ}_{i,j}\cdot X_i = X_iZ_j\cdot\mathrm{CZ}_{i,j},

implies the X_i stabiliser for qubit i gains an additional Z_j operator for every neighbour j connected by a CZ gate.

Equivalently, stabiliser states are the class of states obtained by evolving computational input states under Clifford operations (i.e. CNOT, CZ, Hadamard, Paulis & phase gates). Note that Clifford circuits map stabiliser states to stabiliser states, which is always classically efficient and insufficient for universal quantum computing [Gottesman (1998)]. However, with the addition of the single-qubit, non-Clifford T gate we obtain a universal gate set.

As an example, consider the following linear graph.

This graph has the stabilisers,

S_1 = X_1 \otimes Z_2

S_2 = Z_1 \otimes X_2 \otimes Z_3

S_3 = Z_2 \otimes X_3

If we were to apply a CZ gate to create a third edge, we would obtain a cyclic graph.

This would then have the stabilisers,

S_1 = X_1 \otimes Z_2 \otimes Z_3

S_2 = Z_1 \otimes X_2 \otimes Z_3

S_3 = Z_1 \otimes Z_2 \otimes X_3

The stabilisers associated with graph states can be represented as binary matrices, also referred to as a *tableau representation* or *generator matrix*, comprising an N\times N block representing the location of X operators and another for the location of Z operators,

[\mathbf{X} | \mathbf{Z}].

Noting that rows in this matrix can be arbitrarily permuted, the structure of graph state stabilisers, with exactly one X operator associated with each vertex, implies the X block can be expressed as the identity matrix with appropriate reordering, in which case the Z block corresponds to the adjacency matrix of the graph, noting that the rows and columns of an adjacency matrix capture respective vertex neighbourhoods, the Z operators from each stabiliser,

[\mathbf{X} | \mathbf{Z}] \to[I_N | A_G].

Using the previous example of a three-qubit linear graph, the stabilisers,

S_1 = X_1 \otimes Z_2

S_2 = Z_1 \otimes X_2 \otimes Z_3

S_3 = Z_2 \otimes X_3

can be expressed via the binary matrix,

\left[\begin{array}{ccc|ccc} 1 & 0 & 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 0 & 1 & 0\end{array}\right],

and it can be seen that the Z block corresponds to the expected adjacency matrix for a linear graph.

In addition to graph states being stabiliser states, all stabiliser states are locally equivalent to graph states. An efficient classical algorithm with O(N^3) runtime exists for transforming arbitrary stabiliser states into graph states using local operations [Vijayan *et al.* (2022)]. Using stabiliser transformation rules in the binary representation, the goal is to diagonalise the X block, achieved using a variant of Gaussian elimination.

The concept is best illustrated by example. Consider the 3-qubit GHZ state, which may be represented using the stabilisers,

S_1 = X_1\otimes X_2\otimes X_3

S_2 = Z_1\otimes Z_2

S_3 = Z_2\otimes Z_3

with the binary matrix representation,

\left[\begin{array}{ccc|ccc} 1 & 1 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 0 & 1 & 1\end{array}\right]

Let us first apply Hadamard gates to qubits 2 and 3. Hadamard gates interchange X and Z operators, since HXH=Z and HZH=X, and stabilisers evolve under conjugation. In the binary matrix representation, this swaps the respective columns from the X and Z blocks,

\left[\begin{array}{ccc|ccc} 1 & 0 & 0 & 0 & 1 & 1 \\ 0 & 1 & 0 & 1 & 0 & 0 \\ 0 & 1 & 1 & 0 & 0 & 0\end{array}\right].

Since the product of two stabilisers is also a stabiliser, arbitrarily multiplying them together, equivalent to bitwise XORing the respective matrix rows, does not change the description of the state. Applying S_3\to S_2 S_3, we obtain,

\left[\begin{array}{ccc|ccc} 1 & 0 & 0 & 0 & 1 & 1 \\ 0 & 1 & 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 1 & 0 & 0\end{array}\right].

Our matrix is now in the required form, and the Z block corresponds to the adjacency matrix of the 3-qubit star graph. In general, an N-qubit star graph is locally equivalent to an N-qubit GHZ state, as is the fully connected graph, K_N.

From the definition of a graph state, we know that CZ gates toggle the existence of edges between the vertices upon which they act. Graph states additionally exhibit elegant properties under the action of some gates and measurements, providing valuable tools for directly manipulating the graph structure associated with a state [Hein, Eisert & Briegel (2004), Hein *et al*. (2006)].

One important graph operation that will appear is *local complementation* (LC), represented by the graph operator \tau_i(G). Local complementation inverts (or complements) the edges in the subgraph induced by the neighbourhood of i.

Applying the square root of the graph stabiliser associated with vertex i,

\sqrt{S_i} = \sqrt{X_i} \bigotimes_{j\in n_i} \sqrt{Z_j},

directly implements the local complementation \tau_i,

\sqrt{S_i}|G\rangle \equiv |\tau_i(G)\rangle,

an isomorphism between the LC graph operator, \tau_i, and the state operator, \sqrt{S_i},

\sqrt{S_i} \cong \tau_i.

Note that \sqrt{S_i} comprises only local operations and hence does not affect entanglement. Nonetheless, we observe that its application generally changes the number of edges in the graph. This leads to the interesting observation that while edges in a graph state represent the application of maximally entangling CZ gates, the amount of entanglement in a graph state is not directly related to the number of edges. Locally equivalent graph states exhibiting identical entanglement structure can significantly differ in their edge count.

The extreme case is seen in the above example of the star and fully connected graphs, related by local complementation around the central vertex. Both of these states are locally equivalent to the maximally-entangled GHZ state, yet one contains the smallest number of edges a connected graph can have, O(N), while the other is maximally connected with O(N^2) edges.

While these are locally equivalent states with identical entanglement structure and computational characteristics, they differ enormously from an architectural implementation perspective. Were these two LC-equivalent states to be physically prepared using CZ gates, the star graph would clearly be preferable owing to its quadratically lower CZ count.

Single-qubit gates are generally far easier to implement than entangling ones, and theoreticians often assume they come for free. From the perspective of minimising CZ gate usage during state preparation, the *local complementation orbit* of a graph provides an avenue for optimisation.

Since local complementation comprises only local operations, all graphs related by LC are locally equivalent. The entire class of graphs related by LC is referred to as the graph’s *(local complementation) orbit*, whose size, in general, grows exponentially with the number of vertices, |V|.

Note that local complementations about different vertices do not commute in general,

\tau_i\circ\tau_j(G) \neq \tau_j\circ\tau_i(G),\,\,\forall\, G,i,j.

Simultaneously, the LC operation associated with a given vertex is its own inverse, an involution,

\tau_i =\tau_i^{-1},

\tau_i^2 = I.

The LC orbit of a graph admits a non-Abelian group structure, where the LC operators \tau_i act as the group generators, and the graphs in the orbit constitute the elements of the group. The orbit may itself be represented as a graph, the group’s Cayley graph. Here, vertices represent individual graphs in the orbit, and edges, labelled by group generators, relate them via LC operators. Since the LC operators are involutions, the Cayley graph of a graph orbit is undirected.

Graph orbits are hard to explore, given their in-general exponential scaling and the complexity of navigating them. Finding the LC-equivalence between two graphs is NP-complete in general, while the problem of counting the orbits of a graph is in general #P-complete [Dahlberg, Helsen & Wehner (2019); Adcock *et al.* (2020)].

A sequence of LC operations,

\tau_{\vec{u}}(G) = \tau_{u_{|u|}} \circ \dots \circ \tau_{u_1}(G)

may be represented by an ordered (since LC operators are non-commutative) list of vertex labels where complementations took place,

\vec{u} = \{u_1,\dots,u_{|u|}\},\,\,u_i\in V\,\,\forall\,i,

which may be of any length and have repeat entries.

A graph G’ is said to be a *vertex-minor* of G if it can be reached from G via a sequence of local complementations, \vec{u}, and vertex deletions, for which we use the notation,

G’<G.

The *vertex-minor problem* is the decision problem of finding a sequence of local complementations, \vec{u}, such that \tau_{\vec{u}}(G) = G’, up to vertex deletions, which may always be performed at the end.

This problem is known to be NP-complete in general, requiring exponential classical (and quantum) runtime. While complexity proofs are onerous, the intuition behind the NP-completeness of the vertex-minor problem can be seen by framing it as a satisfiability problem.

Defining the polynomial-time function,

f(\vec{u},G,G’)\to \begin{cases} 1, & \tau_{\vec{u}}(G) = G’ \\ 0, & \tau_{\vec{u}}(G) \neq G’ \end{cases}

solving vertex-minor is now equivalent to finding a satisfying input string, \vec{u}, such that f(\vec{u},G,G’)=1. Unstructured satisfiability (or SAT) problems of this form are NP-complete in general, noting there is more nuance than this as this is not an unstructured satisfiability problem.

Counting the orbits of the N-qubit GHZ state is definitely not #P-complete, as there are always exactly two. It therefore exhibits O(1) time-complexity, where 1=2.

Up to measurement-outcome-dependent local corrections, Pauli measurements implement simple graph transformation rules as follows:

- Pauli-Z: Delete vertex i from G,

G\to G-i.

- Pauli-Y: Locally complement the neighbourhood of i and delete vertex i,

G\to \tau_i(G)-i.

- Pauli-X: For any qubit b neighbouring i, locally complement b, apply rule for Y, then locally complement b again,

G\to \tau_b(\tau_i \circ \tau_b(G)-i).

Since Pauli measurements induce simple graph transformation rules, this immediately implies that graph states combined with Pauli measurements are classically efficient to simulate; simultaneously, Pauli measurements alone are insufficient for universal MBQC, which cannot be efficiently classically simulated. Furthermore, any local Clifford operation may be expressed in terms of efficient graph transformation rules [Van den Nest, Dehaene & De Moor (2004)]. This observation is analogous to the Gottesman-Knill theorem [Gottesman (1998)], that stabiliser states in combination with Clifford evolution and Pauli measurements are classically efficient to simulate, recalling that all stabiliser states are locally equivalent to graph states.

These measurement properties facilitate convenient surgical graph operations. Suppose we became aware that we lost a qubit from a graph state. Rather than discard the entire state and start from scratch, we can measure out the neighbouring qubits in the Z-basis, thereby detaching the lost qubit from the graph, after which the damaged section can be reconstructed by replacing the measured and lost qubits with fresh ones and reconnecting them using CZ gates.

Pauli measurements also provide the tools for contracting larger graphs with redundant qubits down to ones with the required substructure, thereby etching the structure into the graph. Any subgraph of G induced by vertex set S, G[S], may be obtained by measuring out all vertices V(G-S) in the Z basis, while Y measurements may be employed to perform contractions. This provides an elegant means for arguing that lattices of various topologies are universal for MBQC — if a lattice can be reduced to substructures reflecting arbitrary quantum circuits, it can be considered a substrate for universal MBQC.

Quantum algorithms are often designed in the circuit model. While etching circuits into a corresponding graph structure works by equivalence, it doesn’t exploit the more general graph-theoretic structure of graph states, rather imposing an existing way of thinking onto a different paradigm in a highly constrained way.

A more direct and resource-efficient approach for the compilation of quantum circuits into graph states was presented by Vijayan *et al.* (2022), known as *algorithm-specific graph states*, distinguishing them from universal ones like lattices. Conceptually, the approach is to structure quantum algorithms into a form where all Clifford circuitry — the bulk of most quantum algorithms — acts on the computational input state, thereby preparing a stabiliser state, while non-Clifford gates are performed at the end and may be absorbed into non-Clifford measurements.

Considering a universal gate set comprising Clifford and T gates, it is only the non-Clifford, single-qubit T gates that present an obstacle to graph state representation. One well-known technique for converting Clifford + T circuits into Clifford-only circuits is using *magic state injection.* Here, performing single-qubit teleportation using a,

|A\rangle=T|+\rangle=(|0\rangle+e^{i\pi/4}|1\rangle)/\sqrt{2}

resource state, known as a *magic state*, implements quantum gate teleportation of a T gate. Since the teleportation circuit itself is Clifford-only, this allows any circuit to be expressed in a form comprising only Clifford operations, where some inputs are non-stabiliser states.

The T gate teleportation protocol can also be inverted, relying on measurement of the non-Clifford

A(\pi/4)=T^\dag X T

observable instead of magic states. This inverted form allows Clifford + T circuits to be expressed as stabiliser states followed by non-Clifford measurements.

Since stabiliser states are locally equivalent to graph states, this decomposition allows universal quantum circuits to be directly compiled to graph states, where computation proceeds via non-Clifford measurements.

Algorithm-specific graph states capture the entanglement structure of algorithms much more naturally than an etched circuit would. However, the resultant graphs are not unique, as their orbits are computationally equivalent.

Graph optimisation therefore becomes an important next stage in the compilation pipeline. The optimal graph for implementing a given algorithm has many variables and is subject to architectural constraints, but identifying them generally yields computationally complex optimisation problems associated with the complexity of exploring graph orbits.

The commutativity of CZ gates implies they are order-independent. In the context of graph states, this means edges needn’t be built up sequentially but can be parallelised, and divide-and-conquer strategies may be employed to build up large graph states from smaller subgraphs that may be prepared independently and in parallel.

This becomes especially useful when entangling gates are non-deterministic, as is often the case in many physical architectures and necessarily the case when dealing with photonic implementation.

Consider a linear graph state with N qubits. One might think that preparing this state requires successfully performing N-1 CZ gates in succession, meaning that if the gates are non-deterministic with success probability p_\mathrm{gate}, the overall state preparation probability would be p_\mathrm{gate}^{N-1}, which is exponentially decreasing and therefore inefficient.

However, this is not the correct intuition for graph states, which are generally not maximally entangled and from the Pauli measurement properties, enable a state to be rescued via surgical operations when local defects occur.

Rather than building the linear graph in a single shot, let us consider the following scenario, taken from Rohde & Barrett (2007). We have a main linear graph of length N and a resource of small linear graphs of length M, which are prepared offline. We are assuming the availability of quantum memory, or qubits with inherently long decoherence times, to enable this protocol.

We will employ a CZ gate that succeeds with probability p_\mathrm{gate}, and upon failure, destroys the qubits it acts upon, effectively tracing them out of the system.

Upon applying the CZ gate between the two graphs of length N and M, with probability p_\mathrm{gate}, the main graph grows in length to N+M. Upon failure, with probability 1-p_\mathrm{gate}, the end qubit is destroyed, and we recover the remainder of the graph by measuring out its neighbour in the Z basis, shrinking it in length to N-2.

Applying this process repeatedly, the length of our main graph proceeds as a random walk, probabilistically growing or shrinking. The figure of merit is the average length by which the graph grows or contracts. In our case, this can easily be calculated to be,

\langle\Delta\rangle = p_\mathrm{gate}M - 2(1-p_\mathrm{gate}).

If the graph is to grow on average, we require \langle\Delta\rangle > 0, which implies,

M>2(1-p_\mathrm{gate})/p_\mathrm{gate}.

A CZ gate operating with 50% probability would only require M=3 resource states to ensure growth on average.

So long as the resource states we employ are at least length M, our main graph is guaranteed to grow on average, with length growing linearly in the number of iterations t,

\langle N(t)\rangle = N(0) + \langle\Delta\rangle\cdot t.

While the above argument is for linear graph states, linear graphs alone are not computationally useful. For MBQC, we require at least a two-dimensional topology, such as a lattice. It was first shown by Nielsen (2004) how graph structure can be exploited to enable efficient preparation of arbitrarily large lattice graph states using non-deterministic gates by introducing the concept of *micro-clusters*. Micro-clusters are small subgraphs of a larger graph state with multiple dangling nodes, each providing an independent bonding opportunity. Micro-clusters, therefore, provide redundancy in bonding attempts should they sometimes fail.

How large do micro-clusters need to be? The probability of a micro-cluster failing to bond with another drops exponentially with the number of available attempts, M,

p_\mathrm{fail} = (1-p_\mathrm{gate})^M,

which implies the number of available bonds must scale as,

M>\frac{\log(p_\mathrm{fail})}{\log(1-p_\mathrm{gate})},

which is only logarithmic and highly efficient. Achieving 99% bonding probability using gates with 50% success probability requires only M=7 available bonds.

This observation affords enormous resource savings in the context of linear optics quantum computing (LOQC), where micro-clusters were first introduced. Resource overheads associated with the non-determinism of entangling gates in LOQC using the initial circuit-based construction described by Knill, Laflamme & Milburn (2001) (aka KLM) were ‘efficient’ in the computer scientist’s sense of exhibiting polynomial scaling but not in a practical sense as the polynomials were unpleasant ones.

Percolation theory studies the connectedness of percolated graphs (ones with random defects) as a function of defect rate, p_\mathrm{delete}. Percolations could apply to either edges or vertices, and the measure of connectedness could be defined in many ways, commonly whether routes exist spanning the graph.

Taking an edge- or vertex-percolated lattice in the limit of large lattice dimension, L, and considering the probability of connectedness as a function of percolation probability, p_\mathrm{delete}, percolation theory predicts phase-transitions in graph connectivity at some percolation threshold, p_c.

Consider a lattice of micro-clusters. As a function of their size and gate success probability, there exists an associated probability of edge deletion in the subsequent reduced substrate graph.

The relationship between lattice dimension and computational power implies one between percolation probability and computational power [Browne *et al.* (2008); Pant *et al.* (2019); Wei, Affleck & Raussendorf (2012)]. Since the likelihood of finding paths through a graph is a function of the percolation rate, so is the expected density, hence dimension, of a lattice reduced from the available paths.

A percolated lattice graph state with missing qubits (i.e. vertex percolations — one could likewise consider edge percolations), where squares are qubits, yellow if present.

A route-finding algorithm finds sets of edge-disjoint left-to-right (red) and top-to-bottom (green) paths. The path density is a function of the percolation rate.

The path set is reduced to a regularised substrate, here an alternating bridge decomposition, a resource for universal MBQC.

All qubits not belonging to our path-set are measured out in the Z basis, while paths are contracted using Y measurements, reducing the graph to a regularised substrate of some dimension, which directly relates to its computational power.

This yields a relationship between computational power and percolation probability, where we observe computational phase-transitions for large graph dimension, L\to\infty. Above threshold, p_\mathrm{delete}>p_c, we rapidly lose computational power as the graph disconnects into islands and spanning paths cease to exist. The percolation threshold is an important parameter for engineering scalable architectures using this approach.

Since the dimension of the residual lattice is a function of the percolation rate, in turn a function of micro-cluster size and gate success probability, there exists a trade-off between the resources invested into micro-cluster size and computational return, a point of optimisation from an engineering perspective.

Although by definition, the edges in graph states represent the action of CZ gates, these are not the only gates capable of growing graph states. Depending on the physical implementation, various other approaches to creating graph edges exist.

In photonic quantum computing, fusion gates [Browne & Rudolph (2005)] can be used to create connections in graphs. Fusion gates are partial Bell measurements, implemented using polarising beamsplitters (see my previous post, “How do photonic Bell measurements work?”). While fusion gates create new edges in a graph state, they are also destructive, meaning they destroy the two qubits they operate on. This implies some resource overhead, although this overhead is far more favourable than that imposed by optical CZ gates, which are highly complex and resource intensive to implement.

In atomic systems with suitable level structure, where energy levels couple to optical modes, a beamsplitter followed by photo-detection implements which-path erasure on photons emitted via relaxation processes, projecting the two atoms into a symmetric superposition of one being excited state and the other relaxed, equivalent to a Bell projection.

As with quantum circuits, graph states are subject to various error models. How do these propagate through graph states?

Since quantum information flows through graph states via teleportation, so will errors. Consider the single-qubit teleportation circuit, where the local correction applied to the second qubit depends on the measurement outcome of the first. If a Pauli error was introduced onto the first qubit, flipping its measurement outcome, m, this would subsequently manifest itself as a flipped local correction on the second qubit, thereby propagating the error.

In general, as qubits are measured out of a graph state, errors acting upon them are teleported onto neighbouring qubits and accumulate. In the context of micro-cluster-based approaches for tolerating gate failure, the dangling bonds facilitating multiple bonding attempts, which must subsequently be removed, imposes a trade-off between errors. While more dangling bonds implies greater tolerance against gate failure, it simultaneously implies lower tolerance against Pauli errors, which accumulate whenever a redundant bond is removed via measurement.

It is desirable to avoid unnecessarily preparing and subsequently measuring out redundant qubits, and the overall design of a measurement-based architecture must carefully evaluate the inherent tradeoffs between different error types.

Although lattice graphs are universal for MBQC, as arbitrary circuit structures can be etched into them, in addition to being wasteful, this results in unnecessary accumulation of errors.

Graph states are not inherently error-protected, and quantum error correction (QEC) is required as with any other model of quantum computation. Thankfully, this does not require abandoning the inherent elegance of graph states as there are graph-native QEC codes. In particular, topological codes naturally lend themselves to graph-based implementation [Raussendorf, Harrington & Goyal (2006)].

An example is the surface code [Kitaev (2003)], defined relative to a square lattice graph. Although the way surface code stabilisers are defined is distinct from graph states, a direct mapping exists between them under appropriate graph transformations [Bravyi & Raussendorf (2007)].

Such graph-based QEC codes connect us with the field of topology, where the manifestation of errors and implementation of logical operations may be defined in terms of topological invariants — properties that remain invariant under continuous deformation, from which they inherit their robustness.

For example, continuously deforming a non-trivial loop around a torus (see figure below) preserves its topological characterisation. Associating logical operators with operator strings around a loop bestows redundancy in how the logical operator can be applied. Should defects rule out a particular path, another topologically equivalent one can be chosen, allowing defects to be bypassed.

Fusion-based quantum computing [Bartolucci *et al.* (2021)] is a scalable, fault-tolerant, photonic architecture (although also applicable to other physical architectures), integrating many of the concepts we have discussed. This scheme admits more elaborate resource states with small QEC codes built into them, such that some qubits act as parity checks when measured.

Fusion gates (non-deterministic, destructive Bell measurements), implemented using polarising beamsplitters (discussed earlier), enable fusion between unit cells of encoded resource states into a three-dimensional *fusion network* with random defects associated with unsuccessful fusions.

Fusion measurement outcomes reveal a percolated three-dimensional lattice with average case connectivity sufficient to post-select a substructure supporting a scalable topological code in addition to the syndrome outcomes for the associated code.

The goal of quantum communications networks is usually to distribute long-range Bell pairs, equivalently two-qubit graph states. Bell pairs act as a universal resource for quantum communication as they enable quantum state teleportation.

Since long-range quantum communication is generally very lossy, with attenuation increasing exponentially with distance, quantum repeater networks (or entanglement distribution networks) use divide-and-conquer techniques to subdivide long-range links into multiple short-range ones, which are iteratively merged using entanglement swapping, enabling the exponential scaling of loss with distance to be overcome and replaced with polynomial scaling.

This can also be conceptualised in terms of graph states. Based upon the same intuition for efficiently growing arbitrarily large graph states using non-deterministic gates, graph states can similarly be employed for efficient entanglement distribution in the presence of lossy channels, allowing the exponential attenuation of single-shot transmission to be overcome and replaced with efficient polynomial scaling.

Our graph state tools for dealing with gate failure (equivalently loss) can be adapted for this purpose. Using micro-cluster-type concepts, redundant bonds counter channel loss by facilitating multiple bonding attempts, where the failure of a single attempt does not compromise the remaining state.

Applying this iteratively, the goal is to engineer a distributed graph state, which can subsequently be reduced to a long-range Bell pair upon measuring out redundant, intermittent qubits.

In addition to their utility in efficiently overcoming loss in quantum repeater networks, distributed graph states act as a versatile resource for entanglement distribution. Assuming nodes in the network are cooperative and classically communicating, we have the tools to etch out subgraphs (using Z measurements) and contract them down to involve only the desired parties (using X and Y measurements).

Of particular interest are Bell pairs. Our graph transformation rules for Pauli measurements guarantee that any connected graph may be reduced to a Bell pair between any pair of nodes.

Other states of interest might also be available depending on the initial graph’s topology. GHZ states are of interest as they are maximally entangled states that facilitate various multiparty quantum protocols such as open-destination quantum state teleportation and quantum anonymous broadcasting [Christandl & Wehner (2005)]. These can be realised by etching out star graphs. In the special case of 3-qubit GHZ states, any connected 3-qubit graph state, of which there are only two (star and fully connected), is locally equivalent to a GHZ state, and any connected graph with at least three qubits can necessarily be reduced to these using Pauli measurements.

However, we are not limited to measurements when manipulating distributed graph states. We can also play local complementation games, which can be exploited in graph-state-based entanglement routing [Hahn, Pappa & Eisert (2019)].

In a futuristic scenario where large-scale quantum computers and quantum communications networks are readily available, there is a strong incentive to unify geographically dispersed quantum computational resources. Given that the power of quantum computers can, depending on the application, grow exponentially with their number of logical qubits, unifying quantum computers to act as one effectively multiplies their power, which would only accumulate additively in the absence of unification, as per classical computers.

Graph states provide an elegant framework for conceptualising how to architecturally achieve this unification.

The dimensions of the underlying lattice graph dictate the size and power of a MBQC. In the earlier example, the width of the lattice equated with circuit depth and height with the number of logical qubits involved in the computation.

Suppose two independent quantum computers individually had the capacity for N\times N lattice graphs. Rather than use them separately, with quantum communication at our disposal, enabling the creation of long-range links, our two units could stitch their lattices together in a patchwork manner, providing a distributed 2N\times N lattice, affording twice as many logical qubits or twice the circuit depth, an idea that logically generalises to any topology or number of nodes.

Graph states are often equated with measurement-based quantum computing and seen merely as a different way of achieving the same thing. However, graph states provide far more than a direct equivalence with other models of quantum computation, like the circuit model. They provide an alternate framework for conceptualising the flow and interaction of quantum information, enabling unique insights that would not come naturally from the confines of other models. These insights have been of enormous value beyond computation, finding widespread utility in other quantum information processing protocols.

The geometric abstractions graph states provide have facilitated significant advances in solving practical problems, without which a quantum future would be far less likely. In photonic quantum computing, for example, implementation via the circuit model imposes formidable — effectively prohibitive — resource overheads, for which the graph state model affords natural solutions.

Graph states have enabled quantum information processing to be united with otherwise disparate fields of mathematics, providing direct connections with graph theory, percolation theory and topology. Graph theory provides powerful tools for conceptualising the flow of quantum information and associating quantum operations with graph transformations. The connection with the field of percolation theory offers insight into the relationship between errors and quantum computational power. Graph theoretical approaches towards quantum error correction intimately connect with the field of topology, in which codes and operations can be abstracted in terms of topological invariants.

As quantum information scientists, we attempt to understand things inherently too complex to contemplate directly and must rely on different types and levels of abstraction. Problems can generally be approached from different angles, and looking at the same problem through a different lens can yield new insights and a deeper understanding. Having a broad toolkit of different angles of interpretation for viewing problems is essential. Graph states are an incredibly powerful one, enabling us to find solutions to problems that might otherwise not have been found.

*Measurement-based quantum computation with cluster states*, Raussendorf, Browne & Briegel (2003)*Optical quantum computation using cluster states*, Nielsen (2004)*Resource-efficient linear optical quantum computation*, Browne & Rudolph (2004)*Cluster-state quantum computation*, Nielsen (2005)*A fault-tolerant one-way quantum computer*, Raussendorf, Harrington & Goyal (2006)*Multi-party entanglement in graph states*, Hein, Eisert & Briegel (2004)*Graphical description of the action of local Clifford transformations on graph states*, Van den Nest, Dehaene & De Moor (2004)*Entanglement in graph states and its applications*, Hein*et al.*(2006)*Strategies for the preparation of large cluster states using non-deterministic gates*, Rohde & Barrett (2007)*Phase transition of computational power in the resource states for one-way quantum computation*, Browne*et al.*(2007)*All photonic quantum repeaters*, Azuma, Tamaki & Lo (2018)*Percolation thresholds for photonic quantum computing*, Pant*et al.*(2019)*Mapping graph state orbits under local complementation*, Adcock*et al.*(2020)*Fusion-based quantum computation*, Bartolucci*et al.*(2021)*Compilation of algorithm-specific graph states for quantum circuits*, Vijayan*et al.*(2022)

Thank you very much to the authors allowing figures from their work to be reproduced in this post, acknowledged individually in figure captions. Thanks to Dan Browne for helpful feedback.

The post An introduction to graph states appeared first on Peter Rohde.

]]>The post New paper: Proof-of-work consensus by quantum sampling appeared first on Peter Rohde.

]]>**Abstract:** Since its advent in 2011, boson-sampling has been a preferred candidate for demonstrating quantum advantage because of its simplicity and near-term requirements compared to other quantum algorithms. We propose to use a variant, called coarse-grained boson-sampling (CGBS), as a quantum Proof-of-Work (PoW) scheme for blockchain consensus. The users perform boson-sampling using input states that depend on the current block information, and commit their samples to the network. Afterward, CGBS strategies are determined which can be used to both validate samples and to reward successful miners. By combining rewards to miners committing honest samples together with penalties to miners committing dishonest samples, a Nash equilibrium is found that incentivizes honest nodes. The scheme works for both Fock state boson sampling and Gaussian boson sampling and provides dramatic speedup and energy savings relative to computation by classical hardware.

The post New paper: Proof-of-work consensus by quantum sampling appeared first on Peter Rohde.

]]>The post How do photonic Bell measurements work? appeared first on Peter Rohde.

]]>In this post I’ll describe how this very simple optical circuit works and address some of the nuances and common misconceptions surrounding it.

A Bell measurement is a two-qubit operation that projects onto the maximally-entangled Bell basis comprising the four Bell states,

|\Phi^\pm\rangle_L = \frac{1}{\sqrt{2}}(|0,0\rangle_L \pm |1,1\rangle_L),

|\Psi^\pm\rangle_L = \frac{1}{\sqrt{2}}(|0,1\rangle_L \pm |1,0\rangle_L).

Here I’m using subscript *L* to denote logical qubit states. States represented without a subscript will denote Fock (or photon-number) states in an occupation number representation, where |n\rangle denotes an n-photon state.

While there are many ways in which entangling measurements can be implemented photonically, I’ll focus on by far the simplest, most well-known and widely employed implementation shown below.

This circuit implements a partial, destructive and non-deterministic Bell measurement. It is partial in the sense that it can only resolve two of the four Bell states. Otherwise it fails, implying non-determinism. And it is destructive in the sense that the measured qubits are destroyed by the measurement process.

The measurement projector implemented by this device is,

\hat\Pi^\pm_L =|\Phi^\pm\rangle_L\langle\Phi^\pm|_L,

a coherent projection onto one of the two even parity Bell pairs.

Bell measurements can also be implemented using CNOT gates, in which case all four Bell states can be non-destructively resolved. However, CNOT gates are notoriously difficult to construct in an optical setting, are non-deterministic, and have significant resource overheads.

A regular beamsplitter implements a 2\times 2 unitary transformation on the photon creation operators associated with two spatial modes, which we will denote \hat{a}^\dag_1 and \hat{a}^\dag_2,

\begin{bmatrix} \hat{a}^\dag_1 \\ \hat{a}^\dag_2\end{bmatrix} \to \begin{bmatrix} U_{1,1} & U_{1,2} \\ U_{2,1} & U_{2,2}\end{bmatrix} \begin{bmatrix} \hat{a}^\dag_1 \\ \hat{a}^\dag_2\end{bmatrix}.

Here we’re modeling evolution in the Heisenberg picture, representing state evolution via transformations on the photon creation operators acting on the vacuum state. This is the most convenient approach since all the operations we consider are represented by linear transformations of creation operators, hence the term *linear optics*.

For a balanced 50/50 beamsplitter we have,

U = \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1\end{bmatrix},

which is recognisable as the 2\times 2 Hadamard matrix.

This is an entangling operation as it can easily be seen that the state,

|1,0\rangle = \hat{a}^\dag_1|vac\rangle,

is evolved to,

\frac{1}{\sqrt{2}}(\hat{a}^\dag_1 + \hat{a}^\dag_2)|vac\rangle = \frac{1}{\sqrt{2}}(|1,0\rangle + |0,1\rangle),

a Bell state encoded as a superposition of a single particle across two orthogonal modes.

A polarisation rotation, usually implemented using waveplates in experiments, implements exactly the same transformation in the polarisation degree of freedom,

\begin{bmatrix} \hat{h}^\dag \\ \hat{v}^\dag \end{bmatrix} \to\begin{bmatrix} U_{1,1} & U_{1,2} \\ U_{2,1} & U_{2,2}\end{bmatrix} \begin{bmatrix} \hat{h}^\dag \\ \hat{v}^\dag \end{bmatrix},

where \hat{h}^\dag and \hat{v}^\dag denote creation operators associated with horizontal and vertical polarisation.

Hence an input state,

\hat{h}^\dag|vac\rangle= |1\rangle_H|0\rangle_V,

is evolved by the Hadamard matrix to,

\frac{1}{\sqrt{2}}(\hat{h}^\dag + \hat{v}^\dag)|vac\rangle = \frac{1}{\sqrt{2}}(|1\rangle_H|0\rangle_V + |0\rangle_H|1\rangle_V).

Indeed, beamsplitters and polarisation rotations are isomorphic operations, implementing identical optical transformations, differing only in which pair of modes they operate on.

Hong-Ou-Mandel (HOM) interference is a famous interferometric experiment in which a 50/50 beamsplitter interferes two photons, one incident upon each beamsplitter input.

Using the 50/50 beamsplitter transformation, an initial state with a single photon at each input,

\hat{a}^\dag_1 \hat{a}^\dag_2 |vac\rangle = |1,1\rangle,

transforms to,

\frac{1}{2}(\hat{a}^\dag_1 + \hat{a}^\dag_2)(\hat{a}^\dag_1 - \hat{a}^\dag_2)|vac\rangle = \frac{1}{\sqrt{2}}(|2,0\rangle - |0,2\rangle),

a superposition of two photons in one spatial output or two in the other. Note there is no |1,1\rangle term, as these have cancelled via destructive interference. This phenomenon is called *photon bunching*, as the photons ‘bunch’ together and never appear at different outputs, a uniquely quantum effect. Contrast this with classical statistics where we would expect to see anti-bunching (one particle at each output) 50% of the time.

We can replicate the same phenomenon using polarisation encoding by commencing with a two-photon state, where one is horizontally polarised, the other vertically,

\hat{h}^\dag \hat{v}^\dag |vac\rangle = |1\rangle_H|1\rangle_V,

which transforms to,

\frac{1}{2}(\hat{h}^\dag + \hat{v}^\dag)(\hat{h}^\dag - \hat{v}^\dag)|vac\rangle = \frac{1}{\sqrt{2}}(|2\rangle_H |0\rangle_V - |0\rangle_H|2\rangle_V).

A polarising beamsplitter (PBS) operates very differently than a regular beamsplitter, acting on two spatial degrees of freedom, each of which is associated with two polarisation degrees of freedom, making it a four-mode transformation. Most commonly, PBS’s completely reflect one polarisation (say *H*) while completely transmitting the other (*V*), in which case the 4\times 4 transformation is,

\begin{bmatrix} \hat{h}_1^\dag \\ \hat{h}_2^\dag \\ \hat{v}^\dag_1 \\ \hat{v}^\dag_2 \end{bmatrix} \to \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{bmatrix} \begin{bmatrix} \hat{h}_1^\dag \\ \hat{h}_2^\dag \\ \hat{v}^\dag_1 \\ \hat{v}^\dag_2 \end{bmatrix}.

It can be seen that this operation simply permutes modes, leaving the \hat{h}^\dag_1 and \hat{h}^\dag_2 operators unchanged, whilst swapping the \hat{v}^\dag_1 and \hat{v}^\dag_2 operators.

Beginning with any initially separable state in the original *H*/*V* basis, this operation preserves separability and cannot introduce entanglement, nor does any interference take place. Note that while this 4\times 4 matrix corresponds to that of a CNOT gate, this is not a CNOT operation as this matrix describes a transformation on creation operators not qubits.

In the field of photonic quantum computing, qubits are most commonly encoded in one of two ways: dual-rail encoding and polarisation encoding. In dual-rail encoding we encode a qubit as a single photon in superposition across two distinct spatial modes. In polarisation encoding we encode a single photon in superposition across two polarisation states.

Using these two encodings, a single logical qubit,

|\psi\rangle_L = \alpha|0\rangle_L + \beta|1\rangle_L,

can be written as,

|\psi\rangle_\mathrm{dual-rail} = \alpha|1,0\rangle + \beta|0,1\rangle,

|\psi\rangle_\mathrm{polarisation} = \alpha |1\rangle_H|0\rangle_V + \beta|0\rangle_H|1\rangle_V.

Using photonic creation operators we can equivalently express these as,

|\psi\rangle_\mathrm{dual-rail} = (\alpha \hat{a}_1^\dag + \beta \hat{a}_2^\dag)|vac\rangle,

|\psi\rangle_\mathrm{polarisation} = (\alpha \hat{h}^\dag + \beta \hat{v}^\dag)|vac\rangle.

Note that in an occupation number representation both of these can be expressed,

|\psi\rangle = \alpha |1,0\rangle + \beta|0,1\rangle,

where for dual-rail encoding the two modes are spatial modes, while for polarisation encoding they refer to the two polarisation modes.

There also exists *single-rail encoding*, whereby a qubit is encoded in a single mode as a superposition of 0 or 1 photons. The Bell state created previously at the output of a 50/50 beamsplitter fed with a single photon input is an example of single-rail encoding. However this type of encoding has limited utility as implementing operations on single-rail qubits is highly impractical. Since the two logical basis states have different photon-number, hence energy, single-qubit gates require coherently manipulating a superposition of different amounts of energy.

In the \{|1,0\rangle,|0,1\rangle\} occupation number basis the beamsplitter and polarisation rotation operations both implement the transformations,

\begin{bmatrix} |1,0\rangle \\ |0,1\rangle \end{bmatrix} \to \begin{bmatrix} U_{1,1} & U_{1,2} \\ U_{2,1} & U_{2,2} \end{bmatrix} \begin{bmatrix} |1,0\rangle \\ |0,1\rangle \end{bmatrix},

in their respective degrees of freedom. Defining the logical basis states of a single qubit as,

|0\rangle_L \cong |1,0\rangle,

|1\rangle_L \cong |0,1\rangle,

we see that the beamsplitter and polarisation rotation operations implement 2\times 2 single-qubit unitary transformations.

So while beamsplitters and polarisation rotations are entangling operations on two optical modes, they represent single-qubit (hence non-entangling) operations when acting on qubits defined over the single-photon symmetric subspace of two modes. We refer to this as a *symmetric* *subspace* since the qubit space is invariant under permutations of the constituent optical modes. That is, any permutation of the optical modes, of which there are two (identity or swap), leaves the basis \{|1,0\rangle,|0,1\rangle\} unchanged.

Consider two arbitrary multi-qubit systems, |\psi\rangle and |\phi\rangle. Applying a Schmidt decomposition to both systems, separating out one polarisation-encoded qubit from each, which we will subsequently perform Bell measurement on,

|\psi\rangle = \alpha_0 |\psi_0\rangle|H\rangle + \alpha_1 |\psi_1\rangle|V\rangle \\|\phi\rangle = \beta_0 |\phi_0\rangle|H\rangle + \beta_1 |\phi_1\rangle|V\rangle.

Expanding this out and expressing the isolated qubits in terms of creation operators we have,

(\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle \hat{h}^\dag_1 \hat{h}^\dag_2 + \alpha_0\beta_1 |\psi_0\rangle |\phi_1\rangle \hat{h}^\dag_1 \hat{v}^\dag_2 \\+ \alpha_1\beta_0 |\psi_1\rangle |\phi_0\rangle \hat{v}^\dag_1 \hat{h}^\dag_2 + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle \hat{v}^\dag_1 \hat{v}^\dag_2)|vac\rangle.

Evolving this through the PBS we obtain,

(\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle \hat{h}^\dag_1 \hat{h}^\dag_2 + \alpha_0\beta_1 |\psi_0\rangle |\phi_1\rangle \hat{h}^\dag_1 \hat{v}^\dag_1 \\+ \alpha_1\beta_0 |\psi_1\rangle |\phi_0\rangle \hat{v}^\dag_2 \hat{h}^\dag_2 + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle \hat{v}^\dag_2 \hat{v}^\dag_1)|vac\rangle.

Considering only the coincidence terms we post-select upon where each spatial output has exactly one photon this reduces to,

(\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle \hat{h}^\dag_1 \hat{h}^\dag_2 + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle \hat{v}^\dag_2 \hat{v}^\dag_1)|vac\rangle.

From here if we measure the two qubits in the *H*/*V* polarisation basis, we will collapse onto either,

\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle,

or

\alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle,

depending on whether we measure *H*/*H* or *V*/*V*.

However, what we really want is a coherent projection onto both of these terms. If instead of measuring in the *H*/*V* basis we measure in the diagonal (|\pm\rangle_L=(|0\rangle_L \pm|1\rangle_L)/\sqrt{2}) basis we achieve this. The polarisation rotations prior to the photodetectors switch us into the diagonal basis. In qubit space, the balanced 50/50 beamsplitter transformation corresponds to a Hadamard gate, as does a 45° polarisation rotation, which effectively transforms the subsequent measurement from the computational \hat{Z} basis to the diagonal \hat{X} basis.

Applying the polarisation rotation we obtain,

\frac{1}{2}[\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle (\hat{h}^\dag_1 + \hat{v}^\dag_1) (\hat{h}^\dag_2 + \hat{v}^\dag_2) \\+ \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle (\hat{h}^\dag_1 - \hat{v}^\dag_1) (\hat{h}^\dag_2- \hat{v}^\dag_2)]|vac\rangle.

Expanding and regrouping this expression according to the different possible measurement outcomes we can write this as,

\frac{1}{2}[(\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle) \hat{h}^\dag_1 \hat{h}^\dag_2 \\+ (\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle) \hat{v}^\dag_1 \hat{v}^\dag_2 \\+ (\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle - \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle) \hat{h}^\dag_1 \hat{v}^\dag_2 \\+ (\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle - \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle) \hat{v}^\dag_1 \hat{h}^\dag_2]|vac\rangle.

Therefore, upon measuring either *H*/*H* or *V*/*V* we obtain,

\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle + \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle,

whereas if we measure *H*/*V* or *V*/*H* we obtain,

\alpha_0\beta_0 |\psi_0\rangle |\phi_0\rangle - \alpha_1\beta_1 |\psi_1\rangle |\phi_1\rangle,

which are the expected outcomes upon applying the,

\hat\Pi^\pm_L = |\Phi^\pm\rangle_L\langle\Phi^\pm|_L,

projectors.

What happens if rather than measuring a coincidence event we measure both photons at one output? Referring to the previous figure we see that if the input state was \hat{h}^\dag_1\hat{v}_2^\dag|vac\rangle both photons exit the top-left output, while if the input state was \hat{v}^\dag_1\hat{h}_2^\dag|vac\rangle both photons exit the top-right output. This means that if we measure two photons at one output we know exactly what the polarisation of both inputs was. Therefore, when the device fails to project onto the even-parity subspace it performs a computational basis (\hat{Z}) measurement on both qubits.

The above calculation is completely legitimate, but it isn’t clear at all where the entanglement comes from in our entangling measurement. The PBS is a non-entangling operation, and both our inputs and the post-selected outputs are in the qubit basis, whereby polarisation rotations implement single-qubit operations. It sounds like everything involved is non-entangling?

The resolution to the paradox is found in the terms we post-selected away. The non-coincidence terms that we eliminated were of the form \hat{h}^\dag\hat{v}^\dag, one such term associated with each of the PBS outputs, which subsequently undergo polarisation rotation. These two-photon terms are not confined to qubit space and undergo HOM interference, creating highly entangled two-photon terms of the form \hat{h}^{\dag^2}-\hat{v}^{\dag^2}.

So while our input states can be considered polarisation encoded qubits and the overall transformation implemented by the device is a two-qubit entangling gate, *internally* our states are not confined to qubit space and the polarisation rotations prior to the detectors cannot be strictly considered as single-qubit gates. Rather, they are highly entangling multi-photon operations on two optical modes.

Entanglement is always defined relative to a basis and a state which is entangled in one basis needn’t be entangled in another. The most obvious example is that a Bell state is entangled in the qubit basis but not entangled in the Bell basis and vice-versa. Here we’ve defined a qubit space as the single-photon subspace of a two-mode Fock space, where entangling operations in the latter define local operations in the former.

It is correct to say that our partial Bell analyser relies on Hong-Ou-Mandel interference. But it doesn’t take place in the polarising beamsplitter, it takes place within the waveplates.

In our optical circuit we required polarisation-resolving photodetectors. In practise, photodetectors available to us in the laboratory don’t have the ability to do this directly – they only resolve photon-number. However, this can easily be overcome by utilising an additional PBS to spatially separate and independently detect a state’s polarisation components, as shown below.

So our original optical circuit, when experimentally implemented, will actually comprise three PBS’s and four photodetectors, and the full circuit will look like this.

(*Acknowledgement: Thank you to Felix Zilk for providing very helpful feedback on this post.*)

The post How do photonic Bell measurements work? appeared first on Peter Rohde.

]]>The post Response to “Pause Giant AI Experiments: An Open Letter” appeared first on Peter Rohde.

]]>• While the intention is well-meaning and the risks are real, the analysis is superficial and unlikely to play out as suggested.

• Although there are undeniably major risks presented by advanced AI, a moratorium is unlikely to further progress in dealing with them and more likely hinder it. Political responses to disruptive forces tend to be reactionary rather than preemptive and it is not foreseeable that during such a moratorium political and regulatory solutions will be implemented. It is naive to think that if presented with a six month window of opportunity to consider the implications of AI that politicians and regulators are going to make use of it to formulate a master plan. Societal consensus and political responses to complex emerging problems do not take place over such short timescales, and attempts to do so are likely to be poorly considered.

• Such a moratorium is necessarily voluntary as there are no mechanisms for global enforcement, meaning that only good actors will participate, tilting the balance of power in the AI sphere in favour of bad actors.

• Technological advancement is inherently disruptive and there are many instances through modern history where technology has made types of human labour redundant. However, it is very clear that embracing technology has in general driven humanity forward not backward.

• Attempting to inhibit technological advancement is largely futile and unenforceable. Adapting to embrace it is by far the best approach. Adaptation is an evolutionary process, not something that can be decided in advance. We are not in a position to make advance determinations as there are too many unknowns and the spectrum of implications is unclear.

• Obstructing technological advancement that competes against us is a form of protectionism. Recently Italy placed a ban on ChatGPT, and some other EU nations are reportedly considering the same. Doing so, rather than encouraging home-grown development of AI industries represents a major economic setback, enforces competitive disadvantage, and missed opportunity that risks future economic irrelevance. This is not to say that Italy’s privacy-related concerns have no merit. However, placing an outright ban on emerging technologies, rather than adapting to them in tandem with their development is backward thinking. The same line of reasoning could equally be used to justify banning any of the cloud services we all rely on or the internet as a whole.

• Yes, advanced AI will be highly disruptive, but also transformative, with the potential to act as a huge multiplier on productivity, which drives economic progress and human development. Wilfully delaying or missing this opportunity is economically and strategically destructive, handing power to competitors and adversaries.

• We definitely should be acting quickly in considering the ethical and broader implications of AI upon society, but placing a halt on technological progress isn’t going to expedite this process. That will happen as the implications becomes tangible, and in the meantime we’ll have only delayed progress for no reason.

• Openness and transparency are the most powerful forces against malevolent misuse. Driving things underground inhibits this, imposing opaqueness on the sector.

• Turning AI into a black market is completely foolish.

The post Response to “Pause Giant AI Experiments: An Open Letter” appeared first on Peter Rohde.

]]>The post New track – Naso del Liskamm appeared first on Peter Rohde.

]]>The post New track – Naso del Liskamm appeared first on Peter Rohde.

]]>The post New track — Zinalrothorn appeared first on Peter Rohde.

]]>The post New track — Zinalrothorn appeared first on Peter Rohde.

]]>The post MoodSnap now in Spanish appeared first on Peter Rohde.

]]>Thank you to Melany Nadine Monroy Icaza for providing the translation and Christian Ronald Cresci for proof-checking.

The post MoodSnap now in Spanish appeared first on Peter Rohde.

]]>The post Terminally Quantum podcast series appeared first on Peter Rohde.

]]>The post Terminally Quantum podcast series appeared first on Peter Rohde.

]]>The post MoodSnap jetzt in Deutsch appeared first on Peter Rohde.

]]>You can get MoodSnap on the Apple AppStore and find out more at the MoodSnap homepage.

The post MoodSnap jetzt in Deutsch appeared first on Peter Rohde.

]]>The post The Aardvark appeared first on Peter Rohde.

]]>The post The Aardvark appeared first on Peter Rohde.

]]>