Philosophical and Mathematical Foundations of Any Number Generating System and The Lu-Number System

1. A Philosophical Introduction

Assume we begin with the following definition:

By Definition 1, assuming we go by popular conventions in use for ordinary human language and semantics, then, when one entity declares to another that “I have counted 1000000”, it could be interpreted as meaning or implying one of the following:

• ‘1000000’ is a quantity.
• ‘1000000’ also expresses the name of that quantity—its unique or distinct identifier in some base—typically, base-10—and thus just “1 Million”, unless explicitly specified; such as if it had been expressed as ${1000000}_2$ or $0x1000000$ or perhaps $0b1000000$—notations more commonly found in computational literature, and then $\overline{M}$ in Latin Numeral Notation.
• ‘1000000’ implies it is possibly just the quantity, and nothing about whether or not the number has some non-quantifiable quality—such as whether it is signed or not.

The above information might be sufficient for the purposes of merely operating on the name and quantity of the number in the usual or commonplace sense, but perhaps not in a totally meaningful or rather, non-ambiguous way. What this means exactly, can be appreciated by further considering that:

• Without knowing explicitly in which base the counting operation was conducted—or rather, how the computation was performed, we can only guess at what really the quantity of the expression ‘1000000’ is. This, especially if we wish to somewhat reproduce or rather compare other quantities in some or any base, relative to that expressed quantity. So basically, without the base information, the expression ‘1000000’ is but a scalar symbol—it tells us about some number and offers an idea about its quantity or size, but actually only its name and little or nothing about how to exactly express its quantity meaningfully.
• As a result of the above condition, we might for example wrongfully mis-read the expression ‘1000000’ to mean any of the following:
  • the decimal number 1000000 and a quantity as is the result of counting the legs of 10,000 centipedes.
  • especially because by Theorem 2 (Membership in base-$\beta$) in [2], the expression qualifies to be considered a base-2 number, and thus, makes the decimal quantity equivalent to the Canonical Form of the number it expresses (see Definition 1) to be the decimal number 64—or rather, ${64}_{10}$—refer to Theorem 1 (Any Base to Decimal) in [3], and which, by Theorem 2 (Membership in base-$\beta$) in [2] as well as Theorem 2 (Defining ${\psi }_{36}$) in [3], also qualifies to be a number in base-36, by which case then, using the standard base conversion mechanics—like from one base into decimal and from decimal to another [4], and what we know of base-36 [3], that the number expression ‘1000000’ then is equivalent to $1S_{36}$. That is if we have treated the number as a base-10 expression and then converted it to base-36. However, if we indeed treat that same expression, ‘1000000’, as a base-36 number, it then turns out to be equivalent to the decimal quantity ${36}^6$ or rather, ${2176782336}_{10}$ and other interesting numbers in other bases...

Further, we might not clearly know whether the number is positive or not, or whether it expresses a pure number or a pure fractional number—since, for pure fractionals [1], we might, under some special notations, do away with the implied usual “symbolic” parts of the number’s expression such as when we write “0.5” to mean ${\displaystyle \frac{1}{2}}$ when we could as well have written just “.5” or even perhaps $2^{-1}$!

So, much as sometimes number expressions are used/meant to communicate more precise, or rather, unambiguous forms of quantities and quantifiably identifiable measures or properties of things, then, it is important that we be more careful and adopt more explicit, or rather rigorously unambiguous expressions of numbers when communicating exact science, mathematics and/or verifiable information.

A more precise way to report the result of a computation such as counting, should have been expressed as: “I have counted 1000000 in base 2.”

2. The Lu-Number System

In this section, we are going to build upon ideas from the previous section, to try and develop from scratch, a theory and mechanics for defining abtract machines that can process information as input and then produce or rather, generate other information—in particular, information expressions such as numbers in some number system. These machines are essentially Number Generators, though, ultimately, our objective is to systematize and formalize and advance the important field of Random Number Generators.

We shall refer to the original reference number system we are going to base our number generation theory on, as the Lu-Number System, LNS.

2.1. LNS Foundations

Let there be a distinct symbol to be referred to as the signal. For practical purposes, let the signal be the symbol “<”.

Axiom 1.

