Any computation whose behaviour involves only finitely many bits (i.e. is finitely realizable) can be implemented by a permutation (or by a finite composition of permutations) of $2 N$ positions, provided the hyper-finite $N$ is larger than the finite resources used by the computation.

I use “permutation” to mean a permutation of the set of positions ( ${1, \dots, 2 N}$ ); such a permutation acts on bitstrings of length $2 N$ by permuting coordinates.

1. The model

Fix a nonstandard/hyper-finite integer $N$ (so $N$ is an “infinite” integer in a nonstandard model, but hyper-finite so $2 N$ is still a (nonstandard) finite number of positions).
States are bitstrings ( $s \in {0, 1}^{2 N}$ ).
The designated initial state ( $s_{0}$ ) is the string with the first $N$ coordinates $0$ and the last $N$ coordinates $1$ : $s_{0} = 0^{N} 1^{N} .$
Allowed primitive operations are permutations ( $π \in S_{2 N}$ ) of the $2 N$ coordinate positions. A permutation ( $π$ ) acts on a state ( $s = (s_{1}, \dots, s_{2 N})$ ) by $π \cdot s := (s_{π^{- 1} (1)}, s_{π^{- 1} (2)}, \dots, s_{π^{- 1} (2 N)}) .$ (equivalently, move the contents of position $i$ to position $π (i)$ .)
A computation is any finite composition ( $π_{m} \circ \dots \circ π_{1}$ ) of such permutations; applying it to $s_{0}$ yields the output state.

Remark: Permutations preserve the multiset of bit values (so the number of ones is fixed: here always $N$ ). That is not a problem for universality because we will encode finite data and computations into the arrangement of ones (and zeros) among the many available positions.

2. Encoding finite data inside the hyperfinite string

The starting observation is simple and fundamental:

Because $N$ is hyper-finite (nonstandard finite), but the computations we want to simulate only need finite space/time, we may reserve disjoint finite collections of positions inside the $2 N$ coordinates for encodings of inputs, outputs, ancilla, workspace, etc.
Typical encodings:
- One-hot / token encoding. To represent an element $i$ from a finite set of size $M$ use a block of $M$ reserved positions and place a single $1$ in the $i$ -th position and 0s elsewhere (or place a token 1 in a chosen position). Because $N$ is larger than any fixed finite $M$ we need, we can reserve that block inside the last $N$ positions (or anywhere).
- Binary block encoding. To represent a $k$ -bit string use a dedicated block of $k$ positions and put the bits there.
- We can reserve many disjoint finite blocks inside the $2 N$ positions because $2 N$ is hyper-finite and bigger than any standard finite number we later mention.

Thus any finite configuration of finitely many logical bits can be encoded by specifying the contents of finitely many positions in our $2 N$ -length string; all other positions are left in their default values from $s_{0}$ .

3. Elementary lemma about permutations extending finite bijections

This is the combinatorial heart.

Lemma (finite-extension). Let $A, B \subset {1, \dots, 2 N}$ be finite (standard-finite) disjoint subsets of positions with $| A | = | B | = M$ . Any bijection $σ : A \to B$ extends to a permutation $\tilde{σ} \in S_{2 N}$ of all $2 N$ positions.

Proof. Pick any bijection between the finite complements so that together they define a permutation of the whole finite set ( ${1, \dots, 2 N}$ ). Concretely one can define $\tilde{σ}$ by:

On $A$ act by $σ$ .
On $B$ act by some fixed bijection from $B$ onto some other $M$ positions disjoint from $A$ (or leave them fixed if $σ$ maps $A$ onto $B$ and we want fixed elsewhere).
On the finite complement of $A \cup B$ act as identity. Because $A \cup B$ is finite, this defines a well-defined permutation of the whole finite set of $2 N$ positions.

(There is no obstruction: every finite partial bijection of a finite set extends to a full permutation; the nonstandard/hyperfinite size of the ambient set only makes it easier to choose disjoint blocks.) ∎

4. Realizing finite (classical) computations

Fix any classical finite computation $C$ you want to realize. By “finitely realizable computation” we mean: $C$ is a function

f : {0, 1}^{k} \supseteq dom (f) ⟶ {0, 1}^{ℓ}

or more generally a partial function whose behavior depends only on finitely many input bits and uses only finitely many workspace bits and a finite number of steps. (Equivalently: $C$ can be implemented by a finite circuit or a finite reversible circuit/finite Turing computation that uses only finitely many tape cells and steps.)

We show how to implement $C$ as a permutation (or finite composition of permutations) of positions, acting on $s_{0}$ after suitable encoding.

Step A — Make the computation reversible.

Classical trick: every finite (possibly irreversible) computation $f$ can be embedded into a finite reversible permutation on a larger finite state space (Bennett/Toffoli style). Concretely there exists a finite $n$ and a reversible bijection (permutation) $F$ on $n$ -bit strings such that for every input $x \in {0, 1}^{k}$ we have

F (x, 0^{n - k}) = (x, f (x), {garbage}_{x}),

