💻 computer science

A Survey on Complexity Measures of Pseudo-Random Sequences

This survey reviews four decades of research on various complexity measures for assessing the randomness of pseudo-random sequences, including linear, quadratic, and maximum-order complexities, and explores their relationships with other metrics like Lempel-Ziv, expansion, 2-adic, and correlation measures.

Original authors: Chunlei Li

Published 2026-04-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Chunlei Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a secure vault for your most valuable secrets. To do this, you need a master key that looks completely random—so random that no one can guess the next number in the sequence. This is the world of cryptography, and the "randomness" of these keys is everything.

This paper is a survey report written by Chunlei Li, a researcher from the University of Bergen. It's like a comprehensive guidebook that reviews the last 40 years of research on how to measure just how "random" a sequence of numbers (bits) really is.

Here is the breakdown of the paper using simple analogies:

1. The Problem: The Fake Randomness

In the digital world, computers aren't naturally random. They are like very fast, very predictable robots. If you tell a robot to "pick a number," it will always pick the same one if you start it the same way.

To make them act random, we use Pseudo-Random Bit Generators (PRBGs). Think of these as "randomness machines."

The Goal: The machine should produce a stream of bits (0s and 1s) that looks exactly like a coin flip.
The Danger: If the machine is too predictable, a hacker can figure out the pattern, guess the next bit, and break your encryption.

2. The Solution: Measuring "Complexity"

How do we know if a sequence is truly random or just a clever trick? We need a Complexity Meter. The paper reviews different types of meters used to test these sequences.

Think of a sequence of numbers as a recipe.

Low Complexity: The recipe is simple. "Add 1, then add 1, then add 1." (e.g., 1, 2, 3, 4...). Anyone can guess the next number. This is bad for security.
High Complexity: The recipe is a 50-page novel with no pattern. You have to read the whole thing to understand it, and you can't guess the next word without knowing the previous ones. This is good for security.

The paper focuses on three main types of "Complexity Meters":

A. Linear Complexity (The Simplest Test)

Imagine you are trying to predict the next number in a line of people.

The Test: Can you predict the next person just by looking at the immediate previous people in a straight line?
The Tool: This uses a Linear Feedback Shift Register (LFSR). Think of this as a simple machine with a few gears. If the gears are small, the machine is easy to reverse-engineer.
The Verdict: If the machine needed to generate the sequence is small, the sequence is weak. If it needs a huge machine, it's strong. This is the most famous test and is used in standard security checks.

B. Quadratic Complexity (The "Slightly Complicated" Test)

Sometimes, a sequence looks random to the simple machine but has a hidden pattern that requires a slightly more complex machine to crack.

The Test: Instead of just adding numbers, the machine is allowed to multiply them too. It's like upgrading from a basic calculator to a scientific one.
The Verdict: If a sequence can be generated by a machine that does simple math (multiplication included), it's still not random enough for high-security needs.

C. Maximum-Order Complexity (The "Ultimate" Test)

This is the hardest test. It asks: "What is the absolute smallest machine, of any kind (no matter how weird the math is), that can produce this sequence?"

The Test: Imagine a detective trying to find the shortest set of instructions to recreate a crime scene.
The Twist: The paper notes a funny paradox: A sequence can be mathematically complex (hard to generate) but statistically terrible (not random at all).
- Analogy: Imagine a sequence that is 0, 0, 0, 0, 0, 1. It is very hard to generate because the machine has to remember to output five zeros and then a one. But it's obviously not random because it's just zeros!
- The Lesson: High complexity doesn't always mean good randomness. You need a mix of high complexity and good statistical behavior (like having an equal number of 0s and 1s).

3. The "Other" Meters

The paper also mentions other ways to measure randomness, comparing them to the main three:

Lempel-Ziv Complexity: This is like a compression test. If you can zip up a file and make it tiny, the file had a lot of patterns (low randomness). If the file stays huge after zipping, it's very random.
2-adic Complexity: This is a specialized test for machines that handle "carries" (like when you add 1 to 9 and get 10). It's a different flavor of math but checks the same thing.
Correlation Measures: This checks if the sequence has any "echoes." If you see a pattern repeat itself with a slight delay, the sequence is weak.

4. What Did the Author Find?

Chunlei Li summarizes that:

Linear Complexity is the best understood. We know how to calculate it, how to build sequences with high complexity, and how to test them.
Maximum-Order Complexity is getting there. We have good algorithms to calculate it, but the math is tricky.
Quadratic Complexity and others are still a bit of a mystery. We have some tools, but we don't fully understand the "statistical behavior" (how they act on average) yet.

The Big Takeaway

Building a secure encryption key is like building a maze.

Linear Complexity checks if the maze has a simple, straight path.
Quadratic/Maximum-Order Complexity checks if there are hidden loops or secret tunnels.

The paper tells us that while we are getting better at designing mazes that are hard to solve (high complexity), we still need more research to ensure those mazes don't have obvious dead ends or boring patterns (statistical flaws).

In short: This paper is a map of the "Randomness Landscape," showing us which tools we have to measure security, which tools are rusty, and where we need to build new bridges for the future of cryptography.

1. Problem Statement

The paper addresses the fundamental challenge of evaluating the randomness of pseudo-random sequences (PRS) generated by Pseudo-Random Bit Generators (PRBGs), which are critical for cryptographic applications (e.g., encryption keys, nonces).

The Core Issue: While ideal randomness requires indistinguishability from a uniform source, real-world generators often rely on deterministic algorithms (like Feedback Shift Registers - FSRs). If a sequence has low "complexity," it can be predicted or reconstructed from a short observation, leading to security failures.
The Gap: Although Linear Complexity is well-understood and standardized (e.g., in NIST tests), other non-linear complexity measures (Quadratic, Maximum-Order, 2-adic, etc.) and their interrelations remain less explored, particularly regarding their statistical behavior and theoretical bounds for periodic sequences.