Every distinct information has a definite distinct way it can be expressed or encoded so as to express, manifest or represent that for which it is a reference—typically via some symbol or systematic sequence of them, which is known as “information encoding”. Equivalently, symbols represent or express some definite information—information that can be understood and is communicable.

Definition 2 (The First Base Symbol: the Signal).

This is essentially the Primal Signal Encoding Method in the Lu-Number System (LNS); the primal-symbol, also to be known as “the signal”, to be simply written as “<”—a single opening angle-bracket. In the LNS, it is meant to basically express the presence of some information—any perceptible information.

Axiom 2.

In being expressed, any distinct information under the LNS can take on one of two forms; the primal-form or the alternate/inverted form, but not both simultaneously.

Definition 3 (Alternate Base-Symbol: the Alternate Signal— the Anti-Signal).

In LNS, because it is the alternate or opposite of signal, “>”, it shall simply be expressed as “>”—the lateral inversion or exact mirror reflection of the primal-symbol. Also, this operation of reflection or inversion of symbols or information in general, is among the first permissible operations in LNS. More about this later.

Note that, to simplify our calculus when dealing with the LNS Base Symbol Set, sometimes we might just write ${\psi }_l$ instead of ${\psi }_{LNS}$.

Definition 4 (An Information Expression).

An information expression, Θ, is any systematic encoding of meaning as a finite sequence of distinct symbols from a definite symbol set such as ${\psi }_l$ (refer to Theorem 1).

It shall be interesting to note that Postulate 1 raises some interesting problems. For example, away from the simplest LNS expressions such as “<” and “>”, shall it be correct to define $in(·)$, the LNS inversion operation as:

$$in(\Theta )=in\left({\sigma }^{*}\right)\Rightarrow in\left({\sigma }_1\right)·in\left({\sigma }_2\right)...·in\left({\sigma }_{n-1}\right)·in\left({\sigma }_n\right)\forall {\sigma }_{i\in \mathbb{N}}\in \{<,>\}$$

(1)

Also, in the case of the LNS reduction operation, $re(·)$, when or how should we decide which of two or more possible permissible results to produce, generate or return from a call with multi-symbol input information expression—such as $<><<<><>>>$ or $>><$? Essentially, what should be returned in the following computation:

Computation 1.

$re(<><<<><>>>)\Rightarrow$ ?

This problem is actually very important in this LNS theory—it is the kind of problem that brings to mind issues like how to define autonomous choice or autonomous decision making or an autonomous random reduction of some input information? It might likewise spur other problems like; what is the true nature of entropy? What is the identification of signal fundamentally based on? Also, such a critical problem as; is it the operator that decides or what is operated on, concerning what such a dynamic operation as $re(·)$ ought return?

3. Generation, Perception and Encoding of Information as Lu-Number System Information Expressions

Though focus is mostly on what happens after information naturally or artificially generated or produced becomes available for a system to process (of which, encoding it in some new or alternative way is an example of such basic processing), we shall momentarily look at how such information first becomes available to the processing system - such as the Lu-Number Encoder and Generator in this case.

Also, it shall help to clarify on some important matters concerning some of the LNS operations we have just formalized in Postulate 1.

3.0.1. Concerning Information Production/Generation with LNS2

First of all, for purposes of not prematurely jumping into or deviating away from our core subject in this present inquiry or formulation, we must appreciate that it is not really the responsibility of a Number Production System or Information Expression Encoding System theory to worry about the first production of information—creation of information (or rather, entropy—changes in information) ex-nihilo for example, or how entropy comes to be in the first place (how reality expresses itself in some conceptual filter or dimension) in any system and some reference frame, but rather, to provide means to systematically express any such originally produced information (via a natural entropy source for example), when it becomes manifest—such as to a basic signal perceptron or an IoT sensor when it registers a change or infomaton as raw signal; visual, aural, mechanical, tactile, seismic, electric, chemical, thermal, etc. such as from a natural and physical entropy source or dynamic phenomena. However, it should further be noted that such physical entropy sources need not be strictly natural or part of a purely natural phenomena, but could also be virtual—simulated, or rather artificial—such as for entropy sources implemented in virtual and/or augmented reality systems such as meta-verses, computer games and such. Realistically, there might still be some unanswerable questions within the theoretical, though practically useful LNS for now, but that doesn’t necessarily mean it is incomplete3.

