Quantum

Spawn non-deterministic, quantum-aligned randomness with an optimal, unique QRNG API.

Introduction

It's a quantum-aligned TRNG as a QRNG with random numbers returned sequentially in compliance with the Eightomic standard of true randomness using classical computers in parallel to quantum computers.

It's fault-tolerant and hardware-independent with a substantial amount of redundancy to compensate for system clock errors and external interference.

Although the results from successful API requests are reliable, the cloud compute systems that Eightomic uses may have unreliable connectivity due to budget constraints.

Regardless, Eightomic is always working to improve API infrastructure and improve the usefulness of the QRNG API as a reliable fallback in systems that generate PRNG seeds and cryptographic keys.

Documentation

Requests

https://api.eightomic.com/quantum/ is the API endpoint URL.

It allows 100 free requests per IP address per day and 1 request per IP address per second.

It accepts the following optional arguments as either GET or POST fields. GET fields take precedence.

number_digits_minimum_count is the minimum amount of digits in each number with left-padded zeros. The minimum value is 1 and the maximum value is 64. The default value is 1.

number_is_signed is the boolean indication of whether each generated number is either signed or unsigned. The value is either true or false. The default value is false.

number_is_string is the boolean indication of whether each generated number is enclosed as either an integer or a string. The value is either true or false. When the value is false, the enclosing string quotations are removed without validating number_prefix as an integral constant prefix. The default value is false.

number_is_uppercase is the boolean indication of whether each generated number uses either lowercase or uppercase letters when the number_radix is greater than 10. The value is either true or false. The default value is false.

number_prefix is the prefix of each generated number. The maximum value length is 10 bytes. The default value is empty.

number_radix is the number base of each generated number. The minimum value is 2 and the maximum value is 36. The default value is 10.

number_range_maximum is the largest generated number allowed. If the value of number_is_signed is true, the minimum value is -9223372036854775807, the maximum value is 9223372036854775807 and the default value is 9223372036854775807. Otherwise, the minimum value is 1, the maximum value is 18446744073709551615 and the default value is 18446744073709551615.

number_range_minimum is the smallest generated number allowed. If the value of number_is_signed is true, the minimum value is -9223372036854775808, the maximum value 9223372036854775806 and the default value is -9223372036854775808. Otherwise, the minimum value is 0, the maximum value is 18446744073709551614 and the default value is 0.

The value of number_range_maximum must be greater than the value of number_range_minimum.

number_suffix is the suffix of each generated number. The maximum value length is 10 bytes. The default value is empty.

numbers_count is the amount of numbers to generate. The minimum value is 1 and the maximum value is 10. The default value is 1.

An example request is demonstrated with the following POST data in a 1-dimensional JavaScript object.

{
  "number_digits_minimum_count": 1,
  "number_is_signed": false,
  "number_is_string": true,
  "number_is_uppercase": false,
  "number_prefix": "0d",
  "number_radix": 10,
  "number_range_maximum": 1500,
  "number_range_minimum": 0,
  "number_suffix": "",
  "numbers_count": 5
}

Responses

An example response from the aforementioned example request is demonstrated with the following data.

{
  "numbers": [
    "0d1173",
    "0d941",
    "0d333",
    "0d206",
    "0d95"
  ],
  "status": 0
}

Each possible HTTP response status code is described in the following list.

200 means the request was successful.

400 means the request was invalid.

429 means the rate limit was exceeded.

500 means there was a server error.

Each response contains a JSON object that contains the 2 following fields.

numbers contains an array of numbers_count numbers.

When there are no numbers to return in an error response, the numbers value is null.

status contains a numeric value that's described in the following list.

0 means the request was successful.

1 means the rate limit was exceeded.

2 means there was a server error.

3 means the number_digits_minimum_count value must be a number that has a decimal radix.

4 means the number_digits_minimum_count value must be a greater than or equal to 1.

5 means the number_digits_minimum_count value must be a less than or equal to 64.

6 means the number_is_signed value must be either true or false.

7 means the number_is_string value must be either true or false.

8 means the number_is_uppercase value must be either true or false.

9 means the number_prefix value must be a string.

10 means the number_prefix value length must be less than or equal to 10.

11 means the number_radix value must be a number with a decimal radix.

12 means the number_radix value must be a greater than or equal to 2.

13 means the number_radix value must be a less than or equal to 36.

14 means the number_range_maximum value must be a number that has a decimal radix.

15 means the number_range_maximum value must be greater than or equal to 1 when the number_is_signed value is false.

16 means the number_range_maximum value must be less than or equal to 18446744073709551615 when the number_is_signed value is false.

17 means the number_range_maximum value must be greater than or equal to -9223372036854775807 when the number_is_signed value is true.

