Memoryless Generators: Concepts Across Domains

• Memoryless generators are constructions that compute outputs solely based on the current input without relying on past data, applicable across signal processing, computation, and control.
• They enable efficient methods such as neural network-inspired nonlinear linearizers and in-place function generation, reducing hardware complexity and storage requirements.
• Their use spans randomness emulation, constrained encoding, and strategic control, highlighting the trade-offs between memory usage and optimal resource allocation.

“Memoryless generator” (Editor’s term) designates a heterogeneous class of constructions in which generation, correction, control, or encoding is performed without dependence on past inputs, past outputs, or internal trajectory history. In analog-to-digital interfaces this appears as a static nonlinear map $y(n)=g(v(n))$ applied independently to each sample; in procedural computation it denotes in-place synthesis of functions by one-coordinate updates without auxiliary storage; in games and controller synthesis it denotes positional strategies or concretizations depending only on the current state; and in stochastic modeling it marks the contrast between truly i.i.d. sources and deterministic procedures that only imitate such behavior (Linares et al., 2023, Gadouleau et al., 2011, Calbert et al., 2024, Kiefer et al., 2024).

1. Conceptual scope

Across the cited literature, “memoryless” is not tied to one discipline-specific formalism. In all cases, however, it excludes dependence on a stored past. For a static nonlinear map, that means the current output depends only on the current sample. For a strategy or controller, it means the current action depends only on the current state or observation. For a program, it means computation proceeds without auxiliary storage beyond the registers currently being updated. For a source model, it means independence across time.

Domain	Memoryless meaning	Representative form
Static nonlinear mapping	Output depends only on the current sample	$y(n)=g(v(n))$
Procedural computation	One variable updated at a time, no extra buffer	$y_i \gets g_i(y)$
Graph games	Positional strategy depends only on the current state	$\sigma:Q_1\to Q$
Controller concretization	Concrete control uses only the current concrete state	$$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$
Episodic POMDP control	Policy depends only on the current observation	$\pi_t(a|o)$

A common misconception is that memorylessness implies linearity, determinism, or absence of any state variable whatsoever. The low-complexity analog-to-digital linearizer is explicitly memoryless but nonlinear; the MRNG is deterministic and reproducible yet does not establish memorylessness in the probabilistic sense; off-chip bus encoders may be stateful through a clock and still be memoryless because they do not depend on previously transmitted codewords; and memoryless quantum protocols may manipulate a full quantum message state while forbidding private quantum workspace (Linares et al., 2023, Skliar et al., 2012, 0712.2640, Chailloux et al., 2017).

2. Static nonlinear generators in signal processing

One of the most literal uses of the idea is the memoryless nonlinear function generator used for digital post-correction of analog front-end distortion. In the analog-to-digital-interface setting, the distorted sampled signal is modeled as a memoryless polynomial function of the desired input,

$v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$

so each output sample depends only on the current input sample. The conventional benchmark is a parallel memoryless Hammerstein-type post-linearizer,

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$

while the proposed architecture replaces polynomial powers by shifted absolute-value or ReLU-like branches,

$$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$

with $f_m(v)=|v|$ or $y(n)=g(v(n))$0 and branch biases uniformly distributed between $y(n)=g(v(n))$1 and $y(n)=g(v(n))$2 (Linares et al., 2023).

This architecture is neural-network-inspired in form but not in training procedure. It has a single scalar input, a grid of fixed branch biases controlled by $y(n)=g(v(n))$3, and output weights obtained through a regularized least-squares matrix inversion rather than iterative gradient descent. The design procedure forms reference pairs $y(n)=g(v(n))$4, sweeps candidate values of $y(n)=g(v(n))$5, solves a regularized linear system with $y(n)=g(v(n))$6, and selects the best $y(n)=g(v(n))$7. The practical point is that all trainable parameters are found in one regularized linear solve once the basis functions and biases are fixed.