For example, concerning the interesting information reduction operation, $re(·)$ in LNS (see Postulate 1), we could simplify the operation semantics thus:

$$re(\Theta )\Rightarrow <|>|\Theta |{\Theta }^{*}\subset \Theta |\varnothing$$

(2)

This queer definition of the reduction operation is to allow us to explain how it is possible that where there was more than one possible and/or permissible output from the operation based on the input, we still can express meaningful limits on what the result or correct output ought look like and/or mean; the output is always a subset of the input expression4.

And then, concerning the strange information production operation, $pr(·)$ in LNS—which, because it essentially is the first way that information ever gets expressed in any LNS production system—where none existed that is—from or via the processing of raw input signal—that might not necessarily be originally expressed using LNS encoding—such as when such information is produced by a natural system, e.g. the thermodynamic and/or kinematic properties of a naked flame/fire, the Brownian motion of gas particles, the kinematics and geometries of a cloud, the hydrodynamics of a fluid under turbulence, certain statistics in a financial market etc., and yet, its output should be information meaningful within the LNS encoding. Thus, we should perhaps generally define $pr(·)$ as such:

$$pr(·)::=<|>|\varnothing$$

(3)

borrowing notation from the Backus-Naur form [5] notation or

$$pr(·)⟶<|>|\varnothing$$

(4)

borrowing from CNF grammar/syntax production rules notation [6] common in the expression of branching or stochastic production processes in software language engineering literature. Generally, for any number generation founded on the LNS:

$$pr(·)⟶<|>|\Theta |\varnothing$$

(5)

for $\Theta$ a valid LNS information expression.

And, before we close discussion concerning pr(.), note that, the choice of notation when expressing such a function is quite important. For example, from a higher abstraction level—say at the level of a user of an RNG function such as the TEA programming language primitive n: that is built into the language so as to help generate random numbers [7]—it might be the case that from the user’s reference frame or rather, point of view, the basic RNG $pr(·)$ is usable even without any explicit user input—such as for the TEA primitive we have just talked about—meaning, it seems as though the [correct] signature of the information production operator ought be written as:

$$pr(\varnothing )⟶<|>|\Theta |\varnothing$$

(6)

So that, it justifies the idea of creating new information from nothing (thus “ex-nihilo”) or rather, specifying an RNG that uses/requires no seeds! However, despite the aesthetic gravity of this later signature, it is wiser to stick to the earlier variant (Equation 5), or perhaps, we could instead write $pr(·|\varnothing )$ to imply both points of view, though, $pr(·)$ still remains preferable because, apart from helping abstract away what exactly the nature of the arguments the generator expects or operates on, at least it makes it clear there is always some argument no matter what. And in fact, at the lowest level, such as when dealing with a TRNG that say sources entropy from a physical source [8], we find that despite the user of the function not having to explicitly specify an invocation-time argument when seeking for a new [possibly random] information expression, and yet, behind the scenes, at minimum, such an operation must explicitly specify when and from which source (or even perhaps how) the desired information must be read or extracted from the entropy source. Thus, to balance between abstraction, elegance and correct semantics, (Equation 5) shall be our most authoritative definition of the generator operation.

4. Generating Binary Numbers from Signal

Now that we have seen how to generate and/or produce simple and complex information expressions such as numbers in the Lu-Number System, we shall next turn our attention to the production of information expressions in a form more palatable and relatable for practical applications in most real-life domains. Essentially, we are to first look at the simplest number system useful in typical computation processes—the base-2 number system, also known as the “binary number system”, BNS.

Lemma 1 (Equivalence of ${\psi }_l$ and ${\psi }_2$).

By Postulate 2 and the fact that the Base-2 natural symbol set [2] is merely $\langle 0,1\rangle$, if we write the LNS base symbol set (see Theorem 1) in its ordered form as ${\psi }_l=\langle >,<\rangle$, then ${\psi }_l\equiv {\psi }_2$.

