Goal of this post is to describe Asynchronous Entanglement Routing for the Quantum Internet with focus on the results and open problems. The post will be structured in a following way – in the first section I will describe (on a high level) problem that is being addressed in the main article, in the second section we will go through foundational blocks and context required to understand the paper, in third section I will describe main contribution from the paper, fourth section will contain details about simulation setup and results, fifth section will contain open problems as described in the paper.

Why this particular structure?

I believe this approach facilitate better understand - both for reader and for me as a writer of this notes. Having clear picture of what particular problem authors are trying to solve is critical to understanding the solution and somewhat appreciate it. Then, before diving into main contribution (which is a solution to a stated problem), we need to ensure that we are standing on solid foundation. Usually parts like ‘‘Section II’’ are bit boring, yet they are helpful to fully grasp solution described in ‘‘Section III’’.

Section I: Problem definition

Given set of ‘‘quantum devices’’ (capable of entanglement generation and swapping) connected via network capable of qubit transmission – how we can efficiently create entanglement between any two devices in the network?

Context

In the article it is Section 3. ‘‘Quantum network’’ is a network – mathematically represented by a graph – which leverages some quantum specific properties, in this case entanglement. Graph $G(V, E)$ consists of a set of vertices $V$ (nodes, ‘‘quantum devices’’) and a set of edges $E$ (fibers, connection between nodes). Entanglement gives us possibility to create also virtual edges between particular vertices. Let us focus on that - what is a virtual edge? We will consider simple graph consisting of three nodes - $A, B, C$. The solid lines represents physical link between two devices.

graph LR;
    A---B;
    B---C;

Now, each node represents quantum device. Each device can communicate qubits to its neighbour (so another node that is directly connected). Such pair of nodes can create entanglement between their states. In our graph we (in theory) entangle states of $A, B$ and $B, C$. We will represent entanglement between nodes with dotted line.

graph LR;
    A---B;
    B---C;
    A-.-B;
    B-.-C;

By using technique called entanglement swapping we can “sacrifice” entanglements between $A, B$ and $B, C$ to create entanglement between $A, C$!

graph LR;
    A---B;
    B---C;
    A-.-C;

What’s the benefit? Now pair $A, C$ is entangled and they can leverage ‘‘quantum effects’’ - for example in quantum key distribution. Of course as networks grow larger, keeping in mind intermittent and delicate nature of entanglement between nodes, the question of how to create entanglement between any two particular nodes in a network gets harder and harder. Hence, we get our original problem statement.

Section II: Prerequisites and problem statement refinement

Before we can fully jump into contribution of the paper we need to understand what building blocks are leveraged in proposed approach. First we will describe processes or ‘‘functions’’, then we will describe components that leverage these.

Entanglement generation between adjacent nodes

Most basic capability is to entangle qubits between two adjacent nodes in a network. Simplest way would be to generate EPR pair between in node $A$ and then send one of the entangled qubits to connected (via physical link) node $B$.

Entanglement swapping

With the information above we can generate entanglement between physically connected nodes, but what about situation where we have intermediary node?

graph LR;
  subgraph PRE[from this]
     A-.-B
     A---B
     B-.-C
     B---C
   end
   subgraph POST[to this]
     D[A]---E[B]
     E---F[C]
     D-.-F
   end

PRE --> POST

There is existing technique called entanglement swapping, which allows us to do exactly that. In linked example there is a algorithmic description of the process, whereas in the paper you can find circuit-level realisation.

Fidelity

Fidelity between two quantum states can be intuited as “similarity” between those two states. Higher fidelity between two states means that two states are more similar to each other. In case of pure states fidelity can be thought as angle between two vector states.

Entanglement purification

This is a procedure that takes a number of partially entangled states and produces a smaller number (not rarely - just one) state with higher measure of entanglement.

Global and local (node-level) knowledge of direct links

First - what is a direct link? Given two nodes in the network, “direct link” is an edge realised by entanglement between those two nodes. The “global knowledge” is information about states of all direct links between all nodes in the network. It completely describes entanglement between all nodes. In a perfect (yet somewhat imaginary) world every node would have access to that global knowledge, but in a distributed scenario - the state information in any node might be outdated hence it has a “local knowledge”. If you are coming from CS perspective - this simply means eventual consistency

Link capacity

This is a number representing how many entangled qubit pairs can be generated between two nodes. If we would have ‘‘prefect’’ technology it would simply be equal to number of pairs between two nodes, but physical realisation within current state of the art implies that – if we want to achieve specific fidelity with EPR pair – we might need multiple entangled pairs and leverage purification techniques.

Synchronous and asynchronous

Title of the article contains “asynchronous”, hence it would be good to explain what does it mean. From a programmer perspective (or thread perspective) synchronous means that you wait for task to finish before working on next task. When you execute some task asynchronously - you can delegate the work to another ‘‘thread’’ (or other entity of similar type) and work on something else between you get the result back.

Overall, this is a very deep ocean, especially in world of algorithm analysis – so let us try to narrow down what it does mean in context of the paper. It simply means that nodes in the network can perform operations (for example - creating entanglement) simultaneously, without any “global” coordination.

On the page 3, authors mention that existing (synchronous) approaches are generally divided in two phases – external and internal. During the “external” phase, adjacent nodes establish entanglement between each other. During the “internal” phase – nodes are only aware of entanglement status of their neighbours – (quoting from article) “each repeater node swaps entanglement blindly to reach an end-to-end entanglement” between source and target nodes. If the source-target connection is not achieved, process is repeated. The “synchronous” aspect comes from the fact that internal phase needs all entanglement links built in external phase. Moreover, all entanglements are consumed in each time slot. Time slot consists of external + internal phase.

Entanglement rate

This value represents how much entanglement can be generated in a unit of time. Paraphrasing from paper: It is the performance metric indicating the number of end-to-end entanglements (Bell states) that can be generated in a unit time $T$.

Refined problem statement

This section will contain more mathematically precise statement of the problem. It is heavily based on Section 3 of the paper.

Let graph $G(V, E)$ represent topology of a quantum network. Each node $v \in V$ represents a quantum repeater (capable of entanglement generation and swapping), while each edge $e \in E$ represents physical (e.g. fiber optic) node that connects two repeaters. Let $G’(V’, E’)$ be a graph, where $V’ \subseteq V$. $G’$ represents quantum repeaters that are connected with each other via direct entanglement. Hence $e’ \in E’$ represents entanglement connection (in the paper this is called ‘‘direct-link entanglement’’).

Each edge $e \in E$ has associated value $C(e)$ which represents capacity of the link. Capacity is defined as maximum number of entangled pairs that can be generated between nodes connected by $e$. Moreover, each vertex $v \in V’$ also has capacity - $C(v)$, which is defined simply as number of qubits in that particular vertex (remember - vertex is simply a quantum repeater). $C(v)$ is defined as at least equal to sum of capacities of edges that connect $v$ with its neighbours $N(v)$. $C(v) \geq \sum_{e \in N(v)}C(e)$. This will allow us to simplify analysis, because there is no “competition” for qubits between links.

As mentioned before due to limitations of our technology to achieve desired fidelity $f$ (with EPR pair), we need $E(f)$ entanglement pairs to obtain it (via purification). We also define $T_{co}$, which is an average coherence time. It can be understood as how long we can actually maintain entanglement. After that time (on average) we will loose entanglement between two nodes.

In the paper - to simplify the analysis - each link capacity $C(e)$ and $E(f)$ are equal to $1$.

For each entanglement generation that happens between nodes connected via edge $e$ there is probability $p(e)$ that generation will succeed. At each node $v$ there is probability of entanglement swapping succeeding denoted as $q(v)$. To simplify things authors of the paper denote equal $p(e)$ for all edges $e$ – denoted simply as $p$. Analogously, $q$ represents success probability for entanglement swapping for all $v$.

Entanglement rate $\zeta$ represents number of Bell states that can be generated in unit time $T \leq T_{co}$. This last inequality makes sense, because it allow us to narrow down time window to only consider generation of entanglements that all can “live” at the same time.

Moreover, additional (but important) constraint that authors put on themselves is that nodes only posses local knowledge about adjacent entanglement links.

So the refined problem statement would be - given all of the above and assuming asynchronicity - how to design an algorithm that maximizes entanglement rate $\zeta$.

Section III: Main contributions

Before we dive into particular contributions, let us go through various ideas, tools and constructs used by authors to better understand main results