or some reversible form that lets us recover $f (x)$ . So $F$ is a finite permutation of the finite set ${0, 1}^{n}$ .

Step B — encode the $2^{n}$ -sized state space into positions.

Represent each $n$ -bit string by a distinct position (one-hot encoding); i.e. choose a block of $M = 2^{n}$ reserved positions ( $P = {p_{1}, \dots, p_{2^{n}}}$ ) inside the $2 N$ coordinates. Encode an $n$ -bit string $u$ by putting a single $1$ in the position that corresponds to $u$ and zeros in the other positions of the block. Because $2 N$ is hyperfinite and $2^{n}$ is standard finite, we can make such a choice with room to spare.

Under this encoding, a permutation $F$ of the $2^{n}$ -element set of $n$ -bit strings corresponds exactly to the permutation of the $2^{n}$ positions that permutes the corresponding one-hot positions. By the finite-extension lemma we can extend that finite permutation of the $P$ -block to a global permutation $Π_{F} \in S_{2 N}$ of all positions (fixing all other positions outside a finite set).

Step C — realize $f$ .

Given an input $x$ (a $k$ -bit string), form the corresponding $n$ -bit input encoding (pad with zeros if needed), then create the one-hot encoding inside $P$ (this is a permutation of positions applied to $s_{0}$ that moves the token into the appropriate position representing the input — we can construct that since input choice is finite and we reserve specific positions for inputs). Now apply the global permutation $Π_{F}$ (or a composition realizing the reversible circuit as permutations). After $Π_{F}$ the one-hot token will have moved to the position representing the output $F (u)$ , which encodes $f (x)$ in a known place. Reading out the result is again a permutation that moves that token out to whatever output block we chose.

So the whole computation — encode input, apply $Π_{F}$ , decode output — is realized by a finite composition of permutations of the $2 N$ coordinate positions. Each of these permutations is supported on a finite set of positions (a finite transposition/product); by Lemma they extend to permutations of all $2 N$ positions.

Thus the composite permutation sends the initial state-with-encoded-input to an initial state with the encoded output. Because each permutation was a bijection on positions, it is valid in the model.

5. Why the hyperfinite $N$ is important

If we had only finitely many positions with a fixed finite upper bound $B$ , then we could only simulate computations whose total space/time fits in $B$ . By picking a hyper-finite $N$ (infinite in standard terms), we have a single ambient object whose size exceeds any standard finite resource bound; therefore any standard finite computation (no matter how large, but finite) can be embedded by choosing disjoint standard-finite blocks inside the $2 N$ positions.
In nonstandard language: for every standard finite $k$ there is an internal injection of the required $k$ -position workspace into ${1, \dots, 2 N}$ ; hence the universality statement holds for all standard finite computations.

6. Formal statement and proof sketch

Proposition (universality). Let $C$ be any computation that is realizable using only finitely many bit positions, finitely many elementary reversible steps, and finitely many time steps. Then there exists a finite composition of coordinate permutations ( $Π \in ⟨ S_{2 N} ⟩$ ) (supported on a finite set of positions) such that, when the input of $C$ is encoded into specified finite reserved positions of $s_{0}$ , the result of applying $Π$ to that encoded initial state yields the encoding of $C$ 's output.

Proof (sketch).

Convert $C$ to a finite reversible permutation $F$ on an $n$ -bit state space (standard reversible-computation construction).
Reserve a disjoint finite block $P$ of $2^{n}$ positions in the $2 N$ coordinates and choose a bijection between $n$ -bit strings and positions of $P$ ; encode inputs as one-hot tokens inside $P$ .
Realize $F$ as a permutation on $P$ ; extend it to a permutation $Π_{F} \in S_{2 N}$ (Lemma).
The composition of permutations that encodes the input into $P$ , then applies $Π_{F}$ , then decodes the output, is a finite composition of allowed operations and realizes $C$ .

Because each step uses only finitely many positions and $N$ is hyperfinite (so we have room), this works for any standard finite computation $C$ . ∎

7. Remarks and variants

You can use other encodings than one-hot; the one-hot trick is convenient because permutations of positions directly implement permutations of codewords.
The model is reversible by construction (permutations are bijections), so one must embed irreversible computations into reversible form (standard).
The model is essentially a group computation model (computation by group elements acting on a large set of tokens). This is related to permutation-model or token-machine models in computer science; here the novelty is the use of a single hyperfinite ambient string as a universal workspace.
If you allow sequences (finite compositions) of permutations as the allowed programs, the model can realize any standard finite algorithm. If you insist each allowed “primitive operation” must itself be a single permutation taken from a small fixed generator set, you recover a notion of finite-generator permutation network; universality then reduces to showing the generator set can synthesize the required finite permutations (again possible by standard permutation group generation results if the generator set is chosen appropriately).

8. Conclusion (informal)

Because a hyper-finite string of length $2 N$ contains arbitrarily large finite blocks, and because any finite bijection can be extended to a global permutation, every standard finite computation can be implemented inside this permutation-only model by reserving finite regions for encoding and wiring and realising the computation as a finite permutation of positions. Thus the model is universal for all finitely realizable computations.