Duracellko.NET

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.

Round-lot validation (part 4)

Wed, 21 Aug 2024 00:00:00 GMT

In my previous blog post I was writing about round-lot validation on data type decimal in .NET. I presented that the implementation using simple division of the numbers does not return any false-negatives. It means that the function never returns false, when a value fits into a round lot. However, it can return false-positives. It means that the function may return true, when the value doesn't fit into the round-lot. I also presented a small update to mitigate false-positives, but we didn't eliminate them completely.

In this blog post I will show, how to eliminate false-positives using BigInteger. The function may not be that useful by itself. If your application is concerned about false-positive scenarios, then it is likely that decimal data type is not the right one for your values. Therefore, we will have look at another data type. And that is the goal of this blog post.

False-positive

Let's have a look at an example that gives false-positive scenario. False positive happens, (not only) when \(\left| \frac{u+1}{c} - \frac{u}{c} \right| \leq 10^{-29}\). It means, when a small change of the value divided by round-lot changes only at 29th decimal digit. Precision of this operation is lost, because decimal type can store at most 28 digits. Following example presents numbers that are problematic:

Round-lot: 1.0000000000000000000000000001
Value: 20000000000000000000000000002 - does fit into the round-lot and the validation function returns true.
Value: 20000000000000000000000000003 - does not fit into the round-lot, but the validation function returns true.

Let's have a look at the format of decimal data type again. A decimal number has format \(d = s 10^{-e}\). Then dividing of numbers \(u\) and \(c\) is

\[ \frac{u}{c} = \frac{s_u 10^{-e_u}}{s_c 10^{-e_c}} \]

In special case, when \(e_u = e_c\), then

\[ \frac{u}{c} = \frac{s_u 10^{-e}}{s_c 10^{-e}} = \frac{s_u}{s_c} \]

And both \(s_u\) and \(s_c\) are integers, so the validation function should return true if, and only if

\[ 0 \equiv s_u \pmod{s_c} \]

Is it possible to use the same exponent for both numbers all the time? Yes, it is. Let's say:

\[ e_{max} = \max(e_u, e_c) \]

Then

\[ \frac{u}{c} = \frac{u 10^{e_{max}}}{c 10^{e_{max}}} \]

It should be clear that both \(u 10^{e_{max}}\) and \(c 10^{e_{max}}\) are integers, because \(e_{max}-e_u \geq 0\) and \(e_{max}-e_c \geq 0\). Therefore, our validation function can check if

\[ 0 \equiv u 10^{e_{max}} \pmod{c 10^{e_{max}}} \]

Or more explicitly

\[ 0 \equiv s_u 10^{e_{max}-e_u} \pmod{s_c 10^{e_{max}-e_c}} \]

Unfortunately, multiplying numbers \(u\) or \(c\) by a number higher than 1 may not fit into the decimal data type. But it should fit into BigInteger.

Big integer

BigInteger data type can store an unlimited integer value. Well, there are probably some limitations, but we are definitely not going to hit them. So let's get straight to the implementation.

At first we need 2 helper functions. The first function extracts significand (the integer part) of the decimal data type and returns BigInteger. Decimal type has GetBits function that returns 4 integers. The first 3 integers are low, medium and high 32 bits of the 96-bit integer significand. As the first integer is low, then it means that the 96-bit integer is stored in Little-endian. The function to extract significand out of decimal is:

private static BigInteger GetDecimalSignificand(decimal value)
{
    Span<int> decimalBits = stackalloc int[4];
    decimal.GetBits(value, decimalBits);

    Span<byte> bits = stackalloc byte[12];
    BinaryPrimitives.WriteInt32LittleEndian(bits, decimalBits[0]);
    BinaryPrimitives.WriteInt32LittleEndian(bits.Slice(4), decimalBits[1]);
    BinaryPrimitives.WriteInt32LittleEndian(bits.Slice(8), decimalBits[2]);

    return new BigInteger(bits, isUnsigned: true, isBigEndian: false);
}

The function treats the significand as unsigned integer. It is, because sign of the decimal number is not included in those 96 bits. Also our round-lot validation function does not care if the number is positive or negative, so we don't have to take care of the sign bit.

Next function extracts exponent of the decimal type, of course. The exponent is stored in bits 16 to 23 of the last integer returned by GetBits function. So the extracting function is following:

private static int GetDecimalExponent(decimal value)
{
    Span<int> decimalBits = stackalloc int[4];
    decimal.GetBits(value, decimalBits);
    return (decimalBits[3] >> 16) & 0x1F;
}

Then the round-lot validation function is simple. It calculates \(e_{max}\) and then checks if

\[ 0 \equiv s_u 10^{e_{max}-e_u} \pmod{s_c 10^{e_{max}-e_c}} \]

private static bool IsValidRoundLot(decimal value, decimal roundLot)
{
    value = Math.Abs(value);
    roundLot = Math.Abs(roundLot);

    if (value < roundLot)
    {
        return false;
    }

    var bigValue = GetDecimalSignificand(value);
    var bigRoundLot = GetDecimalSignificand(roundLot);
    var valueExponent = GetDecimalExponent(value);
    var roundLotExponent = GetDecimalExponent(roundLot);

    var maxExponent = Math.Max(valueExponent, roundLotExponent);
    bigValue *= BigInteger.Pow(10, maxExponent - valueExponent);
    bigRoundLot *= BigInteger.Pow(10, maxExponent - roundLotExponent);

    return bigValue % bigRoundLot == 0;
}

Conclusion

This blog post presented, how to convert decimal data type to BigInteger and how it can be used to do exact round-lot validation. And this conversion can be used in much more scenarios than just validation function.