Duracellko.NET

How to optimize your calendar using quantum computing

Tue, 07 Jul 2026 00:00:00 GMT

This has probably happened to everyone, and to some people quite often. You receive a meeting invitation from your manager, but it conflicts with a meeting you already have with a colleague. So you try to move that meeting, but the colleague finds that your new proposal now conflicts with another meeting, meaning one of those meetings would need to move too. Finding an optimal schedule for meetings so that no conflicts remain is a very hard problem. Can a quantum computer help?

Background

A few years ago, I started looking into the field of quantum computing. Everywhere I heard that quantum computing was more powerful at solving hard problems, but no one explained what kind of problems. That is what I wanted to learn, so I picked up what some people call the bible of quantum computing, the Quantum Computation and Quantum Information book. The book presents two interesting results in quantum computing. The first is Shor's algorithm, or more generally, the Quantum Fourier Transform. This approach can solve the Hidden Subgroup Problem in polynomial time — in other words, problems where the solution space is periodic. The other highlighted achievement was Grover's algorithm, which provides a quadratic speedup for searching through any NP-hard problem's solution space.

After reading the book, I became interested in more than just the simple question of "What kind of problems can quantum computing solve efficiently?" I wanted to get some hands-on experience and try some quantum computing frameworks, so I started thinking about a good problem to practice on. Most of the NP-hard problems I could think of were optimization problems.

An optimization problem does not search for just any solution, but for the best solution — for example, "What is the shortest path from A to B?" Formally, an optimization problem defines a function \(f: X \rightarrow R\) that assigns a number to every solution; this function is usually called the cost function. The problem is then to find the \(x\) with the minimum value of \(f(x)\). It is also possible to search for the maximum value by simply defining the cost function as \(g(x) = -f(x)\).

Then I realized that the book did not mention optimization problems at all, so I looked into whether there were any quantum computing achievements for optimization problems. I found the breakthrough paper A Quantum Approximate Optimization Algorithm. This paper was published in 2014, so its results could not have been included in a book published in 2010.

Problem

Let's formalize the meeting scheduling problem. The input is a set of unscheduled meetings. Each meeting has a list of required attendees. For simplicity, let's say each meeting requires one hour. The output is a schedule — a time slot assigned to each meeting — such that any two meetings with at least one common attendee are assigned different time slots. The goal is to minimize the number of time slots occupied by all meetings.

For example, consider the following meetings:

Meeting	Attendees
Quantum Mechanics symposium	Albert Einstein, Boris Podolsky, Claude Shannon, John von Neumann
Calculus and Differential Equations lecture	Isaac Newton, Gottfried Wilhelm Leibniz, Leonhard Euler
Graph Theory and Combinatorics colloquium	Paul Erdős, Leonhard Euler, Frank Ramsey
Information Theory symposium	Claude Shannon, Alan Turing, John von Neumann

The Quantum Mechanics symposium and the Information Theory symposium cannot be scheduled at the same time because Claude Shannon and John von Neumann attend both. The Calculus and Differential Equations lecture and the Graph Theory and Combinatorics colloquium cannot overlap because Leonhard Euler attends both.

One optimal schedule is:

Time	Meeting
8:00	Quantum Mechanics symposium
8:00	Calculus and Differential Equations lecture
9:00	Graph Theory and Combinatorics colloquium
9:00	Information Theory symposium

Minimum Graph Coloring

The scheduling problem can be transformed into the Minimum Graph Coloring problem.

Graph coloring is the task of assigning a color to each vertex such that no two vertices connected by an edge share the same color. The minimum graph coloring problem asks: what is the smallest number of colors needed to accomplish this? That number is called the chromatic number of the graph.

Transforming the schedule into a graph

The scheduling problem maps to a graph in two steps:

Each meeting becomes a vertex.
Two vertices are connected by an edge if and only if the two meetings share at least one attendee.

Applying this to our example produces the following graph:

We then find a coloring of this graph using the minimum number of colors. Each color is assigned a unique time slot. It is straightforward to see why this works: if two conflicting meetings were assigned the same time slot, they would be connected by an edge yet share the same color — which violates the coloring constraint. Therefore, a valid coloring guarantees a conflict-free schedule, and minimizing the number of colors minimizes the number of time slots.

Quantum Approximate Optimization Algorithm for Minimum Graph Coloring

Now we arrive at the quantum part. The Quantum Approximate Optimization Algorithm (QAOA) is a hybrid quantum-classical algorithm designed to solve combinatorial optimization problems. "Hybrid" means it uses a quantum computer and a classical computer together, playing to the strengths of each.

Before QAOA can run on a quantum computer, the solution space of the optimization problem must be encoded in quantum states. The usual form of encoding is a binary encoding into multiple qubits in basis \(|0 \rangle\) and \(|1 \rangle\), similar to how the solution would be encoded in a classical binary array. In context of the Minimum Graph Coloring problem, this means that every vertex coloring must be assigned to a unique quantum state (or classical binary string). Then the optimization cost function is defined as a cost Hamiltonian \(H_c\). A "Hamiltonian" is an operator or function that calculates the total energy of the quantum state. In this way, an optimization problem of finding the best solution can be transformed into the problem of finding a quantum state with the lowest energy.

There are many ways to look at how QAOA works, and I found an interesting one in An Introduction to the Quantum Approximate Optimization Algorithm. The paper mentions the Adiabatic Theorem and its implication, stating:

If a quantum system is in the lowest energy state of the initial Hamiltonian \(H_i\) and it is slowly transformed to the final Hamiltonian \(H_f\), then the system stays in the lowest energy state through the transformation, ending in the lowest energy state of Hamiltonian \(H_f\).

So a quantum optimization algorithm would start with a well-known initial Hamiltonian and its well-known lowest energy state. For an \(n\)-qubit system, a good starting point is the Hamiltonian

\[ H_i = - \sum_{i=1}^{n}X_i \]

where \(X_i\) is the Pauli-X matrix applied to qubit \(i\). It is easy to check that the lowest energy state of \(H_i\) is the superposition of all basis states.

\[ \psi_0 = | + \rangle ^{\otimes n} = H^{\otimes n}|0,\ldots,0\rangle \]

Then we define a time-evolving Hamiltonian for the system that would slowly transform from \(H_i\) to \(H_f\). So the Hamiltonian at time \(t\) would be

\[ H(t) = (1-t)H_i + tH_f, \quad t \in [0, 1] \]

This means that the quantum circuit for the full time evolution would need to implement the unitary operation

\[ U = e^{-i \int_{0}^{1} H(t)dt} \]

Unfortunately, in general this quantum circuit would need an infinite number of gates to implement this operation precisely. However, it is possible to approximate it by splitting the continuous time interval \(t \in [0, 1]\) into a finite number of steps. The steps do not have to be the same size, so the circuit would be the product of the following unitary operations.

\[ U \approx \prod_{k=1}^{p} e^{-i (1-t_k) H_i} e^{-i t_k H_f} \]

where \(t_k\) are timestamps on the interval \([0, 1]\). We can generalize this operation by replacing \((1-t_k)\) with \(\beta_k / 2\) and \(t_k\) with \(\gamma_k / 2\). Then the operation looks like

\[ U \approx U_p = \left( e^{-i \frac{\beta_p}{2} H_i} e^{-i \frac{\gamma_p}{2} H_f} \right) \ldots \left( e^{-i \frac{\beta_1}{2} H_i} e^{-i \frac{\gamma_1}{2} H_f} \right) \]

A nice property of this operation is that, for a well-chosen Hamiltonian, the operation \(e^{-i \frac{\alpha}{2} H}\) is easy to implement in a quantum circuit. Usually it just needs to entangle specific qubits and then simply rotate a specific qubit by angle \(\alpha\). Also, increasing the number of steps in the circuit improves the precision of the calculation, as

\[ \lim_{p \to \infty} U_p | \psi_0 \rangle = U | \psi_0 \rangle \]

Another way to look at it is that the algorithm starts with a superposition of all possible states and then iteratively alternates between the final and initial (also known as the mixer) Hamiltonians, with different weights / rotation angles. The final Hamiltonian shifts the phase toward optimal solutions, thus amplifying optimal solutions and suppressing bad ones. The mixer Hamiltonian then mixes the state so that the algorithm does not get stuck in a local minimum, but instead searches for the global one.

Final Hamiltonian

Now that we know how the quantum optimization algorithm works, we need to find the final Hamiltonian and the angles \(\beta_i\) and \(\gamma_i\).

Recently, a new study proposed a qubit-efficient cost Hamiltonian for the Minimum Graph Coloring problem. It was published in "Qubit-efficient and gate-efficient encodings of graph partitioning problems for quantum optimization". It suggests encoding the coloring in the following way.

Each vertex (meeting) is assigned a block of \(L = \lceil \log_2 C \rceil\) qubits, where \(C\) is an upper bound on the chromatic number derived from Brooks' theorem. These \(L\) qubits encode the vertex's color as a binary integer. With \(n\) vertices, the coloring register uses \(n \cdot L\) qubits total.

For example, with 4 meetings and a chromatic number bound of 3, the number of bits per meeting is \(L = \lceil \log_2 3 \rceil = 2\), which leads to 8 qubits total in the coloring register.

The paper phrases the cost function directly in terms of classical bits, before any quantum encoding enters the picture. Let \(x_{v,k} \in \{0, 1\}\) denote bit \(k\) of vertex \(v\)'s color, so that vertex \(v\)'s color is the integer \(\sum_{k} x_{v,k} 2^k\). The cost function — called a Hamiltonian by analogy with its quantum counterpart — is

\[ H = A \sum_{(u,v) \in E} \prod_{k=0}^{L-1} \left( 2x_{u,k}x_{v,k} - x_{u,k} - x_{v,k} + 1 \right) + \sum_{k=0}^{L-1} P_k \sum_{v \in V} x_{v,k} \]