The hardware interpretation is central. The conventional Hammerstein structure requires $y(n)=g(v(n))$8 multiplications and $y(n)=g(v(n))$9 two-input additions per sample, whereas the proposed scheme with $y_i \gets g_i(y)$0 nonlinear branches requires only $y_i \gets g_i(y)$1 multiplications and $y_i \gets g_i(y)$2 two-input additions per sample. The nonlinearities $y_i \gets g_i(y)$3 and $y_i \gets g_i(y)$4 are much cheaper than generating powers $y_i \gets g_i(y)$5, and the paper further emphasizes a fixed-point advantage: in the proposed structure, quantization can occur after the multiplications, avoiding the same output-noise amplification mechanism that constrains the Hammerstein implementation.

Evaluation uses a large set of multi-tone signals covering the first Nyquist band, chosen to resemble the quadrature component of OFDM/QPSK signals rather than isolated single tones. The reported simulations show signal-to-noise-and-distortion ratio improvements of some $y_i \gets g_i(y)$6 dB, the proposed linearizer outperforms the Hammerstein linearizer when the number of multiplications exceeds $y_i \gets g_i(y)$7, and with around $y_i \gets g_i(y)$8 nonlinear branches it drives SNDR close to the approximately $y_i \gets g_i(y)$9 dB SNR limit imposed by the undistorted $\sigma:Q_1\to Q$0-bit quantized case. This suggests that, in practice, the choice of generator basis can matter as much as the nominal plant model once fixed-point constraints and implementation complexity are taken seriously.

3. In-place function generation without auxiliary memory

In theoretical computer science, memoryless generation appears as memoryless computation: a model in which a target transformation $\sigma:Q_1\to Q$1 is generated by a finite sequence of instructions, each updating only one coordinate. An instruction is a transformation with at most one nontrivial coordinate function, written in update notation as

$\sigma:Q_1\to Q$2

A program computing $\sigma:Q_1\to Q$3 is a sequence of such instructions whose composition equals $\sigma:Q_1\to Q$4. “Without memory” means that computation acts only on the $\sigma:Q_1\to Q$5 data registers, not on an enlarged space $\sigma:Q_1\to Q$6 (Gadouleau et al., 2011).

The paper proves universality with explicit length bounds. Any transformation of $\sigma:Q_1\to Q$7 can be computed by a program that consists only of transpositions $\sigma:Q_1\to Q$8 where $\sigma:Q_1\to Q$9 for some $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$0 and the assignment $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$1. More strikingly, any permutation of $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$2 has maximum procedural complexity $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$3, and any transformation of $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$4 can be computed in at most

$$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$5

instructions. These are constructive bounds rather than mere existence statements. For transpositions of two states at Hamming distance $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$6, the exact complexity is $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$7.

The model generalizes the XOR-swap idea. The swap $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$8 over $$C_1(x_1)=\bigcup_{x_2\in R(x_1)} I_R(x_1,x_2,C_2(x_2))$$9 is computed by

$\pi_t(a|o)$0

The key principle is that a temporary quantity can be encoded inside a data register by combining variables, rather than stored in a separate buffer. The paper shows that this is not a marginal curiosity: for manipulations of variables $\pi_t(a|o)$1, it derives exact instruction counts, and it proves that combining variables can strictly shorten programs relative to black-box move-only instructions $\pi_t(a|o)$2.

The framework also quantifies the value of actual memory. With one memory cell, the complexity of a transposition at Hamming distance $\pi_t(a|o)$3 drops to $\pi_t(a|o)$4, and with one memory cell binary instructions become universal even though, over $\pi_t(a|o)$5, binary instructions without memory generate only affine transformations. A plausible implication is that “memoryless generator” in this literature is best understood not as a weak computational model, but as a strong in-place synthesis model whose constraint is absence of auxiliary workspace rather than lack of expressive coordinate updates.

4. Randomness, constrained sampling, and memoryless sources