18 means the number_range_maximum value must be less than or equal to 9223372036854775807 when the number_is_signed value is true.

19 means the number_range_minimum value must be a number with a decimal radix.

20 means the number_range_minimum value must be greater than or equal to 0 when the number_is_signed value is false.

21 means the number_range_minimum value must be less than or equal to 18446744073709551614 when the number_is_signed value is false.

22 means the number_range_minimum value must be greater than or equal to -9223372036854775808 when the number_is_signed value is true.

23 means the number_range_minimum value must be less than or equal to 9223372036854775806 when the number_is_signed value is true.

24 means the number_range_maximum value must be greater than the number_range_minimum value.

25 means the number_suffix value must be a string.

26 means the number_suffix value length must be less than or equal to 10.

27 means the numbers_count value must be a number with a decimal radix.

28 means the numbers_count value must be a greater than or equal to 1.

29 means the numbers_count value must be a less than or equal to 10.

Randomness

Definition

Eightomic articulates and defines the practical, unique application of quantum-aligned randomness captured from a TRNG algorithm that uses internal temporal precision without a physical quantum computer.

Computational randomness is the only way to comprehend the origin of chaotic randomness in the universe.

When developing Quantum, a quantum-aligned random number generator API, Eightomic articulated the following efficient, error-resistant alternative to extracting bits of randomness from collapsed qubits.

In quantum computing, the probability of capturing a result of either 0 or 1 after collapsing a superpositioned qubit is calculated with deterministic mathematical formulas.

These formulas depend on tangible quantum wave functions that leverage entropic oscillations from external interactions.

In lieu of quantum computing, hardware-generated activity is sufficient for cryptographic number generation in most instances, but all numbers captured from external, inconsistent, pre-captured interactions are non-random based on subjectivity to both overlap and theoretical proof that ignores fundamental laws of space and time.

True randomness must always be captured from a source that's always oscillating relative to the capturing program exclusively. In other words, it's either random consistently or it's not random at all to a beholder of measurement.

Therefore, the only valid source of theoretically-sound randomness is from consistent, dedicated, deterministic computation that creates an unpredictable CPU time duration to be measured at a relatively-high precision to compensate for clock drift, frequency skew and low duration.

The aforementioned process creates a chaotic, intangible temporal pool that emits a tangible binary number representing the computed duration to be captured as a truncated bit of true randomness.

Each captured bit of true randomness, if concatenated, must be concatenated sequentially using the original sort order from within the scope of the capturing program to maintain the state of true randomness from outside the scope of capturing program.

Temporal mechanics are clearly-defined with time as a simple measurement within the constraints of classical physics. Time changes at a linear interval with a huge amount of precision relative to the third dimension.

In practical implementations, the CPU must be confirmed to spend at least a few nanoseconds processing each % and / operation. Anything less would be approaching an irrelevant discovery of transcending temporal friction.

Therefore, the pure chaotic factor isn't pollutable by hardware intervention or lack thereof.

For instance, the following TRNG library implementation, while vulnerable to implementation-specific issues, is capable of generating the same level of single-bit quantum randomness by combining classical and quantum computing methodologies.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void error(void) {
  exit(EXIT_FAILURE);
}

uint8_t oscillate(uint8_t randomness, uint8_t oscillation) {
  oscillation *= ((randomness / 111) % 111) + ((randomness + oscillation) % 11);
  oscillation /= (randomness - oscillation) | 1;
  oscillation = ((randomness + oscillation) % 111) + 111;
  return oscillation;
}

uint8_t capture_randomness(uint8_t oscillation) {
  struct timespec s;

  s.tv_nsec = oscillation;

  if (clock_gettime(CLOCK_REALTIME, &s) != 0) {
    error();
  }

  return s.tv_nsec & 1;
}

uint8_t eightomic_trng(void) {
  uint8_t oscillation = 111;
  uint8_t randomness = 1;

  while ((randomness >> 7) != 1) {
    oscillation = oscillate(randomness, oscillation);

    if ((oscillation & 1) == 0) {
      oscillation += randomness;
      randomness = (randomness << 1) | capture_randomness(oscillation);
    } else {
      oscillation -= randomness;
      randomness = (randomness << 1) | capture_randomness(oscillation);
    }
  }

  oscillation = oscillate(randomness, oscillation);

  if ((oscillation & 1) == 0) {
    oscillation += randomness;
    randomness = (randomness << 1) | capture_randomness(oscillation);
  } else {
    oscillation -= randomness;
    randomness = (randomness << 1) | capture_randomness(oscillation);
  }

  oscillation = oscillate(randomness, oscillation);

  if ((oscillation & 1) == 0) {
    randomness = (randomness << 1) | capture_randomness(oscillation);
  }

  return randomness;
}