The first term is the adjacency penalty. The factor \(2x_ux_v - x_u - x_v + 1\) is just the XNOR of the two bits written as a polynomial: it equals \(1\) when \(x_u = x_v\) and \(0\) otherwise. So the product over all \(L\) bits of an edge \((u, v)\) evaluates to \(1\) exactly when every bit matches — that is, when the two meetings have been assigned the same color — and to \(0\) the moment a single bit differs. Summed over all edges and scaled by a constant \(A\), this term adds energy \(A\) for every conflicting pair of meetings and zero energy for every properly colored edge.

The second term is the lexicographic penalty. Taken alone, the adjacency term is satisfied by any proper coloring, including wasteful ones — nothing stops the optimizer from giving every meeting its own color. The weights \(P_k\) grow with \(k\) fast enough that setting a higher-order color bit always costs more than a lower-order one, which nudges the optimizer toward colorings that only use the lower-order bits, i.e. the smallest color indices. This is exactly the minimum coloring we are after. In the paper, \(A = (n+1)^L\) and \(P_k = (n+1)^k\), where \(n\) is the number of vertices; both are chosen large enough that satisfying adjacency is always prioritized over lexicographic minimization, but small enough that lexicographic terms converge sufficently for approximation.

To run this Hamiltonian on a quantum computer, it needs to be expressed as an operator acting on qubits, and the natural choice for encoding a single bit is the Pauli-\(Z\) operator, whose eigenvalues are \(+1\) and \(-1\) rather than \(0\) and \(1\). The standard substitution is

\[ x_{v,k} = \frac{1 - Z_{v,k}}{2} \]

so \(Z_{v,k} = +1\) when bit \(k\) of vertex \(v\)'s color is \(0\), and \(Z_{v,k} = -1\) when it is \(1\). Plugging this into the adjacency factor collapses it to

\[ 2x_{u,k}x_{v,k} - x_{u,k} - x_{v,k} + 1 = \frac{1 + Z_{u,k}Z_{v,k}}{2} \]

Taking the product of this over all \(L\) bits and expanding it turns the single XNOR factor into a sum over every non-empty subset \(S\) of bit positions, since \(\prod_k (1 + Z_{u,k}Z_{v,k})/2 = 2^{-L}\sum_{S \subseteq \{ 0, \ldots, L-1 \}} \prod_{k \in S} Z_{u,k}Z_{v,k}\) (the \(S = \emptyset\) term contributes only a constant). That factor of \(2^{-L}\) combines with the classical-level coefficient \(A = (n+1)^L\) to give a smaller effective weight, \((n+1)^L \cdot 2^{-L} = \left(\frac{n+1}{2}\right)^L\), on each qubit-level term. After dropping the remaining constant terms — they shift every state's energy equally and therefore never change which state has the lowest energy — the cost Hamiltonian becomes