Connected-oriented circuit switching vs connection-less packet switching

I think one of the sentences gives good insight into inspiration for the approach taken by the authors (Section 3, page 8):

characteristic of entanglement resembles connection-oriented circuit switching rather than the connection-less packet switching used in classical networking.

Given that this is important let’s understand what is connection-oriented circuit switching and connection-less packet switching.

First the latter one.

In connection-less packet switching data is divided into packets and each such packet is treated independent unit. There is no pre-established path for data transmission for every packet. Packets may take different routes to reach the destination, and they might arrive out of order. The network nodes make routing decisions based on the current network conditions.

In connection-oriented circuit switching a dedicated communication path (known as circuit) is established between two parties before any data transfer occurs. The path remains reserved for the duration of the connection.

The entanglement cannot be split into parts, we need to reserve particular path to entangle nodes connected by that path. That’s why the connected oriented approach seems like a more natural fit.

DODAG

DODAG is an acronym that stands for destination oriented directed acyclic graph. The DAG part is usually well-known, especially in computer science world. The core property of DAG is having directed edges which form a path without cycles. So going on any path on that graph will not bring you to place you’ve been before.

DODAG is a specific type of DAG that is leveraged in lossy networks (think of dynamic IoT scenario). The additional property to designate one of the vertices as a root node that will have no outgoing edges. All other nodes in the graph can be reached from the root by following the directed edges.

Spanning tree

Spanning tree will also be leveraged within the paper. Given graph $G(V, E)$ its spanning tree is another graph that contains the same set of vertices $V$, but it contains minimum possible number of edges to retain same connections as original graph have (connection here means being able to go from vertex $a$ to vertex $b$)

Distributed graph

Distributed graph is a type of graph where each vertex/node is a computing unit – in our case it is a quantum repeater.

Instant topology

Instant topology refers to a topology of a graph that is built from quantum repeater (nodes) that are connected via entanglement (edges)

Getting to the point

With that long preface and all concepts, we can finally get to describing the key results of the paper. Whew!

Key idea

This is based heavily on section 4 of the article.

I think that good mental model for the asynchronous routing scheme is a service (from software perspective). It is constantly “on” and reacts to particular queries (simplest example is some form of simple http server).

This “routing service” is built from two main components: distributed graph and path determinator.

First component – the “distributed graph” – is responsible for building and maintaining instant topology as a distributed graph. Second component is more of a server which respond to actual requests. If you are software engineering savvy, this routing scheme have traits of a reactive system.

Given my personal software engineering context, I’ll try to represent the scheme in a pseudocode.An instance of class below would run on every node/vertex/quantum repeater in the network.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class AsynchronousRouterNode:
    distributed_graph_component # responsible for building and maintaining instant topology 
    current_node = self

    # On instance startup
    def startup():
        distributed_graph_component.join(current_node)

    # This function would be called as a classical operation with "classical bits"
    def navigate(previous_node, destination_node):
        maybe_next_node = distributed_graph_component.next_hop_determination(current_node, destination_node)
        if maybe_next_node is None:
            # a naive retry - try to join this node to distributed graph and retry the request
            distributed_graph_component.join(current_node)
            navigate(previous_node, destination_node)
        else:
            next_node = maybe_next_node
            es_success = entanglement_swap(previous_node, next_node)
            if not es_success: # if entanglement swapping failed
                # once again - a naive retry.
                distributed_graph_component.join(current_node)
                navigate(previous_node, destination_node)
            else:
                emit_connection_request_to(next_node, destination_node, current_node)

This relatively short pseudocode gives good overview and shows that even if we get complicated behavior (asynchronous entanglement swapping) behaviour of an individual node is simple:

1. On startup connect to the distributed_graph_component
2. On request – try to swap entanglement between previous node and next node. Here the important part is that distributed_graph_component maintains information about instant topology (where edges represents entanglement between nodes). If something fails - try to rejoin the graph and retry the request.

We can see an unsafe infinite loop here (infinite retry), but this is of course just a pseudocode, so I can live with that.

The important questions that arises - how we can realise the distributed_graph_component. From perspective of individual node this is completely opaque, but of course - we are interested in performance on an actual solution. Authors propose two “protocols” that implements the component – DODAG and Spanning Tree. I believe it is worthwhile to understand both approaches (at least on a high level). On the other hand there is possibility to implement other protocols as we develop the science behind it. For detailed explanation please refer to the paper - esp. section 4.

To give even more intuition on “how this works” let me quote from the conclusion section: “We treat all network nodes as vertices in a graph that try to connect their neighbours using direct-link entanglements. No central control and no global knowledge of the direct-link entanglements are needed in our method. Whenever a pair of nodes wants to create an end-to-end entanglement, they go through the distributed graph that is continuously updated to find each other”

Section IV: Simulation setup and results

Now to the results. Authors provided interesting model, especially the fact that it moves towards asynchronicity – which seems like a more natural fit for a network. The question remains if it is better than the synchronous approach.

Experiment setup

Authors utilise entanglement rate (as defined above) $\zeta$ as a performance metric. They run the experiment on a 2D grid topology. Each node is connected to 4 other nodes (neighbours), with exception of edge nodes (those are connected to 3 neighbours) and ‘‘corners’’ (those are connected to 2 neighbors). Each node is only aware of the neighbours’ statuses of entanglement (direct links in an instant topology) and has no awareness about anything “larger” than that.

Authors use NetworkX python library to conduct the simulation. Simulation happens (as mentioned above) in a 2D grid network. It is not clearly stated in the paper what is the size of the grid, but from the description of the Figure 10, we might think that it is around $26 \times 26$.

Synchronous protocol

Authors compare results to “synchronous” protocol. Authors do not describe precisely what protocol they are comparing against, so I assume that they leverage what they described in section 5.1. For us the main interest would be entanglement rate in synchronous protocol:

Let us unpack:

• $s$ means source node
• $t$ is target node
• $p$ is probability of success of entanglement between adjacent nodes
• $q$ is probability of success of entanglement swap
• $l_{s,t}$ is the mean length of all possible paths between nodes $s$ and $t$
• $n_{s,t}$ average number of disjoint paths between $s$ and $t$ as $n_{s,t}$

On $T_{co}$

To fully grasp simulation results, how coherence time – $T_{co}$ – is leveraged. $T_{co}$ represents coherence time or “how long entanglement is alive and usable”. Entanglement rate means that we are talking about how much entanglement we can generate per unit time $T$. For simulations (and analysis) to be meaningful we must assume that $T \leq T_{co}$ – otherwise we would not have available entanglement after single time unit. Authors decided to represent $T_{co}$ as $n$ unit times, so $T_{co} = 3$ represents coherence time of 3 unit times. Unit time is equivalent to ‘‘one time slot in synchronous operation’’, but it is not clearly defined what it means. Entanglement rate for synchronous protocol is independent of $T_{co}$.

Results

Graphs are taken from Asynchronous Entanglement Routing for the Quantum Internet

Rate vs Distance (single-path)

Single-path means that we search only for one path between source and destination nodes.

First thing to notice is that for $T_{co} = 1$ synchronous approach beats asynchronous one. It makes sense, as there is an “additional baggage” for async communication – which does not exist in synchronous approach. But, with $T_{co} = 2$ asynchronous protocols are beating synchronous approach.

Rate vs Entanglement Generation success

Here we can see similar results – async approaches are better when coherence time increases, interesting question is that if we $p$ and $q$ approach $1$ - would we observe any difference? Graph on the left shows that with high values of $p$ and $q = 0.8$ we see almost no difference.

Rate vs Distance (multi-path)

Multi-path means that we search for disjoint paths between source and target nodes. Once again the async approaches beat synchronous approach (but not that much).

Section V: Open problems, future work and potential directions

Network of networks

Authors claim that DODAG roots can serve as gateways to connect multiple networks (constructing network of networks). Leveraging DODAG for async routing (as presented in this article) of network of networks is a direction for future exploration.

Root position

Authors took center of the network as DODAG’s root, but taking different nodes as roots and impact of that decision on entanglement rate warrants further investigation.

Networking properties

Aspects like using (quoting/paraphrasing) “untrusted repeaters, minimal trust between network, malicious nodes, order of entanglement swapping along a path”

Network shapes

Performance of routing schemes in networks with shape other than grid.

Personal propositions