2. Methodology

The author employs a comprehensive literature review and theoretical analysis approach, focusing on:

FSR Models: Analyzing sequences generated by Linear FSRs (LFSRs), Quadratic FSRs, and general non-linear FSRs.
Algebraic & Algorithmic Tools: Utilizing tools such as the Berlekamp-Massey algorithm, continued fractions, discrete Fourier transforms (DFT), generalized DFT, and the theory of Direct Acyclic Word Graphs (DAWG).
Statistical Analysis: Examining the expected values, variances, and distribution profiles of complexity measures for random sequences.
Comparative Analysis: Establishing mathematical inequalities and relationships between different complexity metrics (e.g., Linear vs. Quadratic vs. Maximum-Order).

3. Key Contributions and Technical Results

A. Linear Complexity (LC)

Definition: The length of the shortest LFSR generating a sequence.
Statistical Behavior: For random binary sequences of length $n$ , the expected LC is $\approx n/2$ . The paper reviews Rueppel's and Niederreiter's work showing that for random sequences, $L_n(s) = n/2 + O(\log n)$ .
Periodic Sequences: For $n$ -periodic sequences, LC is determined via the Günther-Blahut theorem using the Generalized Discrete Fourier Transform (GDFT). The paper details the expected LC for periodic sequences, noting it is generally higher than $n/2$ (often close to $n$ ) depending on the cyclotomic cosets of the period.
Perfect Sequences: Discusses $d$ -perfect sequences where the LC profile stays close to $n/2$ for all shifts, a crucial property for keystreams.

B. Quadratic Complexity (QC)

Definition: The length of the shortest FSR with a quadratic feedback function.
Computation: The paper details algorithms (Rizomiliotis et al.) that solve a system of linear equations $M(n,m)F(m) = E(n,m)$ to determine QC. It highlights a recursive algorithm similar to Berlekamp-Massey but dependent on matrix rank calculations.
Statistical Behavior: Unlike LC, there are no rigorous theoretical results for the statistical behavior of QC. The paper presents Conjecture 2 (Youssef & Gong) suggesting the expected QC for random sequences is $\approx \sqrt{2n}$ .
Security Implication: If a sequence has low QC, the feedback function can be uniquely determined after observing $O(m^2)$ bits, making it insecure.

C. Maximum-Order Complexity (MOC) / Non-linear Complexity

Definition: The length of the shortest FSR (with any non-linear feedback) generating the sequence.
Computation: The paper reviews two main approaches:
1. DAWG Method: Relates MOC to the depth of a Direct Acyclic Word Graph.
2. Recursive/Algebraic Method: Uses eigenwords and recursive updates of feedback functions (similar to Berlekamp-Massey). The average complexity is $O(n^2 \log n)$ .
Statistical Behavior: For random sequences, $E[M_n(s)] \approx 2 \log_q(n)$ .
High Complexity Sequences: The paper characterizes sequences with the maximum possible complexity ( $n-1$ ). Surprisingly, these sequences (e.g., $00\dots01$ ) have strong recursive structures and poor statistical properties (lack of balance), making them unsuitable for cryptography despite high complexity.
Periodic Sequences: Theorem 10 provides necessary and sufficient conditions for an $n$ -periodic sequence to have MOC $n-1$ , revealing a recursive structure derived from the Euclidean algorithm.

D. Relations Between Complexity Measures

The paper establishes a hierarchy and interrelations:

Inequality Chain: $M_n(s) \le Q_n(s) \le L_n(s) \le n$ .
2-adic Complexity: The MOC of a binary sequence is upper-bounded by its 2-adic complexity.
Lempel-Ziv (LZ) Complexity: Connected to MOC via the "eigenvalue profile" (number of distinct subsequences).
Expansion Complexity: Related to the degree of polynomials annihilating the sequence.
Correlation Measures: Bounds are provided linking Linear/MOC to $k$ -order correlation measures. High correlation implies lower complexity.

4. Key Results and Open Problems

DeBruijn Sequences: The paper discusses the linear complexity of DeBruijn sequences (bounded between $2^{m-1}+m$ and $2^m-1$ ) and proposes Conjecture 3 regarding the existence of sequences with specific minimal polynomials.
Quadratic Complexity of DeBruijn: Confirms that for order $m \ge 3$ , $Q(s) \le 2^m - \binom{m}{2} - 1$ .
Open Problems Proposed:
1. Characterize all $n$ -periodic sequences with the largest quadratic complexity ( $n-1$ ).
2. Establish lower bounds on the $k$ -error maximum-order complexity for sequences with maximal MOC.

5. Significance

Cryptographic Security: The survey clarifies that high complexity does not automatically imply good randomness. Sequences with maximal MOC often fail statistical tests (balance, run properties) due to their recursive structure. Conversely, sequences with low complexity are easily broken.
Standardization: It reinforces the importance of Linear Complexity in NIST tests while highlighting the need for better understanding of non-linear measures (MOC, QC) to prevent future cryptographic failures.
Research Direction: The paper identifies that while Linear Complexity is well-matured, Quadratic and Maximum-Order complexities lack rigorous statistical theories. It calls for new algebraic tools and theoretical frameworks to analyze these non-linear measures, particularly for periodic sequences used in stream ciphers.

In summary, this paper serves as a critical bridge between the well-established theory of linear complexity and the more complex, less understood realm of non-linear sequence analysis, providing a roadmap for future research in cryptographic sequence design.