\[ H_f = A' \sum_{(u,v) \in E} \sum_{\substack{S \subseteq \{0,\ldots,L-1\} \\ S \neq \emptyset}} \prod_{k \in S} Z_{u,k} Z_{v,k} \; - \; \frac{1}{2} \sum_{k=0}^{L-1} (n+1)^k \sum_{v \in V} Z_{v,k} \]

with \(A' = \left(\frac{n+1}{2}\right)^L\) — the rescaled, qubit-level version of the classical-level \(A\) from before.

Implementation

Now that we know theoretically how the quantum circuit should look, let's implement it. The first step for me was to look at which quantum computing framework I would like to use. My goal was to learn, not necessarily to run the program on an actual quantum computer, so my preference was a vendor-independent framework. Therefore, I tried to avoid Qiskit or Q#, even though there were a lot of references to Qiskit. I found a possibly interesting project, ProjectQ. Unfortunately, just installing it produced a warning that it was not compatible with the new version of Python 3.14, and even running a simple example didn't work on this version. Then I noticed that the latest release was from 2022, so I decided to try something else.

The next candidate was PennyLane, which worked very well, so the implementation in this post uses this framework.

Initial Hamiltonian implementation

Let's start with the function that implements the initial Hamiltonian.

def _get_initial_hamiltonian(self, qubit_count: int) -> qpl.Hamiltonian:
    coeffs = [1.0] * qubit_count
    ops = [1.0 * qpl.PauliX(i) for i in range(qubit_count)]
    return qpl.Hamiltonian(coeffs, ops)

PennyLane represents a Hamiltonian as a weighted sum of operators: a list of coefficients paired with a matching list of operators. Here every coefficient is \(1.0\) and every operator is \(X_i\) for qubit \(i\), which gives \(H_i = \sum_i X_i\) — the transverse-field mixer from the theory section, applied across all qubit_count qubits.

One detail worth flagging: the sign here is the opposite of the \(-\sum_i X_i\) used earlier. This does not matter in practice. The mixer only ever appears inside qpl.qaoa.mixer_layer as \(e^{-i\beta H_i}\), so flipping the sign of \(H_i\) is equivalent to negating \(\beta\), and the classical optimizer is free to pick whichever sign works best within its bounds.

Final Hamiltonian implementation

def _get_final_hamiltonian(self) -> qpl.Hamiltonian:
    n = self.vertex_count
    num_bits = self.color_bits_count

    def qubit(vertex_idx: int, bit: int) -> int:
        return vertex_idx * num_bits + bit

    coeffs: list[float] = []
    ops: list[qpl.operation.Operator] = []

    # --- Adjacency term ---
    adj_coeff = ((n + 1) / 2) ** num_bits
    for u, v in self.graph.edges():
        ui = self.vertices.index(u)
        vi = self.vertices.index(v)
        for mask in range(1 << num_bits):
            subset_qubits: list[int] = []
            for k in range(num_bits):
                if mask & (1 << k):
                    subset_qubits.append(qubit(ui, k))
                    subset_qubits.append(qubit(vi, k))

            if subset_qubits:
                op: qpl.operation.Operator = qpl.PauliZ(subset_qubits[0])
                for q in subset_qubits[1:]:
                    op = op @ qpl.PauliZ(q)

                coeffs.append(adj_coeff)
                ops.append(op)

    # --- Lexicographic term ---
    for k in range(num_bits):
        coeff = -0.5 * (n + 1) ** k
        for i in range(n):
            coeffs.append(coeff)
            ops.append(qpl.PauliZ(qubit(i, k)))

    return qpl.Hamiltonian(coeffs, ops)

This is a direct transcription of the Hamiltonian derived above. Four attributes of the solver instance have impact on the Hamiltonian:

self.graph — the conflict meeting graph itself. Each edge represents a conflict between meetings. The function builds an adjacency term for each edge.
self.vertex_count (\(n\)) — the number of meetings, computed once as len(graph.nodes()). It sets the base of the exponential weights \(A\) and \(P_k\).
self.color_bits_count (\(L\)) — the number of qubits used per vertex, computed from the logarithm of the Brooks'-theorem bound described earlier.
self.vertices — a fixed-order list of the graph's nodes, used to translate a vertex (which might be an arbitrary Python object, like a meeting name) into an integer index. That index is what qubit() uses to compute the qubit offset for a given vertex and bit.

The small helper function qubit calculates the index of the qubit that represents a specific bit of the color of a specific vertex. Notice that the color encoding is little-endian: the more significant bit has the higher qubit index.

The nested loop over mask in range(1 << num_bits) is the code's way of iterating over every non-empty subset \(S\) of bit positions: each bit of mask says whether bit position \(k\) belongs to \(S\), and whenever it does, both \(Z_{u,k}\) and \(Z_{v,k}\) are folded into the running tensor product via PennyLane's @ operator (which composes operators into a multi-qubit Pauli string). The lexicographic term above is a much simpler double loop — one term per bit position \(k\) per vertex \(v\), with coefficient \(-\frac{1}{2}(n+1)^k\) exactly as derived above.

Quantum circuit implementation

def get_colors(self, angles: list[float]) -> tuple[list[int], float]:
    @qpl.qnode(self._dev)
    def circuit() -> npt.NDArray[np.int_]:
        self._execute_layers(pnp.array(angles))
        return qpl.probs(wires=range(self.all_qubits_count))

    probabilities = circuit()

    state = np.argmax(probabilities)
    probability = probabilities[state]

    return (self._decode_colors(state), probability)

def _execute_layers(self, angles: npt.NDArray[np.float64]) -> None:
    for i in range(self.all_qubits_count):
        qpl.Hadamard(wires=i)

    half = len(angles) // 2
    for beta, gamma in zip(angles[:half], angles[half:]):
        qpl.qaoa.cost_layer(gamma, self.final_hamiltonian)
        qpl.qaoa.mixer_layer(beta, self.initial_hamiltonian)

def _decode_colors(self, state: np.int_) -> list[int]:
    colors: list[int] = []

    for i in range(self.vertex_count):
        color = 0
        bit_value = 1
        for j in range(self.color_bits_count):
            bit_index = i * self.color_bits_count + j
            # Reflect: qubit 0 is the highest bit of the integer.
            bit_index = self.coloring_qubits_count - 1 - bit_index
            if state & (1 << bit_index):
                color += bit_value
            bit_value <<= 1

        colors.append(color)

    return colors

The get_colors function calculates the coloring with the highest probability. The function uses the following attributes of the solver instance:

self.coloring_qubits_count (\(n \cdot L\)) — the total number of qubits. It equals the number of vertices times the number of coloring bits per vertex.
self.all_qubits_count — same as coloring_qubits_count here. However, there is a version with some ancilla qubits that would be counted in this attribute too.

If the angles are provided, running the circuit is just a matter of executing it and reading out qpl.probs(), which returns the full probability distribution over all \(2^n\) basis states — the quantum-simulator equivalent of running the real circuit many times and building a histogram of measurement outcomes. np.argmax picks the single most likely basis state, and _decode_colors turns that state back into a coloring. For color decoding, keep in mind that the encoding is little-endian.

The interesting part is _execute_layers, since it is what turns the abstract \(U_p\) formula from the theory section into an actual sequence of gates:

The first loop applies a Hadamard gate to every qubit, which is what actually prepares the uniform superposition \(\psi_0 = |+\rangle^{\otimes n}\). The angles list is the flat \((\beta_0,\ldots, \beta_{p-1}, \gamma_0,\ldots, \gamma_{p-1})\) array provided as parameter, split in half and zipped back into \(p\) (beta, gamma) pairs. Each pair becomes one layer: qpl.qaoa.cost_layer compiles \(e^{-i\gamma H_f}\) into gates directly from the final_hamiltonian object built earlier, and qpl.qaoa.mixer_layer does the same for \(e^{-i\beta H_i}\) using initial_hamiltonian. Stacking \(p\) of these pairs is exactly the product \(U_p\) from the theory section.

Finding angles — optimizing

Now we have the quantum circuit with angles as parameters, so the only question is how to set up those angles. Unfortunately, this is the hardest part of QAOA. The first thing we need is to implement a function that returns the expectation value of the quantum circuit measured using the final Hamiltonian. This means we would not measure all qubits individually, but only the total energy. In other words, if we start with the initial state as a superposition of all basis states

\[ \psi_0 = | + \rangle ^{\otimes n} = H^{\otimes n}|0,\ldots 0 \rangle \]

and run the circuit that implements the unitary operation

\[ U_p = \left( e^{-i \frac{\beta_p}{2} H_i} e^{-i \frac{\gamma_p}{2} H_f} \right) \ldots \left( e^{-i \frac{\beta_1}{2} H_i} e^{-i \frac{\gamma_1}{2} H_f} \right) \]

and we get the final state

\[ \psi_f = U\psi_0 \]

then the expectation value of the final Hamiltonian (or mean total energy) is

\[ \langle \psi_f | H_f | \psi_f \rangle \]

The following function creates such circuit.

def _build_cost_circuit(self) -> qpl.QNode:
    @qpl.qnode(self._dev)
    def circuit(angles: npt.NDArray[np.float64]) -> float:
        self._execute_layers(angles)
        return qpl.expval(self.final_hamiltonian)

    return circuit

This looks almost identical to the circuit inside get_colors, and it is — same device, same _execute_layers call — but it returns qpl.expval(self.final_hamiltonian) instead of qpl.probs(). Instead of the full probability distribution, qpl.expval returns a single number: \(\langle \psi_f | H_f | \psi_f \rangle\), the expectation value we derived above.

The quantum simulator calculates the exact expectation value. Using a real quantum computer, the function would return the mean measured value over multiple measured samples.

Next we will use classical optimization algorithms to find optimal parameters that minimize the output of the _cost_circuit function. There are many algorithms, and Claude recommended COBYLA (Constrained Optimization BY Linear Approximation) that is implemented in SciPy.

def find_optimal_angles(self) -> list[float]:
    angles: list[float] = []
    angles += [self.starting_beta] * self.evolution_count
    angles += [self.starting_gamma] * self.evolution_count

    bounds: list[tuple[float, float]] = []
    bounds += [(0, math.pi / 2)] * self.evolution_count
    bounds += [(0, math.pi)] * self.evolution_count

    options: dict[str, Any] = { "maxiter": self.optimization_steps }

    def cost_fun(angles: npt.NDArray[np.float64]) -> float:
        return self._cost_circuit(angles)

    result = opt.minimize(
        cost_fun,
        pnp.array(angles),
        method="COBYLA",
        bounds=bounds,
        options=options)

    return [float(x) for x in result.x]

evolution_count is the class variable that sets \(p\), the number of iterations (evolutions) in the QAOA circuit. It also defines the number of \(\beta\) and \(\gamma\) angles. The function creates a list of angles \((\beta_0,\ldots, \beta_{p-1}, \gamma_0,\ldots, \gamma_{p-1})\) and sets each \(\beta_i\) to starting_beta and each \(\gamma_i\) to starting_gamma — the array with the layout that is expected by _execute_layers function. The bounds keep every \(\beta\) in \([0, \pi/2]\) and every \(\gamma\) in \([0, \pi]\), which follows from the periodicity of the rotations each angle controls — searching outside these ranges would just retrace angles already covered inside them.

cost_fun is a thin wrapper around the _cost_circuit QNode built above, and opt.minimize(..., method="COBYLA") hands it to SciPy's COBYLA optimizer, which repeatedly proposes new angle values, evaluates the quantum circuit at each one (via cost_fun), and uses those samples to find the optimal angles. optimization_steps caps how many such evaluations COBYLA is allowed to make. The angles it converges to (result.x) are what gets passed into get_colors afterward.

Putting it all together

All the pieces — Hamiltonians, circuit, optimizer — come together in one function that takes a networkx graph and returns a colored copy of it.

def min_graph_coloring(graph: Graph[Any]) -> GraphColoringResult:
    result = graph.copy()

    # A graph with no vertices or edges needs no quantum computation at all.
    if not graph.nodes():
        return GraphColoringResult(result, 1.0)

    if not graph.edges():
        for v in result.nodes():
            result.nodes[v]["color"] = 0
        return GraphColoringResult(result, 1.0)

    solver = GraphColoringSolver(result)
    optimal_angles = solver.find_optimal_angles()

    probability = 0.0

    if len(optimal_angles) > 0:
        colors, probability = solver.get_colors(optimal_angles)

        # The most probable measurement is not guaranteed to be a valid
        # coloring — verify before accepting it.
        if _verify_coloring(result, solver.vertices, colors):
            for i, v in enumerate(solver.vertices):
                result.nodes[v]["color"] = colors[i]
            return GraphColoringResult(result, probability)

    # Fallback: unique color per vertex (always a valid n-coloring).
    for i, v in enumerate(solver.vertices):
        result.nodes[v]["color"] = i
    return GraphColoringResult(result, probability)

Two edge cases are handled before any quantum computation happens: a graph with no vertices needs nothing, and a graph with vertices but no edges has no conflicts, so every meeting can share color 0. Otherwise a GraphColoringSolver is built for the graph — this is the constructor that computes the Brooks'-theorem bound, lays out the qubits, and builds initial_hamiltonian and final_hamiltonian — angles are optimized with find_optimal_angles, and the resulting state is decoded with get_colors.

That last step is a heuristic, not a guarantee: QAOA can converge on a state that is not a valid coloring at all, so _verify_coloring double-checks the decoded colors against the actual graph before accepting them. If verification fails — or if the optimizer returned no angles at all — the function falls back to assigning every vertex its own color, which is trivially a valid coloring, but likely far from minimal.

Full source code can be found at https://github.com/duracellko/qcalendar.

Tuning

The code above has three variables whose setup I have not yet mentioned: starting_beta, starting_gamma, and evolution_count. These need to be tuned by experimentation.

I ran some configurations on a quantum simulator. First, I started with a graph with 4 vertices and 2 edges.

The upper bound on the chromatic number of this graph is 2, so the algorithm needs only 4 qubits to run.

The following variables were set:

evolution_count: 2
maxiter (COBYLA - maximum number of evaluations): 100

The following table presents the probability results for different values of starting_beta and starting_gamma.

\(\beta\)	\(\gamma\)	Probability	All solutions probability
0.001	0.001	0.227535758	0.910143032
0.01	0.01	0.227534724	0.910138897
0.1	0.1	0.227536269	0.910145077
\(\pi / 4\)	\(\pi / 4\)	0.249993679	0.999974715
\(\pi / 8\)	\(\pi / 4\)	0.249981939	0.999927754
\(\pi / 8 + 0.01\)	\(\pi / 4 + 0.01\)	0.235672315	0.94268926

Probability - probability of the resulting coloring with the highest probability.
All solutions probability - sum of probabilities of all colorings with the minimum number of colors. This is the probability of the optimal outcome. Keep in mind that there is more than 1 optimal solution.

Then I ran the program on the graph with 4 vertices and 4 edges.

The upper bound on the chromatic number of this graph is 3, so the algorithm needs 8 qubits to run. The same values were used for evolution_count and maxiter.

The following table presents the probability results for different values of starting_beta and starting_gamma.

\(\beta\)	\(\gamma\)	Probability	All solutions probability
0.001	0.001	0.019252569	0.054215138
0.01	0.01	0.013778213	0.100561002
0.1	0.1	0.017372671	0.047633037
\(\pi / 4\)	\(\pi / 4\)	0.00390625	0.046875
\(\pi / 8\)	\(\pi / 4\)	0.023170804	0.165677839
\(\pi / 8 + 0.01\)	\(\pi / 4 + 0.01\)	0.026776257	0.125146567

It seems that a good starting point would be somewhere around \(\pi / 8\) and \(\pi / 4\). However, this is based only on simulation.

Summary

We mapped meeting scheduling to the minimum graph coloring problem and showed how QAOA can be used in a hybrid quantum-classical workflow to search for good schedules. Then we implemented the QAOA algorithm using PennyLane. The implementation includes the initial and final Hamiltonians, the quantum circuit, and the classical optimizer. Finally, we ran some experiments on a quantum simulator to find good starting values for the angles.

Note: Full source code can be found at https://github.com/duracellko/qcalendar.

Cooperative vs Preemptive Multitasking

Thu, 05 Feb 2026 00:00:00 GMT

A few weeks ago I wrote about the ideas behind the origin of async/await constructs in modern programming languages, and it reminded me that async/await revives an old pattern. The main goal of async/await frameworks is to provide a way to split a procedure into small tasks that can be scheduled on available processors. Soon after the first preview, it became clear that a task does not have to be only a piece of code running on a processor; it can be code running in another process, on another device, or even on another machine. Examples include a Remote Procedure Call (RPC), a database query, or a write request to a file system. In practice, these kinds of tasks are often more common than CPU-bound tasks, and async/await frameworks schedule them using a framework-level scheduler. This raises a question: why do we need an extra scheduler when modern operating systems already provide schedulers for threads and processes?

To answer that, let's look at older operating systems. In the early 1990s, before Mac OS was considered favorite choice for developers, the first operating systems supporting multitasking were introduced. That multitasking model was relatively simple and worked like this:

The operating system started a program.
The program then told the operating system:
1. Please create a new window for me.
2. When anything happens to the window (for example, the user clicks a button or resizes the window), call this callback function.
The program returned control to the operating system.
When an event occurred, the operating system invoked the program's callback function.
The callback handled the event and returned control to the operating system.
The operating system scheduled the next task.

This type of multitasking is called cooperative multitasking. The operating system relies on the program to return control back to it. It may not look complicated today, but it was a big change in thinking for programmers who were used to having complete control over the computer at that time. The advantage of cooperative multitasking is that it has low overhead and is therefore very efficient. The disadvantage is that if a program does not return control to the operating system, the whole system becomes unresponsive. For example, if a program enters an infinite loop, the operating system will never get control back, and thus cannot handle any other programs. Same as today, programs had bugs that could cause such situations.

To solve this problem, preemptive multitasking was introduced. In preemptive multitasking, the operating system has a timer that interrupts running programs after a certain time slice. When interrupted, the operating system saves the state of the program, and then switches to another program. This way, even if a program does not return control back to the operating system, the operating system can still regain control after the time slice expires. This makes the system more robust and responsive. However, preemptive multitasking has higher overhead due to context switching and state saving.

Keep in mind that the same programming model with window event handlers is still used on modern operating systems with preemptive multitasking. The difference is that the OS can interrupt the program at any time, not just when the program yields.

Now let's go back to async/await frameworks. Most applications using async/await frameworks assume that tasks are short-running and do not get stuck running indefinitely. Of course, there can still be bugs in the code and it is not possible to guarantee that a task will not get stuck. However, it is not expected that developers would write routines to handle such situations. In such cases, the usual approach is to restart the whole application. Thus, async/await frameworks can use a cooperative multitasking approach, where tasks are expected to return control back to the scheduler. This makes async/await frameworks more efficient, as they do not have to deal with frequent context switching and state saving.

It is interesting that a use case (cooperative multitasking) that was considered problematic in early operating systems and replaced by a more robust approach (preemptive multitasking) is now being used in modern async/await frameworks. This shows that sometimes, old ideas can be revived and adapted to new contexts, providing efficient solutions to modern problems.

Also, similar use cases can be seen in real-life scenarios. Constant meetings make software development less efficient because of the context switching. However, if stakeholders think that developers could get stuck on some tasks, then a more robust development process is worth the cost of context switching.

Quantum coin flipping

Thu, 29 Jan 2026 00:00:00 GMT

The previous post showed that quantum networks can be as interesting as quantum computers. The main difference from classical networks is the ability to transmit qubits instead of classical bits. This post explores another interesting problem in network communication: Coin flipping.

The problem of coin flipping is to make a fair random decision between two choices. For example, Alice and Bob want to see a movie. Alice prefers the latest DC movie and Bob prefers the latest Marvel movie. They agree to flip a coin to decide which movie to watch. The problem is that they are in different parts of the city, so they cannot flip a physical coin together. Instead, they need to communicate over a network to agree on the coin flip result. The issue is that either Alice or Bob could cheat. For example, Alice could flip a coin and Bob announces head as his guess. Alice could then simply say tail even if the coin landed on head. Or, if Alice announces the coin flip result first, Bob could claim that he guessed it correctly no matter what Alice announced.

A solution could be to involve a trusted third party, Charlie. Alice and Bob can both send their guesses to Charlie, who flips a coin and announces the result. However, a trusted third party is not always available, or may not be trustworthy.

Random choice

Before looking at a coin flipping protocol, let's consider a simpler problem: random choice or a random function. In the real world, it is possible to flip a coin and have it randomly land on head or tail, ideally with a 50% probability for each side. In other words, we want a function that randomly returns either 0 or 1. However, mathematically, all functions are deterministic. This means that for a given input, the function always returns the same output. A solution is to use a secret counter as input for the random function. The counter is incremented for each call, so the input is always different. Since the counter is secret, the output appears random to an outside observer. The function should be complex enough that an observer cannot deduce anything about the counter from previous outputs to predict future outputs. However, as the function has a finite number of instructions, there is a certain number of outputs after which it becomes possible to predict future outputs. Of course, it is desirable for this number to be large enough to be practically unreachable. Therefore, such functions are called pseudorandom functions or pseudorandom number generators.

Another solution is to introduce some randomness from outside the function. For example, today's CPUs have special hardware instructions that return random numbers based on physical processes inside the CPU. Such functions are called true random functions or true random number generators. These systems use physical noise that comes from outside the computer system, such as thermal or electrical noise.

Even for this simpler problem, quantum mechanics can help. A qubit can be prepared at a 45° angle (↗️). Then it is measured in the standard basis: x-axis (90°) and y-axis (0°). The measurement returns 0° or 90° with 50% probability each. We can assign bit 0 to 0° and bit 1 to 90°. Quantum measurement then returns a truly random bit.

Classical coin flipping

As mentioned, if Alice reveals her coin flip result first, Bob can cheat by claiming that he guessed it correctly. If Bob reveals his guess first, Alice can cheat by announcing the opposite of Bob's guess. Therefore, Alice should reveal something about the coin flip result. That something must hide the actual result, so that Bob cannot deduce it and cheat. However, it must also be possible for Bob to verify that Alice did not change her mind when she reveals the actual result. In other words, Alice has to commit to a value. That something may be, for example, a cryptographic hash function like SHA-3. So the protocol can look like this:

Alice generates a large random number \(x\) with at least as many bits as the output size of SHA-3 (for example, 256 bits).
Alice sends the hash value \(h = \mathrm{SHA3}(x)\) to Bob.
Bob guesses if \(x\) is even or odd and sends his guess to Alice. Notice that he cannot tell anything about \(x\), because it is hard to compute the inverse of the hash function.
Alice sends \(x\) to Bob. Bob computes the hash value and compares it with the value \(h\) received in step 2. This way, he can verify that Alice did not change her mind.
If Bob's guess matches the parity of \(x\), Bob wins; otherwise, Alice wins.

This protocol is secure as long as the hash function is secure. This means that it is hard to compute the inverse of the hash function and hard to find collisions (two different inputs that produce the same output). There may be other commitment functions based on other hard computational problems.

Quantum coin flipping

Is it possible to use the secrecy of quantum states to implement a coin flipping protocol without relying on hard computational problems? The answer is yes, it is possible. The communication should follow this protocol:

Alice randomly chooses a single basis: either horizontal/vertical (HV) or diagonal/antidiagonal (DA).
Alice randomly chooses a string of bits and converts each bit to a qubit using the chosen basis.

Secret bit	Basis	Qubit direction
0	0 (HV) ➡️⬆️	Horizontal (0°) ➡️
1	0 (HV) ➡️⬆️	Vertical (90°) ⬆️
0	1 (DA) ↗️↘️	Diagonal (45°) ↗️
1	1 (DA) ↗️↘️	Anti-diagonal (135°) ↘️

Alice sends the qubits to Bob.
Bob randomly chooses a basis (HV or DA) for each qubit and measures them.
Bob guesses the basis used by Alice (HV or DA) and sends his guess to Alice. If the guess is correct, Bob wins; otherwise, Alice wins.
Alice reveals the basis she used and the original bits.
Bob takes the measurements from step 4 where his basis was the same as Alice's basis. He compares the measurement results with the original bits revealed by Alice. If they match, Bob accepts the result; otherwise, he accuses Alice of cheating.

The following example shows how the protocol works:

Alice chooses the horizontal/vertical basis (HV) - ➡️⬆️.
Alice chooses random bits 1, 0, 1, 1, 0 and encodes them to qubits: ⬆️➡️⬆️⬆️➡️.
Alice sends the qubits to Bob.
Bob measures the qubits in random bases:

Row	Qubit	Bob's basis	Bob's measurement	Probability
1	⬆️	HV ➡️⬆️	1	100%
2	➡️	HV ➡️⬆️	0	100%
3	⬆️	DA ↗️↘️	0	50%
4	⬆️	HV ➡️⬆️	1	100%
5	➡️	DA ↗️↘️	1	50%

Bob guesses basis DA.
Alice announces that Bob guessed incorrectly and sends him the original bits.
Bob now takes his measurements from rows 1, 2, and 4, where his basis matched Alice's basis. He compares them with the original bits 1, 0, and 1. They match, so Bob accepts the result.

If Bob wants to cheat, he would need to find the actual angle of a qubit. For example, if Bob measures 1, the qubit could be either ⬆️ (0°) or ↗️ (45°). There is no way for Bob to distinguish between the two possibilities with a single measurement. Therefore, Bob cannot reliably guess Alice's basis.

Alice may have an even harder job cheating. If she wants to change her basis after Bob sends his guess, she would need to know all of Bob's measurements. For example, if Alice sent qubit ➡️ (90°) and wanted to convince Bob that it was diagonal ↗️ or ↘️, Bob would measured it in the DA basis and he could have obtained 0 or 1 with 50% probability. There is no way for Alice to know which one Bob obtained. Therefore, she cannot reliably change her basis and original bits to match Bob's measurements.

Network routing

I presented the problem of sending a secret message and coin flipping over a quantum network. I could present the protocols using a simple angle representation of qubits without needing knowledge about vector spaces or matrices. However, you may notice that both protocols require a direct line to send qubits between the parties. This is rarely the case with classical networks, where messages are routed through multiple intermediate nodes, e.g., through a WiFi router, ISP, Internet backbone, or mail server. It is possible to route qubits through multiple intermediate nodes as well. The intermediate nodes would need to perform quantum teleportation to forward the qubits to the next node. This is out of scope for this post, as it requires understanding of quantum entanglement. The problem is that quantum teleportation requires transferring classical bits that hold certain information about the qubit being teleported. I suspect that this information could leak some details about the qubit, which could compromise the security of the protocols.

Quantum cryptography

Thu, 22 Jan 2026 00:00:00 GMT

In the previous post, I presented some computational problems that can be solved more efficiently by quantum computers. Today, however, computers are not only used for computations but also for solving various types of problems. In fact, most computer applications today perform minimal computation and primarily store, transfer, and transform data. Are there any non-computational problems that are difficult for classical computers but can be solved efficiently by quantum computers? In following posts, I will present examples of such problems in the field of computer networks.

Qubit secret properties

Before presenting specific problems, let's examine some properties of qubits. As mentioned, a qubit is a rotation angle, which can also be represented by a unit vector.

Measuring a qubit requires specifying a basis or direction in which to measure the qubit. For example, in the picture above, the direction is specified by the x-axis and y-axis. The measurement will return either the x-axis or y-axis with certain probabilities. Thus, it is possible to observe one of two possible values. Interestingly, it is physically impossible to obtain the actual angle that represents the qubit's value. This is impossible for two reasons:

After measurement, the qubit's value collapses to either the x-axis or y-axis direction. The original value is lost, and it is not possible to perform further measurements to recover the original value.
Even if multiple measurements were possible, the angle is a real number with infinite precision. Therefore, an infinite number of measurements would be required to obtain the exact value.

This means a qubit can store a secret value that cannot be retrieved. Can this property be used to transfer secret information securely over a network?

Quantum cryptography

Consider the following problem: Alice wants to send a secret message to Bob over an insecure network. An eavesdropper, Eve, can read all messages sent over the network. How can Alice and Bob communicate securely so that Eve cannot read the secret message? This problem is typically solved by public key cryptography. Classical public key cryptography transforms the secret message using a function that is easy to compute, but whose inverse is hard to compute. A well-known example is the RSA algorithm, which relies on the difficulty of factoring large numbers. Unfortunately, this problem is easy for quantum computers, as explained in the Problems for Quantum Computing post. Therefore, the security of such cryptosystems is threatened by quantum computers. Additionally, there is no formal proof that the number factorization problem is truly hard. It is possible that future advancements in computer science may yield an efficient algorithm for classical computers, breaking the security of the cryptosystem.

Is it possible to send a secret message securely by transmitting qubits instead of classical bits? Before answering, note that public key cryptography is not used directly to send secret messages. Instead, it is used to exchange a secret key, which is then used to encrypt and decrypt actual messages using symmetric key cryptography, such as AES. The real problem is securely exchanging a secret key over an insecure network. Public key cryptography algorithms are much slower and have limitations on message size (e.g., 125 bytes). Quantum cryptography also has limitations that prevent direct use of qubits for sending secret messages.

BB84

The first quantum cryptography protocol was introduced in 1984 by Charles Bennett and Gilles Brassard, and is known as BB84. Let's start with a single bit. Alice wants to send a random secret bit (0 or 1) to Bob. She generates another random bit to specify the basis rotation: either horizontal/vertical (HV) or diagonal (DA). She then prepares a qubit according to the following table:

Secret bit	Basis bit	Qubit direction
0	0 (HV)	Horizontal (90°) ➡️
1	0 (HV)	Vertical (0°) ⬆️
0	1 (DA)	Diagonal (45°) ↗️
1	1 (DA)	Anti-diagonal (135°) ↘️

She sends the prepared qubit to Bob over the insecure network. Bob also randomly chooses a basis bit (HV or DA) and measures the received qubit using his chosen basis. If Bob's basis bit matches Alice's, he will obtain the correct secret bit with 100% probability. If the basis bits do not match, Bob will obtain either 0 or 1 with 50% probability. The following table summarizes the possible cases:

Secret bit	Alice's Basis	Qubit	Bob's Basis	Measured Bit	Probability
0	0 (HV)	➡️	0 (HV) ➡️⬆️	0	100%
0	0 (HV)	➡️	1 (DA) ↗️↘️	0 or 1	50% each
1	0 (HV)	⬆️	0 (HV) ➡️⬆️	1	100%
1	0 (HV)	⬆️	1 (DA) ↗️↘️	0 or 1	50% each
0	1 (DA)	↗️	0 (HV) ➡️⬆️	0 or 1	50% each
0	1 (DA)	↗️	1 (DA) ↗️↘️	0	100%
1	1 (DA)	↘️	0 (HV) ➡️⬆️	0 or 1	50% each
1	1 (DA)	↘️	1 (DA) ↗️↘️	1	100%

After Bob confirms his measurement, Alice sends her basis bit to Bob over the classical network. Bob compares his basis bit with Alice's. If the basis bits match, both keep the measured bit as part of the secret key. If not, they discard the measured bit. After repeating this process multiple times, Alice and Bob will have a shared secret key consisting of bits where their basis bits matched.

What if Eve intercepts and measures the qubits sent from Alice to Bob? She faces the same situation as Bob and must randomly choose a basis for measurement. For example, if Alice sends a horizontal qubit ➡️ and Eve measures it in the HV basis, she obtains the correct secret bit 0 and the qubit remains unchanged. However, if she measures it in the DA basis, she obtains either 0 or 1 with 50% probability, and the qubit changes to either diagonal ↗️ or anti-diagonal ↘️. When Eve then sends the qubit to Bob, there is a chance that Bob's measurement will not match Alice's original secret bit, even if his basis matches Alice's. This effect is explained in the experiment with three polarization filters in the Quantum computing measurement post.

After exchanging some secret bits via qubits, Alice and Bob should randomly select some bits and compare them over the classical network. If there is no Eve, all compared bits should match. If there is an eavesdropper, some bits will not match due to Eve's interference. If the number of mismatched bits exceeds a certain threshold, Alice and Bob can conclude that there is an eavesdropper and discard the entire key. Otherwise, they can use the remaining bits as their shared secret key.

Which bits to surrender and compare should be decided randomly after the key exchange to prevent Eve from predicting which bits to measure and which bits to leave untouched.

Compared to classical public key cryptography, BB84 allows exchanging secret keys of any length. If Alice and Bob want to exchange \(N\) secret bits, they must exchange approximately \(4N\) qubits: \(2N\) qubits because half the time Bob's basis will not match Alice's, and another \(2N\) qubits to surrender for eavesdropper detection. Additionally, they need to exchange \(4N\) bits over the classical network to share basis bits and another \(4N\) bits to compare the surrendered bits. This is a reasonable cost for securely exchanging secret keys of any length.

This means Alice and Bob can exchange a secret key of the same length as the message they want to send securely. They can then use one-time pad symmetric key cryptography, which is very simple and theoretically unbreakable.

Limitations

One important limitation is that the BB84 protocol requires online communication between Alice and Bob. Unlike public key cryptography, where Alice can encrypt a message and send it to Bob's mailbox for later decryption, BB84 requires both parties to be online simultaneously to exchange qubits and classical bits.

Another limitation is the need for authenticity of the classical bits. When Bob receives Alice's basis bits and the surrendered bits for comparison, he must be able to verify they are actually from Alice and not from Eve. Otherwise, Eve could impersonate Alice and send false bases and comparison bits, making it impossible for Bob to detect her presence. This problem can be solved by using classical public key cryptography to sign the classical messages. Digital signatures may be required anyway, so Bob can verify that the secret message is actually from Alice, and vice versa.

Summary

I presented the problem of sending a secret message over an insecure network. This problem is reasonably solved by public key cryptography today. However, public key cryptography is not formally proven to be secure. Using quantum communication, it is possible to exchange a secret message that is formally proven to be theoretically unbreakable.

async/await question

Thu, 15 Jan 2026 00:00:00 GMT

When interviewing a candidate, I usually ask them to tell me something about async/await as we know it in modern languages like C# or TypeScript. What does it do? Why do we use it? Most people talk about technical details and threads. Some of these details are correct, some are not. However, I have never heard anyone mention the problem that led to the inception of the async/await concept.

At university, one of the modules I studied was Parallel Algorithms. The module covered questions like, "What kind of problems can be solved more efficiently on multiple processors?" and "How can we design efficient parallel algorithms?" And the first lecture presented question: "Does the number of available processors impact the design of a parallel algorithm?" This question is very important because, when tasked with designing a parallel algorithm, we usually don't know how many processors will be available. The answer is "No." The number of processors does not impact the design of a parallel algorithm. How does that work? When designing a parallel algorithm, we split the computational work into small tasks. Unfortunately, those tasks may have dependencies on one another.

For example, consider an algorithm to sum the numbers in an array of length \(N\). The algorithm creates \(N\) tasks, and each task adds the value at a specific index to the result of the previous task, starting with the value at index 0: \(T(i) = T(i-1) + A[i]\) where \(T(0) = A[0]\). The final result is \(T(N-1)\). The problem is that each task depends on the previous one, so there are no two tasks that can run in parallel. The following image presents the tasks for an array of length 5. The arrows represent dependencies between tasks.

To take advantage of multiple processors, we need to change the dependencies between the tasks. We can do this by making the algorithm work in rounds. In the first round, each task adds two values from the array. In the second round, each task adds two values from the results of the previous round, and so on. The following image presents the tasks for an array of length 10. The arrows represent dependencies between tasks.

How does this work with a different number of processors? To run the algorithm, we need a scheduler that assigns tasks to processors. The scheduler can work quite simply: it takes tasks in order \(T(0), T(1), \ldots\) and assigns each task to the next available processor. However, a task is scheduled only after all its dependencies are finished. If there are \(N\) processors available, then there is always a processor available for each task. If there are \(m\) processors available, where \(m < N\), then the scheduler assigns the first \(m\) tasks to processors. As soon as any task is finished, it takes the next task and assigns it to the available processor. This way, we don't have to design a parallel algorithm for a specific number of processors. The scheduler maps any algorithm to the available processors.

And that is exactly what async/await frameworks do. They provide a programming language construct to split a procedure, function, or method into small tasks. The framework then implements a scheduler that assigns tasks to available processors, or technically, threads. So the framework provides an abstraction for engineers to write parallel procedures without worrying about the number of available processors.

Historically, processors used to have only a single core. At some point, this changed and multi-core processors became commercially available. There was a need for a framework to bring those multiple cores to software developers without requiring them to know how many cores the target system would have. That was the motivation for creating async/await frameworks.

Problems for Quantum Computing

Tue, 28 Oct 2025 00:00:00 GMT

In the previous post, I explained nondeterministic Turing machines and how quantum computers can simulate them for certain problems. It was mentioned that simulation is possible using Quantum Fourier Transform when solutions are periodic. In this post, I will present some examples and other use cases of quantum computing.

The previous post already mentioned an example of a problem that can be efficiently solved by a quantum computer: Order finding. This is the problem of finding the smallest integer \(r\) such that \(x^r = 1 \mod N\), where \(x\) and \(N\) are given integers. Probably the most famous application of order finding is Integer factorization. This is the problem of finding prime factors for a given integer \(N\), meaning finding prime numbers \(q_1, q_2, \ldots, q_n\) such that \(q_1 q_2 \ldots q_n = N\). There is a quantum algorithm called Shor's algorithm that can solve integer factorization efficiently by reducing it to order finding.

Another example of a problem that can be efficiently solved by a quantum computer is Discrete logarithm. This is the problem of finding an integer \(k\) such that \(g^k = x \mod p\), where \(g\), \(x\), and \(p\) are given integers, and \(p\) is prime. This problem can be solved by a modification of Shor's algorithm.

Public key cryptography

Shor's algorithm has a significant impact on information security, specifically on public key cryptography. The most common use of public key cryptography is Transport Layer Security (TLS), which is used to secure communication over the Internet. Public key cryptography solves two main problems: secure key exchange and digital signatures. Secure key exchange provides confidentiality in information security by allowing two parties to agree on a shared secret key over an insecure channel. Digital signatures provide integrity by allowing one party to sign a message in a way that anyone can verify the signature, but only the signer can create it. It means that a sender of a message cannot deny having sent the message.

Currently, the most common cryptosystems in public key cryptography are RSA and Elliptic-curve cryptography. The security of RSA is based on the assumption that integer factorization is a hard problem, and elliptic-curve cryptography assumes that the discrete logarithm is a hard problem. While it is believed that these problems are hard to solve on classical computers, Shor's algorithm solves them efficiently using quantum computers. This means that current computer systems secured by public key cryptography are vulnerable to quantum computer attacks. At the moment, quantum computers do not have enough qubits to match the key sizes used by current cryptosystems. However, it is expected that quantum computers will become powerful enough in the future.

Therefore, there is an ongoing effort to develop and standardize new cryptographic algorithms that are secure against quantum computer attacks. This field is called Post-quantum cryptography. FIPS 203 standard has been published and it specifies post-quantum cryptographic algorithms for both secure key exchange and digital signatures. These cryptosystems are based on module-lattice based problems. These problems were studied in the field of Machine Learning and are believed to be hard to solve even for quantum computers.

Period finding

Order finding is a special case of a more general problem called Period finding. This is the problem of finding the period \(r\) of a periodic function \(f(x)\) such that \(f(x) = f(x + r)\) for all \(x\). The function is given as a black box, so the only way to get its value is to call the black box with some input. The goal is to find the period \(r\) using as few calls to the black box as possible. It should be clear that order finding is a special case of period finding, where the function is defined as \(f(x) = a^x \mod N\) for a given \(a\).

Like order finding, period finding can also be solved efficiently using quantum computers. The algorithm using Quantum Fourier Transform can be generalized to achieve this.

A generalization of the period finding problem is the Hidden subgroup problem. Unfortunately, it is not known how to efficiently solve all instances of the hidden subgroup problem using quantum computers, and it is believed that some instances are hard to solve even for quantum computers. For example, Learning with errors problem can be reduced to some instances of the hidden subgroup problem, and it is believed that learning with errors is hard to solve even for quantum computers. Learning with errors is the basis of some post-quantum cryptographic algorithms, and it likely would not be considered for post-quantum cryptography if it were not believed to be hard for quantum computers.

Quantum search

In the previous post, I explained that a nondeterministic computing machine can branch its calculation into multiple paths. While classical computers have to evaluate all the paths, quantum computers can find the right path efficiently with high probability in certain cases.

There is another approach to simulation of nondeterministic computing machines using quantum computers. This approach is called quantum search and it uses Grover's algorithm. The result is not as impressive as using Quantum Fourier Transform for periodic problems, but it is still better than using classical computers. Quantum Fourier Transform reveals the right path and is equivalent to the computation of a single path. However, Grover's algorithm requires multiple runs and is equivalent to the computation of multiple paths. Specifically, it requires \(\sqrt{N}\) computations, where \(N\) is the number of all possible paths.

For example, consider the problem of finding a secret key for Advanced Encryption Standard (AES) with a key size of 256 bits. There are \(2^{256}\) possible keys, and a classical computer would have to try on average half of them, which is \(2^{255}\). A quantum computer using Grover's algorithm would require only \(\sqrt{2^{256}} = 2^{128}\) tries. So quantum computers effectively halve the size of the secret key. AES is still considered secure for post-quantum cryptography, but it is recommended to use AES with a key size of 256 bits or more.

Unfortunately, I did not find a simple illustration or analogy to present quantum search or Grover's algorithm. Books and the Wikipedia article has some geometric explanation, but that requires some knowledge of vector spaces.

Summary

While a smart way has been found to simulate some nondeterministic Turing machines efficiently using quantum computers, it is believed that quantum computers cannot simulate all nondeterministic Turing machines efficiently in general, so there are hard problems that cannot be efficiently solved by quantum computers.

So far, the biggest success in quantum computing is showing that quantum computers can efficiently find the period of a periodic function, when finding the solution using classical computers would require calculating the function for almost all possible inputs. It is possible that there are other kinds of problems that can be efficiently solved by quantum computers, but they are not known yet. As quantum computations work quite counterintuitively, it requires a lot of ingenuity to find new approaches for quantum algorithms.

Quantum Computing and Nondeterminism

Tue, 21 Oct 2025 00:00:00 GMT

Some time ago, I set out on a journey to understand "What kinds of problems can quantum computation solve efficiently?" I decided to write a series of blog posts to explain this as simply as possible. In previous posts, I discussed the qubit and measurement. In this post, I will finally answer the question. The most common answer is, "It can run computations in parallel." However, as I showed in the previous post about measurement, that is not exactly true. A quantum computer cannot simulate a computer with the enormous number of processors. However, it can simulate a different kind of machine in some special cases: the Nondeterministic Turing machine.

Nondeterministic Computing machine

I will not go into the details of Turing machines, but I need to describe nondeterminism in computing machines. A nondeterministic computing machine (my own term to avoid details of the Turing machine) is a theoretical or hypothetical machine. One perspective is that the machine can solve problems for which it is easy to verify a solution, but hard to find one. For example, it is easy to verify that an integer \(a\) divided by integer \(b\) has remainder 0, but it is hard to find such number \(b\). By "hard," I mean it takes a lot of computation steps.

A procedure for a deterministic (classical) computing machine is described as a sequence of steps. After each step, the machine is in a specific state, and the state determines the next step. For example, when iterating through a list of items, the state can be the index of the current item. If the index is less than the length of the list, the next step is to increase the index by one. Otherwise, the next step is to stop the iteration. The following image presents deterministic computation for finding the maximum number in a list. Rectangles represent computation states, and rounded rectangles represent steps. The important point is that there is always exactly one next step.

A procedure for a nondeterministic machine can have multiple next steps after each step. You can think of it as computation splitting and following multiple paths. For example, the following image presents nondeterministic computation for finding a number that divides 15 without remainder.

Problems to be solved by nondeterministic machines are usually presented as decision problems, meaning the output is either yes or no. The output is yes if any of the computation paths outputs yes. If all paths output no. then the final output is no. As mentioned, a nondeterministic computing machine is hypothetical, and there can be different actual realizations of such machine. One option is to try all computation paths one by one in sequence. However, for large inputs, there can be a huge number of computation paths. For example, if the input was a 128-bit number, there would be \(2^{128}\) possible computation paths. That is more than the estimated number of atoms in the universe. So that would take too long. Another option is to have multiple processors and try multiple paths in parallel. Parallelism should be easy, because the paths do not have any dependencies. However, it would require an enormous number of processors.

Quantum computer and nondeterminism

Can a quantum computer simulate nondeterministic computing machines efficiently? Yes, for some problems. Recall from the measurement post that multiple qubits can be in superposition of multiple states or numbers with certain probabilities before measurement. Only after the measurement do the qubits collapse to exactly one of the states. It should be possible to map nondeterministic states to quantum states. Then, a quantum computer can compute on the superposition of all nondeterministic states. The following image presents nondeterministic computation of 5 steps with 2 branches at each step, resulting in 32 possible final states. A quantum computer can follow the same computation paths and end in a superposition of 32 final states.

If each of the 32 states has approximately the same probability \(\frac{1}{32}\), then measurement will return any of the states with approximately the same probability. In this case, there are 2 yes states and 30 no states. Therefore, measurement will return yes with probability \(\frac{2}{32}\) and no with probability \(\frac{30}{32}\). So it is much more likely to output no than yes. But no is the wrong answer, because there is at least one yes path.

Can we manipulate the probabilities so that all no states have almost zero probability? If we can do that, then the quantum computer could simulate a nondeterministic computing machine efficiently with high probability.

Quantum Fourier Transform

It seems possible to achieve almost zero probability for no states when each \(k\)-th state is yes state and there are no other yes states. For example, the following image presents nondeterministic computation where every 5th path outputs yes.

An example of such a problem is Order finding. This is the problem of finding the smallest integer \(r\) such that \(x^r = 1 \mod N\), where \(x\) and \(N\) are given integers. It is easy to verify the solution, but hard to find it. However, the yes states are periodic, occurring at positions \(0, r, 2r, 3r, \ldots\).

If this condition is satisfied, then we can use a method called the Quantum Fourier Transform. I will explain how the method works using a simplified example. You may be familiar with alternating current, which is the electricity available in wall sockets in every household. The voltage of alternating current changes periodically and can be represented as a sine wave.

While there are only 2 wires going to the wall socket, there are 6 wires coming to each household. This is because the electricity provider generates 3 alternating currents, each with the same frequency but shifted by 120° or \(\frac{2\pi}{3}\). This is called 3-phase alternating current. The following image shows 3 sine waves representing the 3 phases of alternating current.

The phase functions are:

\[ f_1(x) = \sin x \]

\[ f_2(x) = \sin \left(x - \frac{2\pi}{3}\right) \]

\[ f_3(x) = \sin \left(x + \frac{2\pi}{3}\right) \]

Notice that

\[ f_1(x) + f_2(x) + f_3(x) = 0 \]

This means that if we combine the 3 alternating currents, the result is 0. That is why it is possible to use only 4 wires for 3-phase alternating current: 3 wires can be combined into one neutral wire. I may be wrong, I am not an electrician.

Quantum Fourier Transform uses a similar trick. It combines multiple states with different phases in a way that the probability of combined states \(0, 1, \ldots, k-1\) is almost zero. That leaves states \(0, k, 2k, 3k, \ldots\) with high probability. This is exactly what we want to achieve.

An explanation of the Quantum Fourier Transform is beyond the scope of this post. As mentioned, let us consider a problem where every \(k\)-th solution is the correct one. Of course, the value of \(k\) is what we are trying to find. When we find \(k\), we know the solution to our problem. The Quantum Fourier Transform is a procedure to find \(k\).

Summary

A quantum computer can simulate a nondeterministic computing machine efficiently when yes states are periodic. Nondeterministic machines are only a theoretical construct and may be harder to imagine for people outside of computer science. They can be simulated by computers that can run computations in parallel. This is probably the reason why quantum computers are often explained as computers that can run computations in parallel. However, I find the comparison to nondeterministic machines much more insightful. Maybe it is just me, because I have not seen such explanation anywhere else.

Quantum Computing measurement

Tue, 14 Oct 2025 00:00:00 GMT

This is the second post in my journey to discover "What kinds of problems can quantum computation solve efficiently?" In the first post, I explained what a qubit is and how it can be represented. In this post, I will cover measurement in (not only) quantum mechanics. You have probably heard that when measuring a qubit, it collapses to one of the measured states and loses its actual value. This led me to some natural questions: What is the difference between measurement and any other operation? How does a qubit know it is being measured?

I already presented an example of a measurement experiment in the previous post, without explicitly mentioning it. Do you remember the experiment where we rotate two polarization filters 45° relative to each other? Only 50% of the light that passed through the first filter passes through the second filter. So what actually happens? Let us say the first polarization filter sets the polarization direction, and thus our qubit, to the blue arrow. The second filter then "measures" the qubit in the \(x\) and \(y\) axes.

What happens to the photon after passing through the second polarization filter? It changes its polarization to either the direction of the y-axis or the x-axis. The probability it is changed to the y-axis is \(\cos^2\alpha\), and the probability of changing to the x-axis is \(\sin^2\alpha\). In reality, the photon that is changed to the x-axis never passes through the filter and is destroyed. Therefore, the experiment with electron spin is more accurate, as the electron is not destroyed and the outcome is actually one or the other direction. However, photons are easier to observe by eyes.

Now it is possible to explain the experiment with three polarization filters. As mentioned, the first polarization filter sets polarization to the vertical direction, which is aligned with the y-axis. The second polarization filter measures polarization at a 45° rotation.

This second filter changes the polarization of 50% of the photons to the direction of \(y^\prime\) and the other 50% to \(x^\prime\), which does not pass through the filter. Now we have 50% of the light passing through the first filter and 50% of that passing through the second filter. That means 25% of the light passes through both filters, and all of this light has the polarization direction of the \(y^\prime\) axis. The third filter then measures again in the horizontal x-axis and vertical y-axis, similar to the first image. The outcome is that 50% of the photons reaching the third filter change polarization to the y-axis and 50% to the x-axis, which is again filtered out. Therefore, the total light passing through all three filters is 12.5%.

Multiple qubits

With classical bits of values 0 or 1, it is possible to combine them to represent other numbers or values. For example, it is possible to combine 8 bits to represent an integer between 0 and 255. Is it possible to combine multiple qubits in the same way? The answer is "yes." But do we even need it? If a qubit can be any real number between \(0\) and \(2\pi\), then it can easily represent a number from a finite set of integers. For example, an integer \(i \in \{ 0, \ldots, 255 \}\) can be represented by a qubit as

\[ i \rightarrow \frac{i}{256} \cdot 2\pi \]

Interestingly, a similar approach is used in classical computing. Most people say that computers communicate in 0s and 1s. However, that is not exactly true, although it is the best abstraction of the communication signal. While 0s (low voltage) and 1s (high voltage) are commonly used in processors and memory units (likely because it works well with transistors), network communication over cable or air uses more complicated encoding. Just like a qubit value, voltage can also be any real number. So it is possible to use multiple voltage levels to represent more numbers than just 0 and 1. This is especially important in communication. If the communication is at a certain frequency, e.g., 1 kHz, then it would be possible to transmit a maximum of 1000 bits per second with 2 levels. But introducing multiple energy/voltage levels increases the number of bits transmitted per second.

Why do we not use the same approach with qubits? The first reason is similar to classical computing: there are limited operations we can perform with a single qubit. It is possible to add numbers and perform reflections, but it is not possible to perform multiplications. The second reason is the limitation of measurement. As mentioned above, a measurement of a single qubit can yield one of two possible outcomes, and not an explicit value from a set of multiple integers.

Schrödinger's cat

We have shown that a qubit measurement aligns the qubit with either the x-axis or y-axis. We can assign the value 0 to the x-axis and 1 to the y-axis. Thus, it is possible to think of a qubit as something between 0 and 1, and measurement reveals exactly one of the values 0 or 1.

Many people are probably familiar with the Schrödinger's cat thought experiment, thanks to The Big Bang Theory sitcom. The thought experiment describes a cat in a box with poison. It is not possible to know if it is dead or alive without opening the box. The idea is to consider the cat both dead and alive at the same time before opening the box.

The same perception can be applied to a qubit. Instead of considering it as something between 0 and 1, we can consider that a qubit is both 0 and 1, each with a certain probability. This property of a qubit is called superposition of 0 and 1. This is another reason to combine multiple qubits. If we have 2 qubits, each in superposition of 0 and 1, then those 2 qubits are in superposition of values 0, 1, 2, 3. In general, \(n\) qubits can be in superposition of numbers \(0 \ldots 2^n-1\). This is the reason why it is often explained that quantum computers can run computations in parallel. The problem, however, is that measurement always reveals only a single number. When running the same computation multiple times, the measurement reveals a different number each time. Therefore, I find the statement "quantum computers can run operations in parallel" a bit misleading.

Superposition is also the reason that a qubit is usually represented by a two-dimensional vector, instead of just a single angle. There is also a natural way to combine two-dimensional vectors into multi-dimensional vectors, so they can represent the superposition of multiple qubits.

What is measurement?

Quantum mechanics describes measurement of a single qubit as a set of two operations on the qubit, where exactly one operation is chosen with a certain probability and that is applied. The difference from a regular qubit operation is that measurement is not a reversible operation. This partially answers the question, "How does the qubit know it is being measured?" or "What is the difference between measurement and a regular operation?" However, that still does not explain how it works.

The book Quantum Computation and Quantum Information provided me with valuable insight into this. I realized it has connections outside of quantum mechanics. There is Goodhart's Law: "When a measure becomes a target, it ceases to be a good measure." For example, when unit test code coverage is being measured, code coverage may become more important than code quality. So a measurement always impacts the system being measured. In some cases, the impact is significant, such as with the unit test code coverage metric. In other cases, the impact is negligible. For example, a car speedometer has almost no impact on the speed of the car, but it is still a non-zero impact. It is always a bit of an art, requiring a lot of experience, to design measurements that have minimal impact on the measured system. It is likely almost impossible in the quantum world, which is so small that even the introduction of a small system change required for measurement probably has a large impact. It is like a variation of the 3rd Newton's law: For every action, there is some reaction.

Interestingly, quantum mechanics explains this very well. By measuring, we are usually adding something to the quantum system. For example, measuring a photon may require an electron that produces electric current when hit by the photon. So we can consider that a quantum system with measurement is like a system with additional qubit(s). When we combine possible measurement outcomes with changes on the added qubit(s), the combined operation is actually a regular operation that is revertible and does not seem counterintuitive.

It is extraordinary how something negligible in larger systems can explain the counterintuitive behavior of quantum measurement.

Quantum Computing - qubit

Tue, 07 Oct 2025 00:00:00 GMT

When I asked the question, "What makes quantum computation more powerful?" or "What kinds of problems can quantum computation solve efficiently?", the usual answer was, "It can run computations in parallel." While this is perhaps the most accurate single-sentence answer, I find it both inaccurate and misleading. A few years ago, I began my journey studying quantum computing. My background is in computer science, so my main interest was to understand the problem space that can be solved more efficiently by quantum computation. I did not study physics beyond high school, and my goal was not to delve deeply into quantum physics. In the next few blog posts, I will attempt to provide a better explanation to the question, "What kinds of problems can quantum computation solve efficiently?"

I began my self-study of quantum computing with the book Quantum Computing for Everyone by Chris Bernhardt. The book is a good, light introduction. It covers quantum states and quantum operations. However, it did not provide the insight I was seeking. Then I found another book, Quantum Computation and Quantum Information by Michael A. Nielsen and Isaac L. Chuang. This book was exactly what I needed to gain the insights I was looking for.

Qubit

In this first blog post, I will discuss the qubit. The first book explained it quite well using a physical experiment with electron spin. I will use a different experiment with photons for explanation. Advantage of the photons experiment is that you can try it yourself with some inexpensive polarization filters. When you look through a polarization filter, it filters part of the light (some photons). The actual filtered amount depends on the source of light and the environment, but for simplicity, let's say it filters 50% of the light (50% of the photons). When you place the same polarization filter behind the first one, it does not filter any additional light. However, when you rotate that filter by 90°, the scene becomes black and all light is filtered. When you rotate the filter only 45°, then 50% of the light that passed through the first filter is filtered. The effect is shown in the following images.

A very surprising part of the experiment is to rotate the second filter by 90°. That makes the scene black. Then, try inserting another polarization filter between the two and rotate it 45°. The surprising result is that it passes 25% of the light through. This is counterintuitive, because by adding the additional filter, less light is filtered and more photons pass through.

Let us return to the two-filter scenario. In this case, the more you rotate the filters toward 90°, the more photons are filtered and the scene becomes darker. The more you rotate toward 0°, the more photons pass through and the scene becomes lighter. The angle between the filters determines how much light is passed through and how much is filtered. That angle represents the qubit.

How does this work? The experiment with electron spin would be physically more accurate, but I will continue with photons, even though it is not strictly correct. The first filter allows only photons polarized in a certain direction to pass through. Recall the saying, "There is no up in space." That is what the second filter does: it defines where the "up" direction is. The following image should clarify this.

The blue arrow is the direction of polarization set by the first filter. The \(x\) and \(y\) axes represent the direction of the second filter. It is important to realize that it is possible to rotate the first filter, which means rotating the blue arrow in the \(x\), \(y\) coordinates. Alternatively, it is possible to rotate the second filter, which means rotating the \(x\) and \(y\) axes around the blue arrow. The result is the same, because the final amount of light passed through depends on the angle \(\alpha\).

The angle \(\alpha\) is significant. It determines how much light is passed through and how much is filtered. The probability that a photon passes through the second filter is \(\cos^2\alpha\). The probability that a photon is filtered out is \(\sin^2\alpha\). Note that \(\cos^2\alpha + \sin^2\alpha = 1\) by Pythagorean theorem. Thus, it is certain that a photon is either filtered or passed through. The amount of light passed through is \(\cos^2\alpha\).

For example, when the filter is rotated 30°, then \(\alpha = \frac{\pi}{6}\) and the probability of a photon passing through is

\[ \cos^2\frac{\pi}{6} = \left(\frac{\sqrt{3}}{2}\right)^2 = \frac{3}{4} \]

A qubit can be represented as a real number between \(0\) and \(2\pi\) (0° to 360°). This means that a qubit can have an infinite number of values, compared to a bit, which can have only two (0 or 1). Notice that the value can be greater than \(\pi\), and thus \(\sin\alpha\) and \(\cos\alpha\) can be negative. However, the probabilities of passing and filtering (\(\cos^2\alpha\) and \(\sin^2\alpha\)) are always positive numbers between 0 and 1.

Qubit operations

Now the question is: what kinds of operations can be performed on a qubit? An important rule in quantum mechanics is that it should be possible to revert the operation. There are two types of operations that allow reverting. The first is rotation. This means adding any constant angle to a qubit. For example, the following image shows a qubit rotated by angle \(\gamma\). In other words, it adds a constant \(\gamma\) to qubit \(\alpha\).

It should be clear that the operation can be reverted by subtracting the same angle.

The second type of operation is reflection. This means reflecting the direction line by another given direction line. For example, the following images present reflection by the y-axis, x-axis, and the diagonal line.

The revert operation is even simpler: repeating the same operation returns the qubit to its original state.

What kinds of operations cannot be reverted? For example, consider the conditional operation:

\[ f(x) = \begin{cases} x+\pi, & \text{if } x<\pi\\ x, & \text{otherwise} \end{cases} \]

The problem is that it is not possible to revert the value \(\frac{3}{2}\pi\), because

\[ f\left(\frac{3}{2}\pi\right) = f\left(\frac{\pi}{2}\right) = \frac{3}{2}\pi \]

So there would be two possible results for the revert operation.

Even simple multiplication of the angle by a constant is not revertible. For example, multiplication by 2 cannot be reverted either.

\[ 2\cdot\frac{\pi}{4} = 2\cdot\frac{5}{2}\pi = \frac{\pi}{2} \]

in the space of values between \(0\) and \(2\pi\).

Vectors

I used the angle representation of a qubit because it is very illustrative. However, the usual representation of a qubit is as a two-dimensional vector. That is, a tuple of two values, specifically \((\sin\alpha, \cos\alpha)\). In the previous image, we presented the qubit as an arrow showing direction. However, the arrow shows only the direction; it does not have any significant length. So we can standardize all arrows to the same length of a single unit. Thus, a qubit can be represented by a point on the unit circle. The coordinates of such point are \((\sin\alpha, \cos\alpha)\). That is the vector.

The vector representation of a qubit is very useful when combining multiple qubits. I will discuss that in the next post. I will try to avoid vectors as much as possible, as my goal is to explain quantum computing using elementary math.

3-dimensional space

The first book, "Quantum Computing for Everyone," explains the qubit as a direction in two-dimensional space. An advantage of this approach is its ease of illustration. However, we live in three-dimensional space, and thus a qubit is actually a direction in three-dimensional space. So we can think of it as a point on the unit sphere, instead of the circle. This point can be represented in different forms:

Three-dimensional coordinates \((x, y, z)\)
Two angles known as polar coordinates - you can think of these as GPS coordinates for points on Earth.
Two-dimensional vector of complex numbers \(C^2\)

As you might expect, the most common representation of a qubit is the last one: a vector in \(C^2\). Three-dimensional space also means that there are more possibilities for rotations and reflections, and thus more complex qubit operations.

Window icon in WinUI 3

Sun, 27 Apr 2025 00:00:00 GMT

When developing a Windows application using WinUI 3, by default it displays default Windows icon in taskbar: Changing this icon is a little bit more complicated than in other .NET UI frameworks. In WinForms and WPF Window class has Icon property. And these frameworks have classes to work with icon objects. Universal Windows Platform application doesn't have window under control and the platform automatically sets the icon from application assets.

Program icon

In Windows every executable file can have a custom icon. That is the icon that you can see in Windows Explorer, when an executable file is listed. In .NET applications this is set the same way, no matter if the application is WinUI, WinForms, or even console application. Simply add an icon (e.g. MyApp.ico) to your .NET project and add ApplicationIcon element to the project file. For example:

<PropertyGroup>
  <ApplicationIcon>MyApp.ico</ApplicationIcon>
</PropertyGroup>

This is the first step to setup your application icon. When the application is compiled, then you can see the icon in Windows Explorer. However, running the application would still display the system icon in Windows taskbar. Except in WPF that by default displays the application icon for all windows.

Loading icon from a file

In WinUI 3 the Window class has AppWindow property that allows system specific customization of the application window. And AppWindow class has SetIcon method that can be used to setup icon of the window. The method has 2 overloads. The first overload accepts a path to .ico file.

So the first option is to include the .ico file in the published application folder and load it from there. This can be done by adding Content in the .csproj file. For example:

<ItemGroup>
  <Content Include="MyApp.ico" />
</ItemGroup>

And then setting up the icon in constructor of the window.

public sealed partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        string iconPath = System.IO.Path.Combine(Package.Current.InstalledLocation.Path, "MyApp.ico");
        AppWindow.SetIcon(iconPath);
    }
}