• Are there different structures other than DODAG?
• What results for $T_{co} \in (1, 2)$?
• More granular comparisons with different synchronous algorithms
• (far-fetched) can we learn something from blockchain related research?

Below are my notes on the proof of Lemma 4.1 from the paper Computational Quantum Entanglement. My approach is to take the proof apart and try to understand each step. I will try to explain the concepts in a way that is understandable for me. Each part will be taken as a $\textit{claim}$ and I will try to convince myself why it is true.

Here I will focus only on proving bounds on part regarding (computational) entanglement distillation.

What are we trying to prove?

For any small enough $\varepsilon > 0$ and non-decreasing $n(\lambda)$ such that $n(\lambda) \rightarrow \infty$ as $\lambda \rightarrow \infty$, there exists a family $\{\rho_{\lambda}^{AB}\}$ of bipartite pure states on $2n(\lambda)$ qubits such that for all $\lambda$, $E_{D}^{0}(\rho_{\lambda}^{AB}) = E(\rho_{\lambda}^{A}) = n(\lambda)$, but for any valid lower bound $m$ on $\hat{E_{D}}^{0}(\rho_{\lambda})$, we have that $m \leq_{\infty} 0$.

What does it mean?

There exist a family of states $\{\rho_{\lambda}^{AB}\}$ that has high (namely $n(\lambda)$) distillable entanglement , but small (namely 0) computational distillable entanglement.

Intuitive proof overview

To distill entanglement we need to create at least single EPR pair. The idea is to create a family of pure states (of which uniform mixture is the totally mixed state) that is way more numerous than number of efficient LOCC maps from those states to one EPR pair. If the family has so many states that almost all (at least half of them) of them would be distilled by one (family parametrized by $\lambda$ of) LOCC map. Assume that this efficient (critical part of assumption) LOCC map actually exist. Then, this particular LOCC map by being linear should also distill with non-zero fidelity from uniform mixture of the family - from this we have non-zero distillable entanglement. But we know that totally mixed state has entanglement entropy (via entanglement of formation) equal to 0. Entanglement entropy is an upper bound for distillable entanglement, hence we arrive at contradiction.

What is the post:

• Claims 1, 2 describe why we can even think about constructing such family of states
• Claim 3 shows that this family of state might be very populated.
• Claims 4, 4.1, 4.2, 4.3, 4.4 show properties of such family of states.
• Claims 5.1, 5.2 are the “actual” proofs.

Claim 1: For $n$-qubits unitaries $U$ and $V$, and $\lvert \phi^n \rangle$ the tensor product of $n$ EPR pairs, the states $(I \otimes U)\lvert \phi^n \rangle$ and $(I \otimes V)\lvert \phi^n \rangle$ are both maximally entangled.

If you are into quantum computing already, this is true because $\lvert \phi^n \rangle$ is maximally entangled (by definition of EPR pair) and we cannot “change” entanglement by using local operations – and those what $(I \otimes V)$ are. We apply each same unitary to each EPR pair.

I personally prefer more mathematical oriented proofs.

To show that state $(I \otimes U)\lvert \phi^n \rangle$ is maximally entangled, we need to show that reduced density operator for subysystem will not change.

First, let us consider an EPR pair - $\frac{1}{\sqrt{2}}(\lvert 00 \rangle + \lvert 11 \rangle)$. What is important to recall that this is just a shorthand for writing $\frac{1}{\sqrt{2}}(\lvert 0\rangle_{A} \otimes \lvert 0 \rangle_{B} + \lvert 1 \rangle_{A} \otimes \lvert 1 \rangle_{B})$. Next, $\lvert \phi^n \rangle$ is actually $\bigotimes_{1}^{n} \lvert \phi \rangle$. Last property that we need to leverage here is called mixed-product property and it applies to tensor (kronecker product): $(A \otimes B)(C \otimes D) = AC \otimes BD$ (if dimensions “agree”).

Before we go further let’s recall dimensions of used entities. $\lvert \phi \rangle$ has dimensions of $4 = 2^2 \times 1$, so $\lvert \phi^n \rangle$ will have dimension of $2^{2n} \times 1$. $U$ (and $V$) is an $n$-qubit unitary, so it will be $2^n \times 2^n$. So for statement $(I \otimes U)\lvert \phi^n \rangle$ to make sense $I$ needs also be a $2^n \times 2^n$ matrix.

Let us combine all of that and end up with (over)simplified statement

$\sum(\lvert \alpha \rangle_A \otimes \lvert \beta \rangle_B)$ – this represents a sum of all combinations that we will get from tensor-multiplying. What is important that both (or maybe each) $\lvert \alpha \rangle_A$ and $\lvert \beta \rangle_B$ describe $n$-qubit system. This is why - by mixed product property we can write:

That of course shows that subystem A is not affected by (I \otimes U), hence maximum entangled is retained. Of coruse exactly same reasoning can be used for $V$.

Claim 2: States $(I \otimes U)\lvert \phi^n \rangle$ and $(I \otimes V)\lvert \phi^n \rangle$ have fidelity $1- \frac{1}{2}\frac{1}{2^n}\lVert U - V \rVert^2_F$

To be more precise, we need to show that:

First, let us note that both $(I \otimes U)\lvert \phi^n \rangle$ and $(I \otimes V)\lvert \phi^n \rangle$ are pure states – we already described them as a single ket vector in proof of previous claim (it was a sum, but that is still a single ket vector).

Trying to directly attack the issue via the definition of fidelity brought me nowhere, but you might now that fidelity and trace distance as related. Fortunately, we have the following relationship (source):

Okay, so that means that we want to show that:

Where $\rho$, $\sigma$ are density matrices of pure states. Intuitively, it does make sense. We take same pure state, apply two different unitaries to the same state, hence it should be a function of distance between those two unitaries. Now let us define trace distance $T$

Now of course – how we can prove that equality? I spent half a day with my limited mathematical skills and fell short, but fortunately I found this paper, from which equation 5 fell from the sky on my laps. For those sweet, sweet pure states we have:

And that is something we can work with. First, let us simplify lefthand side:

Now let’s move to $\text{Tr}(\rho\sigma)$.

Now that is interesting, because both $\langle \phi^n \rvert(I \otimes V^H U)\lvert \phi^n \rangle$ and $\langle \phi^n \rvert (I \otimes U^HV)\lvert \phi^n \rangle$ are scalars, so we can drop the trace! But what is even more interesting is how we can leverage Exercise 9.16 from Nielsen and Chuang (be sure to check errata), Let $\lvert i \rangle, \lvert j \rangle$ be orthonormal basis set, now define $\lvert m \rangle = \sum_{i}\lvert i \rangle, \lvert j \rangle$, we get:

Now, let us recall that we can write $\lvert \phi^n \rangle = \frac{1}{\sqrt{2}}^n \lvert \tilde{\phi} \rangle$, where $\lvert \tilde{\phi} \rangle$ meets the requirement above! Back to our trace calculations:

Now let us recall that by original claim we are interested in only the real part, so we obtain:

Okay, now let us try to simplify $\frac{1}{2^n}\lVert U - V \rVert^2_F$

Now, let us try to simplify to convince ourselves about the claim.

Switch gears to trace distance:

Which is exactly where we want to be based on trance distance-fidelity relationship. Reasoning can be simplified, but I want to leave a bit of personal touch to show how I was wondering (and wandering!) around.

Claim 3: $\eta$-net on a $n(\lambda)$-qubit unitaries for normalized Frobenius norm has size $(\frac{1}{\eta})^{\Omega(2^{2n(\lambda)})}$

Another rich statement. First we need to understand what $\eta$-net is. In literature the standard name is $\epsilon$-net. Formal definition is available (for example) here at page 12, section 47.4. I’d like to focus on intuition that helped me grasp the idea. I will be using $\eta$-net to remain in the context of the paper. Let say we have metric space $(M, d)$. We have points and well-defined distance between those points. Now let us pick some subset $X \subseteq M$ and a parameter $\eta$ in a specific way – all the points of $M$ should be no further than $\eta$ distance from one of the points in $X$, that set X will be $\eta$-net. Not that complicated right?

Now let us think a little about size of an $\eta$-net. The smaller the $\eta$ the more elements needs to be in set. If we set a $\eta = 0$, we need whole $M$ set as a “$0$-net”. On the other extreme if we consider a “$\infty$-net” than any single point would suffice. To make it more manageable, we can normalize our metric space, so we only need to operate on values between $0$ and $1$. That means that no two points are further from each other than of $d=1$. So if we set $\eta=\frac{1}{2}$, then we need at least 2 points to cover whole set. We may need more, but we are guaranteed that that is minimum in that toy example. And that brings us closely to claim we need. Now with some geometric intuition the claim becomes relatively simple – think about a circle than you need to fill in with smaller circles to ensure all points are within radius of smaller circles. I will finish at that.