The interesting and useful consequences of Lemma 1 is that any typical binary number expressions (or rather, information expressions encoded using bits) can all be re-written simply as expressions in the Lu-Number System. Or rather, at the symbol-set level then, the two seemingly different information encoding number systems are equivalent and expressions in one system can readily be re-written in the other. Illustrations of this would be transforms such as:

• $101⟷<><$
• $000111⟷>>><<<$
• $<><<<>⟷101110$
• $><><⟷0101$

5. Generating Decimals from Signal

Now that we have seen the case of obtaining binary numbers from signal, or rather, via the Lu-Number System, and having seen the interesting property that the BNS and LNS are equivalent in some regards, we can then turn our attention to information expressions of numbers in base-10 and see what interesting things we might find out based on LNS.

Next, we shall look at the generation of numbers in any base.

6. A General Number Generator and the True Random Number Generator

Building on the ideas we have seen in the previous sections, we can safely trust that the LNS can readily allow us to design a number generator targeting any base starting from the processing of some basic signal.

Turning our attention away from the generation of just any information expression, or rather, any numeric expressions or numbers, we shall now look at the more important matter of how to generate random information expressions and consequently, how to generate truly random numbers.

At this juncture, we can pause and appreciate that any random number generator is in one way or another, an information processor—more correctly, a signal encoder. However, for TRNGs, the conditions laid out in Definition 5 are undeniably critical and important, since, they shall help us to readily tell apart RNGs that are truly/appreciably random from those that are only-approximately random (such as pseudo-random number generators, PRNGs), that might forego use of an external, statistically independent and semantically correct source of randomness, and instead rely on user-provided seeds, say for purposes of allowing the generation of predictable random numbers or sequences of them, and thus, produce or generate predictable information/results—see [8] for more on this). This shall also help in the design and implementation of special RNGs meant for critical operations such as in enabling cryptography or information security via the use of Cryptographically Secure Random Number Generators (CSRNGs).

Next, we shall attempt to distinguish between RNGs that operate directly on raw signal (physical information) vs those that operate on complex signal—or rather, on finite strings such as [higher-order] information expressions (see Definition 4).

We shall then find that the production operator in LNS, $pr(·)$ is actually a kind of $\mathsf{\Xi }$.

Lemma 2 (All $\mathit{\xi }$-TRNG Reducible to $\mathsf{\Xi }$-TRNG).

Any higher-order TRNG producing numbers in any base or number system can be reduced to a simple first-order TRNG in the LNS.

7. Conclusion

In this work, we have developed a new number system, LNS, a basic, first-order information encoding system fit for expressing basic outputs from an entropy source—especially physical entropy sources, in the form of signal or its absence. LNS provides a low-level framework upon which interaction with entropy sources can be made so that higher-level information expressions such as numbers in binary, decimal and other usual bases can be readily obtained or inferred from mere basic signal. We have seen how the basic LNS number generator would work from a purely theoretical perspective, and have likewise seen how other higher order number generators—in particular, Binary Number Generators and then Decimal Number Generators can be founded on an LNS generator. Apart from offering the foundations for rigorously specifying a basic RNG, via specifying the permissible basic operations possible on LNS-encoded basic information, this work also contributes to the literature on especially TRNGs, by establishing how any TRNG irrespective of its target or output number system, can be founded on, or rather, can be reduced to a basic LNS-TRNG—a $\mathsf{\Xi }(·|\varnothing )$. In future work, we shall further this undertaking with pragmatic verification of the theory thus laid out, say with a reference implementation of a LNS-TRNG, and leveraging that to implement a high-order RNG, $\xi (·|\Theta |\varnothing )$, such as a decimal TRNG, so as to practically verify this theory and also help extend it further. Also, more theoretical work might delve into answering some of the still-unanswered questions raised in this present work, such as how exactly to specify when/how a typical branching production rule in a generator specification might rely on some explicit condition so as to decide how to produce one of several possible output [terminal or non-terminal] terms, a solution that might likewise be of theoretical and practical relevance in automated language engineering such as in implementing systems than can generate valid source-code/computer programs autonomously or even stochastically, based on processing of a language specification or formal grammar (BNF or CNF production rules for example), and which are driven by some stochastic signal or input—ideas useful in cases such as if we are to work on automated-generation of valid and useful TEA programs ex-nihilo.