This solution has desired effect of displaying correct icon in Windows taskbar. However, it is unusual to include .ico file in the application folder and having dependency on it. Therefore, the next step is to include the icon directly in the executable.

Loading icon from a resource

Including icon in the executable file was done in the first step using ApplicationIcon element. The problem is, how to load it into the Window object? And for that there is second SetIcon method overload that accepts IconId type. We need some Win32 API to get the IconId value. This is full class with GetApplicationIconId method to get the IconId value that can be passed to SetIcon method.

public static class IconService
{
    public static IconId GetApplicationIconId()
    {
        // Application resource ID assigned by Visual Studio to .NET applications
        // https://devblogs.microsoft.com/oldnewthing/20250423-00/?p=111106
        IntPtr iconResourceId = new(32512);

        IntPtr hModule = NativeMethods.GetModuleHandle(null);
        if (hModule == IntPtr.Zero)
        {
            return default;
        }

        IntPtr hIcon = NativeMethods.LoadIcon(hModule, iconResourceId);
        if (hIcon == IntPtr.Zero)
        {
            return default;
        }

        return Win32Interop.GetIconIdFromIcon(hIcon);
    }

    private static class NativeMethods
    {
        [DllImport("kernel32.dll", EntryPoint = "GetModuleHandle", CharSet = CharSet.Unicode)]
        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
        public static extern IntPtr GetModuleHandle(string? lpModuleName);