int main(void) {
  unsigned char i = 0;

  while (i < 10) {
    i++;
    printf("Result %u is %u.\n", i, eightomic_trng());
  }

  return 0;
}

It uses a computationally-expensive sequence of algorithms to generate 8-bit randomness without a quantum computer using the aforementioned principles of quantum mechanics that rely on temporal mechanics.

oscillate(randomness, oscillation) is the classical equivalent of quantum waves in superposition and capture_randomness(oscillation) is the classical equivalent of quantum observation.

Although it adheres to the C99 standard draft (ISO/IEC 9899:1999) and it's convertible to other programming languages and standards, it's still vulnerable to implementation-specific issues.

1. It's only compatible with POSIX-compatible systems with adherence to POSIX.1-2001, POSIX.1-2008 and SUSv2.

2. The system must have resilience to the year 2038 problem for implementations with long-term usage intent.

3. The clock_gettime() implementation must support high-resolution, system-wide clock reads with consistent nanosecond time precision.

4. CLOCK_REALTIME is affected by other processes that can change the system clock.

5. It assumes s.tv_nsec = oscillation prevents compilers from unintentionally capturing randomness with capture_randomness(oscillation) before oscillate(randomness, oscillation) assigns oscillation a value.

6. System clock failures are handled by terminating the process with exit(EXIT_FAILURE).

Aside from the aforementioned issues that the Eightomic QRNG API prevents, it's impossible for the aforementioned implementation to capture non-random, predetermined bits due to the verified temporal precision of the system clock on each implemented device far exceeding the fastest processing time of repeating computations between each random bit capture.

Perceptual entities that are capable of comprehending language must either acknowledge the existence of true randomness or reject their constrained existence.

The standard of true randomness is defined by classical computing within the constraints of time.

Theoretical randomness and denying the existence of free will beyond these computations are topics of an irrelevant philisophical discussion.

Analysis

Although true-random number sequences always seem to be distributed in a random fashion at first glance, they usually fail advanced statistical tests after a few KB of output due to the astronomical amount of possibile numbers compared to deterministic, random-looking PRNG cycles.

Therefore, the output from Quantum creates reliable test vectors for researching and developing undiscovered randomness analysis methods.

For example, Eightomic noticed the following consistent pattern sequence in prime numbers when any set of adjacent prime numbers span a gap sized at 10.

In a set of 3 adjacent prime numbers a b c, and when a and c have the difference of 10, b is the result of incrementing by either 4 or 6.

The first occurrence of this pattern, starting from the first prime number in ascending order, is 19 23 29.

There are several other patterns, for example, in a set of adjacent prime numbers a b c d and when a and d have the difference of 10, the difference of b and c is always 2.

The first occurrence of this pattern, starting from the first prime number in ascending order, is 7 11 13 17.

The following prime number generator code validates this for the first 20k primes.

#include <stdio.h>

int main(void) {
  unsigned int primes[20000];
  unsigned int dividend = 3;
  unsigned int divisor;
  unsigned short gap_occurrences_count = 0;
  unsigned short i = 1;
  unsigned char is_prime;
  unsigned char is_pattern = 1;

  while (i < 20000) {
    divisor = 3;
    is_prime = 1;

    while (
      dividend != divisor &&
      is_prime == 1
    ) {
      if ((dividend % divisor) == 0) {
        is_prime = 0;
      }

      divisor += 2;
    }

    if (is_prime == 1) {
      primes[i] = divisor;
      i++;
    }

    dividend += 2;
  }

  while (i > 9) {
    i--;

    if ((primes[i] - 10) == primes[i - 2]) {
      gap_occurrences_count++;

      if (
        (primes[i - 1] + 4) != primes[i] &&
        (primes[i - 1] + 6) != primes[i]
      ) {
        is_pattern = 0;
      }
    }
  }

  if (is_pattern == 1) {
    printf(
      "The prime number pattern is consistent among %u gap occurences.",
      gap_occurrences_count
    );
  } else {
    printf(
      "The prime number pattern is inconsistent among %u gap occurences.",
      gap_occurrences_count
    );
  }

  return 0;
}

Of the 20k primes, there are 1120 occurrences of the aforementioned pattern.

Although this may have no substantial impact on the practical security properties of cryptographic algorithms, the aforementioned pattern can contribute to strengthening cryptanalytic evidence required by algorithms that leverage the entropic properties of prime factors.

In conclusion, there are plenty of undiscovered correlations among sets of numbers that appear to have no apparent pattern.

Therefore, using a theoretically-valid QRNG API as a true source of randomness is a reliable upgrade to relying on output from either a CSPRNG or an external noise generator that passes modern statistical tests.