Claim 4: Construction and properties of $S_\lambda$

Within this section we will deal with all the properties and construction of $S_\lambda$. Here, we will just extract a list of what we need to show. Quick recap of how $S_\lambda$ is constructed. We start with $S_\lambda = \emptyset$, then:

1. Let take a $U$ $n$-qubit unitary and construct $\lvert \psi \rangle = (I \otimes U)\lvert \phi^n \rangle$. If $\lvert \psi \rangle$ has fidelity less than $1 - \eta$ with every state already in $S_\lambda$, then add $\lvert \psi \rangle$ to the set, otherwise stop.
2. Add $2^{2n}$ (?) pure states {$ (I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle : a, b \in {0, 1}^n$} to the set $S_\lambda$. My understanding here is that for $a, b = 0$ we are adding the original state again, so we are actually adding $2^{2n} - 1$ new states, but we end up with $2^{2n}$, because it was added in step 1.

Now for the properties:

1. Any pair of elements from $S_\lambda$ has fidelity at most $1 - \eta$.
2. $S_\lambda$ has at least $\frac{1}{\eta}^{\Omega(2^{2n(\lambda)})}$ elements
3. Uniform mixture over all $\lvert \psi \rangle \in S_\lambda$ is the totally mixed state.
4. For any $\lvert \psi \rangle \in S_\lambda, E(\lvert \psi \rangle \langle \psi \lvert) = n(\lambda)$

For me to feel comfortable, we need to split first property into few smaller ones:

• $(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle$ and $\lvert \psi \rangle$ has fidelity at most $1 - \eta$
• Let $\lvert \psi_1 \rangle$, $\lvert \psi_2 \rangle \in S_\lambda$. $(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi_1 \rangle$ and $\lvert \psi_2 \rangle$ has fidelity at most $1 - \eta$

Additionally, we need to be sure that $(I \otimes \sigma_X(a)\sigma_Z(b))$ are actually pure states.

Claim 4.1: $\{(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle : a, b \in \{0, 1\}^n\}$ are all pure states.

All maximally entangled states are pure. In Claim 1 we showed that applying operations in form $I \otimes A$ does not affect status of being maximally entangled. Because of that, $\{(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle : a, b \in \{0, 1\}^n\}$ will remain maximally entangled, hence all $\{(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle : a, b \in \{0, 1\}^n\}$ are pure.

Claim 4.2: $(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi \rangle$ and $\lvert \psi \rangle$ has fidelity at most $1 - \eta$

Ah, fidelity again! So let us write everything we know, starting with states:

Okay, as we have fidelity formula for pure states

Of course we are not in case when $a = b = 0$ – we would be measuring fidelity between particular state and itself. What we need here is following fact: $\sigma_X(a), \sigma_Z(b), \sigma_X(a)\sigma_Z(b)$ all have trace equal to $0$, hence the fidelity is 0, which is less that $1 - \eta$.

Claim 4.3: Let $\lvert \psi_1 \rangle, \lvert \psi_2 \rangle \in S_\lambda$. $(I \otimes \sigma_X(a)\sigma_Z(b)) \lvert \psi_1 \rangle$ and $(I \otimes \sigma_X(c)\sigma_Z(d)) \lvert \psi_2 \rangle$ has fidelity at most $1 - \eta$

Now, we want to check if added orthogonal states coming from two different unitaries will still be far apart from each other. For me, it is not obvious that the fidelity will be “preserved” (or at least not increased). Good that those are all pure states, we also now that fidelity between $\lvert \psi_1 \rangle, \lvert \psi_2 \rangle$ is at most $1 - \eta$. We can write that down in a following way:

That’s what we know. With some easy simplifications we are interested in showing that:

Let us first consider the case $n = 1, a = b = 1, c = d = 0$, we end up with:

Now - simplifying, but wlog - let us recall that if we have unitary $U$ already in set $S_\lambda$, then we also have: $\sigma_XU, \sigma_ZU, \sigma_X\sigma_ZU$. That means that $V$ must have desired fidelity with all of those matrices, by conjugate transpose we have the “simplified” equation above for any quantum one time padding of $V$.

Here operations will “cancel out”:

Claim 4.4: For any $\lvert \psi \rangle \in S_\lambda, E(\lvert \psi \rangle \langle \psi \lvert) = n(\lambda)$

First, we need to help oursevles with definition of $E$. $E$ means entanglement entropy. In the Paper of Interest it lies under Definition 2.7. And it is defined as:

where $H(A)_\rho$ denotes the von Neumann entropy of the reduced density matrix $\rho_A$. For the case of a pure state $H(A) = H(B)$. Then of course we need von Neumann entropy. Fortunately, we are constantly in the realm of pure states, and we can leverage fact describe below (source).

That means that we can “trace out” system B. System B is only one that is being modified, hence we are still in realm of maximal entropy.

Claim 4.5: Uniform mixture over all states in $S_\lambda$ is the maximally mixed state.

This comes directly from quantum one time pad. For more practical information please see this notes

Claim 4.6: Uniform mixture over all $\lvert \psi \rangle \in S_\lambda$ is the totally mixed state.

By construction of $S_\lambda$ we are effectively building an $\eta$-net. For a geometric intuition think about a unit circle. Then put a first unit vector (it should lie on a radius). Recall that inner product between any vector can be intuited as angle between those two vectors. Then for a particular angle – $\alpha$ – (fidelity) how many vectors you can “pack” into that circle so that every pair of vectors have at least $\alpha$ angle between them. Then try to imagine how it would work in a sphere.

“Claim” 5.1: $s$ grows faster than any polynomial $\rightarrow$ lemma is proven for distillable entanglement

Now we get to the first, easier case of lemma. Just let us be clear on what we want to show – there exists family of bipartite pure states of $2n(\lambda)$ qubits that distillable entanglement equal to $n(\lambda)$, but it has computational quantum entanglement bounded by 0.

So, what is $s$? $s$ is defined as a function that for each state returns the smallest size of an LOCC map that distills one EPR pair from particular state. Moreover, if we pass “size parameter” $\lambda$ it will return maximal size for particular family of states. It is defined on $S_\lambda$ from Claim 4.

With this claim we assume that $s$ grows faster than any polynomial – so the size of LOCC grows faster than any polynomial – for $S_\lambda$. That obviously means that $S_\lambda$ is the family for which at least one EPR by means of polynomially bounded LOCC, hence computational distillable entanglement is $0$. By Claim 4.4 the (non-computational) distillable entanglement is $n(\lambda)$. We are where we wanted!

“Claim” 5.2: $s$ is polynomially bounded than any polynomial $\rightarrow$ lemma is proven for distillable entanglement

Now for the harder case.

First statement that we need to deal with is – The number of LOCC maps from $2n(\lambda)$ to 2 qubits of size at most $s(\lambda)$ is at most $2^{\text{poly}(s(\lambda))}$. Why? Because any such map can be described using a number of bits that is polynomially bounded. Why?

First, recall that $s$ that represented size of LOCC maps is polynomially bounded. Size of LOCC map means how many gates we need to realise that map. So if we take the “biggest” map (or rather the fastest growing), we can create a (non bit, but $n$-ary, where $n$ is number of gates we have at disposal) string that for each position will tell us which gate has been used. As the number of gates is fixed (even if we consider applying gates to different qubits, it will always be fixed) we can translate each position to a binary string, then with concatenating we have a string of size at most $2^{\text{poly}(s(\lambda))}$.

Now, we can take our $S_\lambda$ that has $(\frac{1}{\eta})^{\Omega(2^{2n(\lambda)})}$ states. Important observation is that there are more states than there are LOCC maps. As we can see, number of LOCC grows exponentially already, but in case of states it is the exponent that grows exponentially – we omit degraded cases in general where fidelity $< \frac{1}{2}$.

By pigeonhole principle that means that – if we grow $\lambda$ to big enough values – that there will be polynomial LOCC mapp that distills “almost all” states in $S_\lambda$ with fidelity at least $1 - \epsilon$ (not $\eta$!) with one EPR pair.

Then we have following:

Now let $\rho^\lambda$ be the uniform mixture over all $\psi \in S_\lambda$. Then provided $\eta$ is small enough with respect to $\epsilon$ it still follows that $\hat{\Gamma}^\lambda(\rho^\lambda)$ has fidelity at least $1 - 2\epsilon$ with one EPR pair

And this is something that we need to explain. When we decrease $\eta$ we increase number of states as well as “locally” states are more similar to each other. If we increase $\epsilon$ we are okay with map $$\hat{\Gamma}^\lambda$ to provide states “further” away from single EPR pair.

This part remains a bit of mystery to me. I know that fidelity is concave, which we can leverage. We also know that LOCC are linear mappings (as all quantum operations are)

First, let us split $\rho^\lambda$ into two parts: $\rho^\lambda_{\epsilon-}$ – uniform mixture of states that have fidelity at least $1 - \epsilon$ and $\rho^\lambda_{\epsilon+}$ – states that have fidelity less than $1 - \epsilon$. From “almost all” condition we know that $\rho^\lambda_{\epsilon-}$ would be a mixture of no less elements than $\rho^\lambda_{\epsilon+}$. So for lower bound we can assign weight $\frac{1}{2}$ to each of mixtures. Now, for the questionable element:

We know that $F(\hat{\Gamma}^\lambda(\rho^\lambda_{\epsilon-}) \geq 1 - \epsilon$. We can always assume $F(\hat{\Gamma}^\lambda(\rho^\lambda_{\epsilon+}) < 1 - \epsilon$. Finishing calculations we end up with $\frac{1}{2} - \epsilon$, which is different (but linearly similar) to what we have in paper and this is enough to finish the proof.

What is crucial is that for $\epsilon < \frac{1}{2}$, we have non-zero fidelity between uniform mixture and one EPR pair.

Know for the entanglement of totally mixed state. Von Neumann entropy can be leveraged as measurement of entanglement entropy, but only for pure states. For mixed states we can leverage entanglement of formation.

We have our totally mixed state $\frac{1}{d}I_d$. We can decompose it to a set of pure product states (think computational basis states), each of those has $0$ entanglement, so min-sum among those would still be 0.

Now, we arrived at contradiction (for small enough $\epsilon$), so $s$ cannot be polynomially bounded, so $S_\lambda$ is the family of states from the claim.

Product states

It seems that qubits are social beings, hence let’s consider a two-qubit state $\lvert ba \rangle$. During measurement this system can be in four states - $\lvert 00 \rangle$, $\lvert 01 \rangle$, $\lvert 10 \rangle$, $\lvert 11 \rangle$. Of course, each of those base states has an associated amplitude which is a product of its components’ amplitudes.

The same limitation is placed on amplitudes, meaning that the sum of their modulus squares needs to be equal to $1$

To close on this very brief introductory description, let us go through an example two-qubit state $\lvert -1 \rangle$ (that is read “ket minus 1”)

With amplitudes described above, we have a 0.5 probability of observing $\lvert 01 \rangle$ and a 0.5 probability of observing $\lvert 11 \rangle$.

Canceling out amplitudes

As you might recall the amplitudes are complex numbers. That means that the $-\frac{1}{\sqrt{2}}\lvert 11 \rangle$ is completely valid as for example $-\frac{i}{\sqrt{4}}\lvert 11 \rangle$ would be (although the rest of amplitudes would have to be different). That means that with an interesting enough chain of quantum logic gates, some amplitudes will cancel each other out! (Recall $i^2 + 1^2 = 0$).

Entangled states

Okay, we described multiple qubit states. You might scratch your head “Well, so what?”.

It turns out that we can have states that are not a product of individual qubit states! Consider the following state (read “ket phi plus”)

We can play a little with this state

Okay, so let us tackle this problem with basic equation-solving skills! If we look at equations 1 and 2, we can deduce that $\alpha_b \neq 0$, otherwise we could not satisfy equation 1. That implies that $\beta_a$ is $0$. Whew, that was close! But if we look at equation 4 now, we end in a ditch, because it cannot be satisfied with $beta_a = 0$. This short reasoning shows that we cannot represent the $\lvert \Phi^- \rangle$ state by simply combining states of two single qubits.

So how could we achieve that?

With the help of quantum logic gates, obviously! We know that we can achieve $\lvert -1 \rangle$ state. We are missing a gate that would have a $4 \times 4$ matrix that would map (for example ) $\lvert -1 \rangle$ to $\lvert \Phi^- \rangle$. That means solving $\lvert \Phi^- \rangle = M \cdot \lvert -1 \rangle$. Moreover, to meet the requirements of a quantum logic gate, we need to ensure that $M$ is unitary. With some tinkering, we can get to

To sum up, we started with two qubits in a product state pushed those qubits through a gate, and ended up in an entangled state that cannot be split into two qubits.

Why do we even need entangled states?

Okay, we described entangled qubit states. You might scratch your head “Well, so what?”.

Quantum algorithms you might read about leverage entanglement to propose solutions that are computationally faster than the fastest known “classical” algorithms. This is why we need to grasp the idea of the entangled state.

I do not know whether an entangled state is strictly necessary for a quantum algorithm to have a “quantum advantage”, but there are voices saying that it is necessary. On the other hand there are papers showing that there is a possible quantum advantage even without the entangled state. My opinion - as a layman - is anything realizable and practically useful will need entanglement along the way.

After reading What is quantum? I did not feel like I fully grasped the intuition behind the H-gate. In this post, I attempt to build such intuition on a high level (without diving too deep into the technical description). To do so, we will execute the following battle plan - we will describe bits, then qubits and amplitudes, then how amplitude relates to probability. Finally, we will tackle the boss-level concept of the H-gate.

I assume you are familiar (that does not mean being super proficient) with those concepts: basic Boolean logic, vectors, matrices, matrix multiplication, and complex numbers.

Bits

I really like the description of what bit is from Wiki:

The bit is the most basic unit of information […]. The bit represents a logical state with one of two possible values.

This short description works very well for me, especially after I took it apart. The highlights are basic unit of information, state with two possible values. If we think about what the minimal amount of information we can convey is that whether something is or is not. And that’s how I do interpret bits.

Please note that we did not describe how bits are physically realized. We described them as abstract objects. Bits can be realized in any physical thing that has two distinct states. For example with something as simple as a light switch with on and off positions. The core point is we do not really care about this, we just care about the properties of bits and what we can do with them as a perfect, mathematical object.

Of course bits, themselves are pretty boring. The action starts with logic gates! Logic gates are simply implementations of logical operations - think your ANDs, NOTs, ORs, and XORs.

NOT is probably the simplest gate - it takes a bit and returns the inverse of it. For 0 (is not) it returns 1 (is). AND takes two bits and checks, whether both of them are. For 1 and 1, it will return 1 and for every other input it would return 0.

Qubits and amplitude

First of all qubits are also (but not only) abstract, mathematical objects. What makes it easier for me to deal with them is to treat them as such - if I see a surprising qubit property, but can understand (or at least have intuition) about the math behind it - then I am all good. I tell myself that “surprising properties of qubits are just consequence of math” to avoid mind-bending quantum effects which are so distinct from our day-to-day experience.

Just like a bit, a qubit also has two states, but instead of representing a logical state, it represents a quantum state. Now let us take jump head first and try to swim. Quantum state $\lvert \psi \rangle$ of a qubit can be defined as:

Now let us take the equation above apart. First the $\lvert \text{something} \rangle$ notation - for our purposes it can just mean quantum state. If you want to dive deeper you should start reading up on Dirac notation. With that $\lvert 0 \rangle$ is analogous to a $0$ state of a classic bit and $\lvert 1 \rangle$ to a classic bit with state $1$. What is important to know is that the aforementioned quantum state can be represented as a vector:

Now let us tackle the $\alpha$ and $\beta$. As we can see above they describe how much state $\lvert \psi \rangle$ consists of $\lvert 0 \rangle$ and how much of $\lvert 1 \rangle$. Both $\alpha$ and $\beta$ are probability amplitudes. Probability amplitude is a complex number with the following property - square modulus of probability amplitude equals probability of a particular outcome (this is simplified, visit Wiki for more formal exposition).

Now we can interpret $\lvert \psi \rangle = \alpha \lvert 0 \rangle + \beta \lvert 1 \rangle$ as a state that has ${\lvert \alpha \rvert}^2$ probability of being $0$ and ${\lvert \beta \rvert}^2$ of being $1$! Remember that, when we will measure the state of a qubit we will see either $0$ or $1$, not some “in-between” state.

Quantum logic gates

With that, we can now attack quantum logic gates and H-gate. We know that quantum gates will take as an input a quantum state (at least one) and return another quantum state. If we define input and output quantum states as

then for a quantum logic gate to be expressive we would like to freely combine input values with the output ones, so we want

If you recall your linear algebra course that is exactly how matrix multiplication works! So we can use our gate in the following ways

For a single qubit gate, we have the gate matrix needs to be $2 \times 2$

The output state needs to conform to the ${\lvert \alpha \rvert}^2 + {\lvert \beta \rvert}^2 = 1$. This is achieved by using unitary matrices.

Let us now look at the gate that would inverse the quantum state - mapping $0$ to $1$ and $1$ to $0$.

This quantum logic gate is called an X-gate. It is analogous to a NOT gate.

H-gate

Finally, we can tackle the H-gate. Let us recall the properties of H-gate from the What is quantum? section in the qiskit textbook.

1. Starting $\lvert 0 \rangle$ and $\lvert 1 \rangle$ we ended up with $0.5$ probability of observing $0$ and $0.5$ probability observing $1$. The output state of applying H-gate to $\lvert \psi \rangle$ would have following form - $\lvert \psi_H \rangle = \sqrt{\frac{1}{2}} \lvert 0 \rangle \pm \sqrt{\frac{1}{2}}$ $\lvert 1 \rangle$. The $\pm$ comes from the fact that if we want to get 0.5 probability by squaring a modulus of a complex number, we can do it from both $+\sqrt{\frac{1}{2}}$ and $-\sqrt{\frac{1}{2}}$.
2. Applying H-gate twice takes us back to our initial state - $\lvert \psi_{HH} \rangle = \lvert \psi \rangle$

Those two properties bring us to the following H-gate matrix (you can do the math on your own, it is not that hard!)

Notes on amplitude as a vector

As amplitudes are complex numbers we can represent them using polar coordinates, with modulus becoming the length of vector formed between the origin point and any particular complex number. For me (on my current level of knowledge) thinking about amplitudes as vectors make things more “complete”. Then, for $\lvert 1 \rangle$ H-gate performs rotation of the amplitude vector (for the $\lvert 1 \rangle$ output).

Summary

We described what bit is, then we went a level higher to describe qubit. We focused on the qubit complicated state which allowed us to describe quantum logic gates and finally define H-gate. I hope that this will help build your intuition and progress through the qiskit learning course!

Polimorfizm jest jedną z podstawowych technik programowania w językach wysokiego poziomu. Jest bardzo popularny w językach obiektowych - i słusznie. Będąc wierny jedynej słusznej drodze (JSD), czyli programowaniu funkcyjnemu, sądzę, że polimorfizm o smaku ad-hoc pozwala pisać w sposób naturalny kod, który jest bardziej modularny oraz uniwersalny.

Czym jest typ, klasa, klasa typów?

Zacznijmy od rozplątanie pojęć, które bywają używane zamiennie w kontekście tematu typeclass. Na końcu tej części powinno być jasne, czym ów twór jest.

1. Zbiór - w kontekście matematycznym - chyba najtrudniejsze do zdefiniowiania pojęcie. Jest to fundamentalne pojęcie teorii mnogości(Mnogość to inaczej zbiór, więc to po prostu teoria zbiorów). Fundamentalne oznacza tu, że jest to pojęcie tak pierwotne, że jest częściowo przyjmowane na zasadzie - “czym jest zbiór, każdy widzi” (to oczywiście zależy od podejścia do teorii mnogości jakie przyjmiemy, ale to wykracza poza nasze potrzeby). Intuicyjne jest to pewna kolekcja arbitralnie wybranych przez nas elementów.
   Ważniejsze są cechy zbioru - dany element może należeć do zbioru lub też nie, ale nie może przynależeć do niego dwukrotnie. Zbiór jest jednoznacznie wyznaczony przez jego elementy. To tylko tyle i aż tyle.
2. Typ - w ujęciu programistycznym - znane nam dobrze Int, String, List[T], czy też stworzone przez nas class Animal, trait Money, object Earth. Jest to cecha danych, która mówi kompilatorowi w jaki sposób chcemy użyć danych i na jakie operacje powinien nam na nich pozwolić. Zwróćmy uwagę na analogię pomiędzy zbiorem a typem, posłużmy się do tego funkcją:

   1
   def isDivisableBy3(x: Int): Boolean = x % 3 == 0
   

   Funkcja ta sprawdza, czy przekazany Int jest podzielny przez 3. Informuje nas o to zwracając odpowiednią wartość true lub false. Spójrzmy na to jednak z małą matematyczną lupą. Zdefiniowaliśmy funkcję, która przypisuje elementom zbioru Int któryś z elementów zbioru Boolean. Tak więc wartości true, false należą do zbioru Boolean - stąd też ich typ. Analogicznie ze zbiorem Int, będącego skończonym podzbiorem liczb całkowitych.

3. Klasa - w ujęciu matematycznym - Pojęcie jest używane w matematyce, gdy mamy do czynienia z wielością (celowo nie zbiorem), który jest zbyt liczny i odrobinę zbyt zaskakujący, żeby go badać przy pomocy narzędzi teorii mnogości. Na nasze potrzeby wystarczy intuicja, mówiąca, że klasa to grupa obiektów, która jest określona przez pewną wspólną własność.
4. Klasa - w ujęciu programistycznym - liczę na to, że czytelnik jest zaznajomiony z tym pojęciem. Ewentualną dygresją, którą warto dodać, że jest to pewne narzędzie, które służy nam do modelowania domeny problemu.
5. Klasa typów - typeclass - Jest to połączenie konceptu klasy matematycznej z typem programistycznym. Więc mówiąc typeclass mamy na myśli pewną grupę typów, które mają jakąś wspólną własność. W praktyce przez wspólną własność zazwyczaj rozumiemy określoną na tych typach funkcję.

Przykładem, który weźmiemy sobię pod lupę jest serializacja danych do formatu JSON. Naszym bardzo (a nawet bardzo, bardzo - nie bieżcie go za wzór przy modelowaniu czegokolwiek) uproszczonym punktem początkowym będzie

1
2
3
4
5
6
7
case class Account(id: String, balance: BigDecimal) {
  def toJsonString: String = ??? // we do not care about implementation
}

case class Dog(name: String, breed: String, weight: Int) {
  def toJsonString: String = ??? // we do not care about implementation
}

Bez żadnego naciągactwa możemy powiedzieć, że chcielibyśmy wprowadzić pewną klasę typów, która pozwoli nam mówić o klasach, które możemy serializować do formatu JSON.

Seperacja zachowania od danych

Zanim jednak wypłyniemy na wzburzone morza typeclass o modularności. Jestem zwolennikiem seperacji zachowania danych od ich definicji. Programiści (w tym ja!) często - przypadkiem - doprowadzają często do splątania tych dwóch rzeczy, a to w efekcie zmniejsza modularność naszego kodu. Zmniejszenie modularności powoduje, że nasz kod jest ciężej używać w różnych, niezależnych od siebie miejscach, ciężej go testować i ogólnie zwiększa stopień “kaszanowatości” rozwiązania. Wyobraźmy sobie nie najlepiej zamodelowaną klasę:

1
2
3
4
5
6
7
case class Account(id: String, balance: BigDecimal) {
  def toJsonString: String = ??? // we do not care about implementation

  def closeAccount: ClosingResult = ??? 

  def buyDog(dog: Dog, money: BigDecimal): Dog = ???
}

Mamy do czynienia tutaj z pomieszaniem z poplątaniem. Moduł naszej aplikacji odpowiedzialny za zamykanie i autoryzacje kont teraz jest pośrednio zależny od buyDog - jeżeli zmienia się definicja tej funkcji, wszyscy użytkownicy tej klasy muszą zostać o tym poinformowani. W mojej ocenie co jest jeszcze gorsze dajemy możliwości kupowania psów modułowi autoryzacyjnemy oraz zamykania konta modułowi odpowiedzialnymi za sprzedaż piesków! Pozwól danym być danymi, nie zmuszaj ich do niewolniczej pracy.

Podejście to jest oczywiście efektem dobrych praktyk programistycznych (single responsibility principle, seperation of concerns i innych).

Co to nam mówi o “serializowalnym” Account i Dog? Nie powinniśmy plątać definicji serializacji i definicji danych.

Do rzeczy - jak ten typeclass wygląda w Scali?

Żeby zdefiniować klasę typów, które będą mogły być serializowane do JSON możemy zacząć od definicji trait:

1
2
3
trait JsonEncodable[A] {
   def toJsonString(a: A): String
}

A cóż to za parametr A? Naszą klasą typów jest JsonEncodable natomiast z punktu widzenia języka programowania będziemy musieli w jakiś sposób pokazać, że dany typ przynależy do klasy JsonEncodable - odbędzie się to przez implementację JsonEncodable:

1
2
3
4
5
6
object Account {
  implicit val enc: JsonEncodable[Account] = new JsonEncodable {
    override def toJsonString(account: Account): String = ??? // we do not care about implementation.
  }
}

Teraz żeby zserializować obiekt Account możemy napisać:

1
2
val account: Account = Account("id", 100)
val jsonString: String = Account.enc.toJsonString(account)

Możemy pozwolić sobie również tworzenie generycznych funkcji:

1
def genericToJsonString[A](a: A, ev: JsonEncodable[A]) = ev.toJsonString(a)

Po co to wszystko?

Pierwszą zaletą jest fakt odseperowania zachowania od definicji danych. Kolejną jest przekazanie części pracy kompilatorowi, funkcja genericToJsonString[A] wymaga zaimplementowanego ev: JsonEncodable[A] (ev jest skrótem od evidence).
Drugą jest możliwość deklarowania różnych implementacji dla kompletnie różnych typów, które same w sobie nie muszą być ze sobą w żaden sposób związane (musi istnieć odpowiednia implementacja JsonEncodable dla typu A) - nazywamy to ad-hoc polymorphism. Zwróć uwagę na fakt, że w żaden sposób nie narzuciliśmy ograniczeń na typ A. Trzecią zaletą możliwość rozszerzanie funkcjonalności typów bez dostępu do ich kodu źrodłowego (JsonEncodable[Account] możemy zaimplementować bez dostępu do kodu źrodłowego Account).

No strasznie to brzydkie

Faktycznie zapis def genericToJsonString[A](a: A, ev: JsonEncodable[A]) = ev.toJsonString(a) wygląda dość ociężale. Scala jednak pozwala na kilka uproszczeń.

1
def genericToJsonString[A](a: A)(implicit ev: JsonEncodable[A]) = ev.toJsonString(a)

Wtedy serializacja typu Account będzie uproszczona - tak długo jak w zasięgu kompilatora będzie implicit val enc: JsonEncodable[A]. Obecnie zdeklarowaliśmy go w companion object Account, więc zawsze gdy zaimportujemy Account pojawi się nasz encoder, co pozwoli nam napisać:

1
2
val account: Account = Account("id", 100)
val jsonString: String = genericToJsonString(account)

Kolejnym uproszczeniem jest następujący zapis:

1
def genericToJsonString[A: JsonEncodable](a: A) = JsonEncodable[A].toJsonString(a)

Żeby jednak kompilator był zadowolony (zadowolony kompilator to sprawa istotna) musimy stworzyć companion object do JsonEncodable:

1
2
3
object JsonEncodable {
  def apply[A](implicit ev: JsonEncodable[A]): JsonEncodable[A] = ev
}

To pozwoli nam również na zapis:

1
2
val account: Account = Account("id", 100)
val jsonString: String = genericToJsonString(account)

Alterantywnie bez deklaracji companion object możemy pokusić się o takie sformułowanie:

1
def genericToJsonString[A: JsonEncodable](a: A) = implicitly[JsonEncodable[A]].toJsonString(a)

Można (i należy) dalej “upiększać” przy pomocy interface syntax lub interface object, o których warto przeczytać tu

Podsumowanie implementacji

Żeby zaimplementować typeclass musimy zrobić przynajmniej poniższe dwie rzeczy:

1. Zdefiniować typeclass-ę jako generyczny (sparametryzowany przynajmniej przez jeden typ) trait, na przykład JsonEncodable[A].
2. Przynajmniej jedną implementację powyższej typeclass-y - w naszym wypadku była to implicit val enc: JsonEncodable[Account] = ....

Podsumowanie

Mam nadzieję, że ten artykuł przybliżył Wam koncept typeclass-y. Jest to tylko wstęp, więc nie miej sobie za złe, jeżeli nie od razu widzisz zastosowania tej techniki. Postaram się to zmienić w kolejnych wpisach. Jest to jednak niezbędna widza, jeżeli chce się wejść na odrobinę wyższy poziom w Scali niż użycie map i filter.

Zmienna i stała

Używając Scali możemy określić wartość na dwa podstawowe sposoby var oraz val. var jest skrótem od angielskiego variable, dosłownie oznaczającą zmienną, val natomiast jest skrótem od value oznaczającego wartość. Zanim przejdziemy dalej, sądzę że należy rozprawić się z pewnym splątaniem tych pojęć.

1. W Scali, kiedy mówię o zmiennej mogę mieć na myśli zarówno var x: Int i val x: Int, a to nie pomaga. W praktyce, w związku z tym, że praktycznie nigdy nie używam var - mam na myśli val. Podobnie jest w innych językach typowanych, np. w Javie zmienną nazwę zarówno int x jak i final int x.
2. W matematyce zmienna oznacza zazwyczaj wielkość, która może przyjmować wartości z określonego zbioru. Zmienną można ustalić, czyli określić konkretną wartość i już się jej trzymać - nazwiemy wtedy ją stałą.

Warto zwrócić uwagę na pewną analogię pomiędzy tymi dwoma konstruktami, szczególnie na określenie typu w Scali oraz idee zbioru w matematyce.

Co to za różnica?

Słuszne pytanie! Zobaczmy więc jak zachowa się Scala, kiedy będziemy chcieli nadpisać wartość var oraz val.

1
2
3
4
5
6
7
8
9
10
11
12
scala> var x = 3
x: Int = 3

scala> x = 4
x: Int = 4

scala> val y = 3
y: Int = 3

scala> y = 5
<console>:12: error: reassignment to val
       y = 5

Okazuje się, że do val nie można ponownie przypisać wartości. Wydaje mi się, że zasadą, której należy się trzymać jest: Używaj tylko val, chyba że bardzo dobrze wiesz co robisz. Jest to podejście, które pozwoli szybciej wdrożyć się w jedyną słuszą drogę (JSD), tj. programowanie funkcyjne. W mojej ocenie, nie korzystanie z narzędzi jakie Scala daje, tak by sprawnie pisać funkcyjnie jest powodem, żeby w ogóle ze Scali zrezygnować.

Oczywiście dobrze byłoby uzasadnić pogląd wyższości val nad var. W mojej ocenie kluczową zaletą jest odciążenie mózgu. Istnieje duże prawdopodobieństwo, że jest to spowodowane moimi umiarkowanymi mocami intelektualnymi. Zawsze byłem pełen podziwu dla osób, które są w stanie spamiętać, gdzie i kiedy każdy konkretny var się zmienia. Pamiętają też, żeby pilnować te wartości w środowisku wielowątkowym. Być może część funkcjonalności jest poprawnie oddelegowana do innej metody, która oddelegowuje gdzieś dalej, a oni wciąż pamiętają każdą zmianę. Ja niestety takich talentów nie posiadam, więc uproszczenie i usystematyzowanie myślenia o kodzie jest dla mnie wartościowe.

Możliwość metodycznego i systematycznego myślenia o kodzie jest dla mnie ważna i zwięszka zaufanie do tego co piszę ja oraz osoby, z którymi pracuję. Czytając wtedy kod, wiem, że nie ma gdzieś ukrytej wartości, która może - zazwyczaj w nietrywialnej sytuacji brzegowej - wporwadzić w osłupienie i skierać na nieprzetarte szlaki z wiernym debuggerem.

Co ze strukturami danych?

Jeżeli takie zalety mają pojedyncze zmienne, to chicelibyśmy je generalizować na struktury danych. Na szczęście, rzeczywiście tak jest. W obrębie tego wpisu struktury danych rozumiem głównie klasy tworzone przez programistów, chociaż przenosi się to na “klasycznie” rozumiane struktury danych takie jak listy, słowniki, czy drzewa. W tym wypadku zazwyczaj w celach optymalizacyjnych implementacje zawierają jakiś stan, który jednak nie powinien wyciekać do użytkownika API takiej struktury.

Wróćmy do tworzonych przez nas klas oraz typów. Rozważmy uproszczony przykład konta bankowego, które posiada swój numer oraz stan dostępnych środków:

1
case class Account(var id: String, var balance: BigDecimal)

Jeżeli nawet odrobinę nie boli Cię widok takiej deklaracji, to powinien zacząć. Użycie var do określenia id jest zastanawiające niezależnie od tego z jakiej perspektywy patrzymy na nasz problem. Konto ma swój unikalny identyfikator i po utworzeniu nie powinniśmy móc go zmieniać.

Można natomiast próbować argumentować użycie var balance: BigDecimal. Przecież jak dostaję wypłatę, to nie mam nowego konta z wypłatą, lecz jest to to samo konto, którego stan jest powiększony o kwotę wypłaty. Ciężko się z tym nie zgodzić. Należy jednak pamiętać, że nie mamy obowiązku modelować świata w sposób identyczny, mamy tylko przedstawić jego reprezentację. Część osób zaznajomionych z DDD może powiedzieć, że Account to typowy przykład entity i związku z tym balance należy do pól, które mogą się zmieniać. W mojej ocenie jest to nadużycie koncepcji entity wewnątrz języka programowania i nie używanie poprawnie jego narzędzi, które nam dostarcza. Oczywiście nie podważam tutaj ani istotności DDD, ani entity przy modelowaniu domeny, po prostu nie wszystko należy przenosić dosłownie.

Konto po zwiększeniu kwoty nie staje się innym kontem. Jednak z punktu widzenia naszego kodu lepiej będzie, gdy wszystkie pola będą ustalone w momencie tworzenia, a do aktualizacji pól będziemy albo używać odpowienich metod, które będą zwracać kopię obiektu z zaktualizowanymi wartościami. W Scali każda case classa - a to właśnie ich powinniśmy używać do modelowania danych - ma metodę copy, która pozwala wygodnie zaktualizować wartość (są oczywiście jeszcze lenses, ale to podejście i temat przedyskutuję w oddzielnym wpisie). Poprawnie zamodelowana klasa Account i aktualizacja jej stanu powinna wyglądać następująco:

1
2
3
4
5
6
7
8
scala> case class Account(id: String, balance: BigDecimal)
defined class Account

scala> val acc = Account("id1", 0)
acc: Account = Account(id1,0)

scala> val accAfterPayday = acc.copy(balance = acc.balance + 100)
accAfterPayday: Account = Account(id1,100)

Zwróćmy uwagę, że w wypadku pominięcia słowa var Scala automatycznie uznaje pola klasy za niezmienne. Zupełnie jakby chciała nam coś powiedzieć. Oczywiście używanie copy może wydawać się dość siermiężne i należy używać odpowiednich technik - jak definiowanie dobrze nazwanych funkcji - by kod był siermiężny odrobinę mniej. Zasada, którą możemy wyciągnąć, mówi Używaj tylko niezmiennych struktur danych, chyba, że masz bardzo dobry powód by było inaczej. Z punktu widzenia użytkownika Twojej klasy - najlepiej, żeby API wyglądało jednak jakby było zupełnie immutable.

Podsumowanie

Temat ten dla kogoś, kto pracował ze Scalą jest oczywiście zupełnie podstawowy. Widzę jednak, że osoby przychodzące ze świata javascriptu, php i innych języków często właśnie w taki sposób próbują rozwiązywać problemy. Trzymanie się dwóch wytłuszczonych “zasad”, które przytoczyłem pozwoli na pisanie kodu, który będzie odrobinę łatwiejszy w utrzymaniu, czytelniejszy oraz - jeżeli dopiero zaczynasz przygodę ze Scalą/FP - zadba o szybsze postępy i wykluczy pewne, zazwyczaj niezdrowe, nawyki.

I based my post on Extreme learning machine: Theory and applications, by Guang-Bin Huang, Qin-Yu Zhu, Chee-Kheong Siew. That means that we will focus on neural networks with one hidden layer. Further advances have been made - for example using multiple hidden layers. If you are interested in that, you can visit this site. It is definitely worth it.

What is Extreme Learning Machine?

Before we can understand ELMs brief remainder of how Single hidden Layer Feedforward Networks (SLFNs) look like.

Single hidden Layer Feedforward Networks

As the name suggests, SLFN is a neural net that has a single hidden layer. What makes them interesting is that they are simple, which makes them easier to understand, imagine, represent and reason about. We will start with a very simple example.

There are two neurons in the input layer, three in the hidden layer and one in the output layer. Usually, we are most concerned about the hidden layer and that is why this type of neural network is called single layer. By feedforward we mean that data during actual usage (not during training) flows only forward, from left to right. We can represent input to this network as a two dimensional vector $x \in R^{2}, x = [x_{1}, x_{2}]$, hidden layer as a three dimensional vector $l \in R^{3}, l = [l_{1}, l_{2}, l_{3}]$ and output simply as a number $y \in R, y = y_{1}$.

We will be more interested in connections, which are represented by arrows in the image. Every arrow represents weight of that connection. In order to calculate value $l_{1}$ we need to do the following:

Let’s unpack this equation. $w_{11}, w_{12}$ are aformentioned weights connecting $x_{1}, x_{2}$ to to $l_1$ and $g$ is an activation function. If you do not know why bother with an activation function - it helps neural net learn learn complicated dependencies. You can read about this on this stackexchange post. What is $b_{1}$? It is a parameter called bias. It “moves” our function in proper direction if needed. My intuition goes as follows: We can have whole family of functions $x^{2} + b$, but in order to precisely identify which one I am talking about I need to pinpoint $b$ parameter which is a bias. In function $x^{2} + 4$, it is 4 that represent the bias. Now, with a little help of matrices we can write equation for j-th sample:

\(H_{j} = \begin{bmatrix} g(x_{j1} \cdot w_{11} + x_{j2} \cdot w_{12} + b_{1}) & g(x_{j1} \cdot w_{21} + x_{2} \cdot w_{22} + b_{2}) & g(x_{j1} \cdot w_{31} + x_{j2} \cdot w_{32} + b_{3}) \\ \end{bmatrix} \\ = \begin{bmatrix} g(\boldsymbol{x_{j}w_{1}} + b_{1}) & g(\boldsymbol{x_{j}w_{2}} + b_{2}) & g(\boldsymbol{x_{j}w_{3}} + b_{3}) \\ \end{bmatrix}\) Where bold dot mean vector dot product.

As you can see a connection between layers can be represented by a matrix.

So what is so extreme?

Now that we understand now SLFN look like we can get back to Extreme Learning Machines. The idea is simple - let’s assign a random value from continuous distribution (for people a little bit less math savvy, it’s just random), do the same for all values of the $w$ vector. After that, we can directly calculate the value of the matrix representing the second connection, which we will denote as $\hat{\beta}$.

Woah, that is a lot, so now it is time to unpack it.

Few lines above we have declared $H_j$ as a matrix representing hidden connection for a j-th sample. Matrix $H$ will represent hidden connections for all samples. Each row of the matrix will represent each sample. J-th label will be represented by $t_{j}$ and the whole vector with all labels will be denoted by $T$. The connection between the hidden and output layer will be denoted by $\hat{\beta}$ - it already represents connection for all the samples. For ELM it is also required that $g$ function is smooth, which for example - sigmoid is. Now we can write:

And as we know H (it is random, but known) all we have to do is solve above matrix equation for $\hat{\beta}$.

To state it another way, we want to ensure that:

A more math-savvy person may see a problem with that approach. What if we have more samples then hidden neurons? Then we will have more equations than free variables, making this equation impossible to solve explicitly.

Enter the Moore–Penrose inverse

To tackle the above problem we can use Moore-Penrose inverse. It is a generalization of an inverse, sometimes called a pseudoinverse. There is a decent wiki article on this topic.

Moore-Penrose inverse provide least squares solution that also has minimal norm! That is exactly what we wanted.

Now, we can easily describe our algorithm:

1. Assign random values to hidden weights and hidden biases
2. Calculate the value of $H$
3. Solve equation $H\hat{\beta} = T$ for $\hat{\beta}$

After dabbling ourselves a little bit in math, we should implement ELM. We will try to classify hand-written digit on MNIST dataset.

Sample Implementation on MNIST dataset

Jupyter notebook is available here