In probability and information theory, the word “memoryless” usually refers to a source model rather than to the generator mechanism itself. The MRNG is useful precisely as a contrast case. It is a fully deterministic construction based on comparing decimal digits of prime roots, concatenating the resulting bits, and extending the sequence by moving to further prime blocks. The authors argue that the output empirically resembles Bernoulli$\pi_t(a|o)$6 bits: from $\pi_t(a|o)$7 ordered digit pairs they report frequencies close to $\pi_t(a|o)$8, and over $\pi_t(a|o)$9 generated strings the transitions, dyads, triads, tetrads, and pentads tests produce failure rates close to the nominal $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$0. Yet the paper does not prove that successive bits are independent and identically distributed, and it explicitly acknowledges that the sequence is generated by a deterministic algorithm and is not random under Algorithmic Information Theory (Skliar et al., 2012).

The constrained-random-number-generator framework takes a different route. It samples $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$1 from a target distribution conditioned on global constraints such as

$v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$2

or jointly

$v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$3

For channel coding, the encoder samples from $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$4 restricted to $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$5; for lossy source coding, it samples from $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$6 restricted to $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$7. The main theorems are information-spectrum achievability results for general channels and sources, but practical implementation is developed for memoryless priors or posteriors of the form

$v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$8

because that product structure, combined with sparse constraints, yields a factor graph to which the sum-product algorithm can be applied (Muramatsu, 2013).

Lossy compression of a binary redundant memoryless source provides a concrete coding instance. The source is i.i.d. over $v(n)=a_{0}+a_{1}x(n)+\sum_{p=2}^{P}a_{p}x^{p}(n),$9 with

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$0

and Hamming distortion. The Shannon benchmark is

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$1

The proposed scheme uses a sparse regular matrix $y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$2 together with a nonlinear map

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$3

so that the decompressor is

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$4

A symbol-MAP encoder is implemented by extended belief propagation with a heuristic inertia term, and for fixed row weight and iteration count the resulting complexity is $y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$5. The paper reports near-optimal performance for moderate block lengths and emphasizes that memorylessness of the source does not preclude exploitable structure, because redundancy resides in the one-symbol marginal distribution rather than in temporal dependence (Mimura, 2011).

Taken together, these works draw a sharp distinction. A truly memoryless source is a probabilistic object with independent symbols. A deterministic procedure may imitate some of its short-range statistics without becoming memoryless. Conversely, a constrained generator may start from a memoryless prior or posterior but produce globally dependent samples after conditioning on algebraic constraints.

5. Memoryless strategies, controllers, and policies

In game theory, “memoryless” is usually synonymous with positional. For weighted graph games with payoff functions defined by infinite weighted averages,

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$6

the central characterization is negative: among this class, the only objectives that induce optimal memoryless strategies for both players in all finite two-player weighted graph games are essentially discounted sum and mean-payoff. If $y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$7 converges, universal memoryless optimality forces a geometric progression

$y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$8

which yields discounted sum. If $y(n)=c_{0}+c_{1}v(n)+\sum_{k=2}^{K}c_{k}v^{k}(n),$9 and the coefficients are bounded, the objective must coincide with mean-payoff on regular words. The paper uses a monotonicity lemma and one-player gadgets, building on work of Gimbert and Zielonka, to show that there is essentially no other simple payoff function in this weighted-average family with universal memoryless optimality (Chatterjee et al., 2011).

For concurrent stochastic reachability games, the result is subtler. Under finite state space and finite Min action sets, Max has a randomized memoryless strategy that is $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$0-optimal from all states and optimal from all states that have an optimal strategy. This strengthens the result of Bordais, Bouyer, and Le Roux by allowing Max’s action sets to be countably infinite. The proof passes through finite-horizon values, a leaky-game reduction from reachability to safety, and a partition of states into those where optimal strategies exist and those where they do not. The theorem is exact about scope: some states admit no optimal strategy at all, so only $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$1-optimality can be required there (Kiefer et al., 2024).

In abstraction-based controller synthesis, the relevant notion is the memoryless concretization relation. Under the usual alternating simulation relation, concretization may require online simulation of the abstract system and storage of abstract state and input. Under MCR, the concretized controller is the static map

$$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$2

so runtime needs only the current concrete state $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$3. MCR is stronger than ASR when the quantizer is non-deterministic, weaker than feedback refinement relation because the concrete input may differ from the abstract input, sufficient for the memoryless concretization property, and—under the paper’s standing assumptions—also necessary for it (Calbert et al., 2024).