        [DllImport("user32.dll", EntryPoint = "LoadIconW")]
        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
        public static extern IntPtr LoadIcon(IntPtr hModule, IntPtr lpIconName);
    }
}

The main function used here is LoadIcon that returns Icon handle. The first parameter of the function is handle of the module that the icon should be loaded from. If it is NULL (IntPtr.Zero) then the function loads Windows system icon and not your custom application icon. Therefore, it is necessary to call function GetModuleHandle to get handle of the module representing the executable file.

Calling GetModuleHandle is simple. It is sufficient to pass null. That returns handle of the module that started execution of the current process. And that is likely your executable file.

The second parameter of the LoadIcon function is more tricky. By definition, it is LPCWSTR and that is string pointer. Notice, however, that we declared it as IntPtr and not string. Resources (e.g. icons, strings, images) in modules (.exe or .dll files) can be accessed by name or by index. And LoadIcon function accepts both. When the value of second parameter is lower than 65536, then it is considered as a resource index and icon with the specified index is loaded. Otherwise, it is considered as a string pointer and icon with the specified resource name is loaded.

We want to use the resource index, therefore the function is declared with IntPtr type and not string. Specifically, we use fixed index value 32512. According to What resource ID should I give my application’s main icon?, Visual Studio assigns this specific index to the application icon. You can also verify that by opening the compiled executable file in Visual Studio. This displays all resources in the executable file.

Last part of this method uses Win32Interop.GetIconIdFromIcon to convert the icon handle to IconId. Notice that after each Win32 API call, the method checks if the result is non-zero. When it is zero, then Win32 function failed, so the method returns default IconId.

Last step is to set the icon in Window class constructor. Btw, the default (or empty) IconId value, would instruct WinUI to use default system icon.

public sealed partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        AppWindow.SetIcon(IconService.GetApplicationIconId());
    }
}

Note: This example has only single application window. When the window is closed, the whole application is closed. So the icon is loaded only once and it is never released using DestroyIcon function, because it is needed for entire application lifetime.