Finite-horizon POMDPs furnish an additional control-theoretic meaning. Here the object is a deterministic, time-varying, observation-based memoryless policy

$$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$4

optimized directly in output space rather than in belief space. Because the output process is non-Markovian, simultaneous stagewise policy improvement is invalid. The proposed family of policy-iteration algorithms therefore alternates single-stage improvements with reevaluation according to a periodic pattern. Any onto periodic pattern yields monotonic improvement to a locally optimal memoryless policy, and the optimal computational-efficiency pattern is the nearest-neighbor forward/backward sweep

$$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$5

which minimizes the average reevaluation burden (Zuijlen et al., 11 Dec 2025).

A unifying interpretation is that these papers treat memoryless generators of actions: current-state maps, current-observation maps, or current-concrete-state interfaces that are correct without replaying the entire history. The price is usually a strong structural theorem or a stronger abstraction relation.

6. Resource-constrained encoders, protocols, and update rules

Several literatures study memorylessness as a resource constraint. For off-chip buses, an $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$6-state $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$7-bit encoding scheme is memoryless when the codeword chosen for the current source word does not depend on previously transmitted codewords. The optimization target is the maximum code size under a worst-case transition bound $$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$8, formalized by

$$y(n)=c_{0}+c_{1}v(n)+\sum_{m=1}^{N}w_{m}f_m(v(n)+b_m),$$9

The paper proves explicit optimal families of memoryless codes and the striking identity

$f_m(v)=|v|$0

so access to a clock does not make a memoryless encoding scheme that minimizes bit transitions more powerful. In the unrestricted stateless case, the optimal code size is

$f_m(v)=|v|$1

and the codebooks are explicit and polynomial-time constructible (0712.2640).

For the weighted $f_m(v)=|v|$2-server problem on uniform metric spaces, a randomized memoryless algorithm is completely specified by a probability vector $f_m(v)=|v|$3 used whenever a move is needed. The exact optimal competitive ratio in this model is the recursively defined sequence

$f_m(v)=|v|$4

There exists an $f_m(v)=|v|$5-competitive memoryless algorithm, and no randomized memoryless algorithm can do better. The paper also shows that the Harmonic algorithm, which chooses probabilities in inverse proportion to weights, has competitive ratio $f_m(v)=|v|$6 (Chiplunkar et al., 2013).

Quantum communication theory uses a different but precise notion. A quantum protocol is memoryless when the players’ private registers are always empty, so each party retains only its classical input and sends the entire current quantum message state onward. In this model, the classical input information cost of bounded-round protocols for one-bit AND under the hard distribution $f_m(v)=|v|$7 is

$f_m(v)=|v|$8

The paper further shows that unrestricted private classical coins can transform any quantum protocol into an equivalent perfectly private memoryless protocol, whereas one-shot coins are strictly weaker: they can be compiled away without increasing information cost too much, so they do not collapse the information cost in the same way (Chailloux et al., 2017).

In decentralized optimization, “memoryless” refers to curvature updates that discard old secant information. The decentralized memoryless BFGS method uses only the latest pair

$f_m(v)=|v|$9

to build a scaled one-pair inverse-Hessian approximation, rather than recursively carrying a full BFGS matrix or a limited-memory buffer. The method combines this with gradient tracking, has computational and memory cost $y(n)=g(v(n))$00 per iteration, and the paper establishes global convergence and linear convergence rate with constant stepsize for strongly convex smooth decentralized optimization (Wang et al., 2024).

What these constructions share is not a common application area, but a common architectural discipline: use only the current local configuration, current sample, current observation, current message state, or current secant pair. This discipline can yield exact optimality theorems, explicit constructive schemes, and significant savings in storage, latency, arithmetic, or communication. It also marks a recurring boundary. Memorylessness is often sufficient only after the problem has been reshaped—by choosing the right basis functions, by conditioning a product law on sparse constraints, by strengthening a simulation relation, or by exploiting a structural characterization such as discounted sum versus mean-payoff.