Working Notes

Here You can read some working notes we decided to release. Currently under editorial review, L^AT_EX versions coming soon.

Core

• notes_for_QCO_in_order.txt -- for notCipher;
• notes_for_QCO_NN_in_order.txt -- for LLM cooprocessor;
• tensors_to_algebra_cookbook.txt -- tensors for algebra optimisation;
• HPF_QCO_tower_horizons.txt -- HPF QCO tower horizons;
• Hierarchical_Metric_Flow_on_Data_Graphs.txt -- LLM front without magic;
• appendix_implementations_1_for_Hierarchical_Metric_Flow_on_Data_Graphs.txt -- appendix for HMF (above);

Help

• Understanding_the_Mechanism_in_the_Context_of_implementations.txt -- if You want to understand;
• Implementation_Note_Guidance_for_Project_Manager.txt -- if You want to run such a project;
• Difficulty_Assessment_for_QCO_Entropment_Framework.txt -- if Your company really insist to implement some of those;
• LLM_implementation_limitations_hints.txt -- if You need help of LLM with papers / implementation;
• Programmer_friendly_Entropment_explanation.txt -- how Entropment (the "not-cipher" projection) actually works -- simplified for programmers;

Introduction

• Ontological status of IEEE-754 arithmetic in this construction ( txt )
• Numerical Quasi-Attractor in Finite-Precision Arithmetic ( txt )
• Crawling of zero divisors in sedonions leading to NaN ( txt )
• Zero Divisors in Sedonion Algebra under Floating-Point Arithmetic ( txt )
• ENGINEERING NOTE: Representation-Induced Behavior ( txt )

~2% BER correct key, ~55% nearby keys

Offline. Deterministic. Structural irreversibility.

Not a cipher, no IND-CCA security, no key secrecy assumption, no randomness required, no semantics, no primitive.

Open code and exe file in releases;

Raw project notes for reproduction and research purposes - free in papers; implemented.

Hierarchical Metric Flow on Data Graphs

LLM front without magic. Read more in papers; currently under implementation.

QCO-NN Coprocessor & LLM ↔ QCO Interface

Path-centric governance, decision closure, structural suppression of hallucinations, C/E/U regimes, decoupling depth from decision cost.

QCO-NN operates as a cybernetic decision engine, not a traditional layered neural network.

It governs computation via paths (Π) rather than fixed edges or layers, using a hierarchical QCO-norm to weight deeper abstractions exponentially less.

Key properties:

• Decision closure — asymptotic stabilization of the invariant functional I under admissible dynamics (vanishing ΔI_n and vanishing informational efficiency ΔI_n / K_n → 0)
• C/E/U regimes — trichotomy of outcomes: Closure (C), Exploratory-admissible (E), Undecidable (U)
• Structural hallucination suppression — no forced token continuation; output is the moment of stabilization or explicit undecidability
• Decoupling depth from cost — arbitrary structural depth is possible (via loops and CD tower with adaptive K), but effective decision cost remains adaptive and bounded by active components under the norm;

Interface model:

• LLM acts as semantic I/O processor (parsing, context, formatting)
• QCO acts as deterministic geometric / decisional coprocessor

Pipeline: Φ(q_text) → Ψ(q_struct) → Γ(s_dec)
where s_dec ∈ {C, E, U}

Raw project notes for reproduction and research purposes - free in papers; not implemented yet.

Technical Optimizations

When and why to pack tensors into algebras (CD / Clifford / Lie) instead of using dense GEMM.

Raw project notes for reproduction and research purposes - free in papers; implemented.

Notes are provided as-is for verification, numerical experiments.

They do not constitute production-ready documentation, tutorials, or drop-in libraries.

Direct production use without significant adaptation and validation is not recommended.

Commercial & Professional Services

We offer:

• Commercial software licensing
• System integration and deployment
• Consulting and architecture design
• Custom algorithm development

Contact us for a quote.

This page contains collection of materials that showcase our research, findings, technical progress and other insights.

This page is designed for researches, partners, investors and anyone interested in taking a deeper look at how we think, build and innovate.

YouTube

DataEntroper Introduction:

Entroper test loop for demo DataEntroper:

Basic use of function for demo DataEntroper:

Hidden tools in source code for demo DataEntroper:

We've just expanded our Papers section with new help paper -- a programmer-friendly introduction to "not-cipher" Entroper. Direct link (txt version). Read more…

This page contains downloadable builds and development packages of our projects. For now, developers and curious minds can study provided .zip package.

Source code packaged as GameMaker projects. Please install GameMaker first.

• 1. Version 32
• 2. Version 31

Version 32

Source code:

RIPA_32_export_source_code.zip (zip 455 kB)

Windows binary:

RIPA_32_export_exe.zip (zip 3.3 MB)

Version 31

Windows binary:

RIPA_31_export.zip (zip 3.7 MB)

Today marks the beginning of something exciting. This is our first public post -- a simple Hello World -- but behind it is a much bigger vision. Read more…

ENGINEERING NOTE: Representation-Induced Behavior

This implementation intentionally relies on properties of IEEE-754 floating-point arithmetic as a computational substrate.

Key points for implementers:

• The algorithm does NOT assume exact arithmetic over \mathbb R.
• Floating-point rounding, exponent scaling, and mantissa truncation are treated as deterministic projection operators.
• Observed attractors and quasi-stable states arise from the global geometry of the floating-point lattice, not from numerical noise.
• Behavior is stable across rounding modes and precision reductions, indicating representation-level invariance rather than implementation artifacts.

From an engineering perspective:

• This is expected behavior.
• This is reproducible behavior.
• This is architecture-consistent behavior.

Attempts to "fix" these effects by enforcing real-number identities (associativity, exact cancellation, symbolic reordering) will destroy the intended dynamics of the system.

This code operates in a representation-induced projective algebra, not in an ideal real-number field.

• 1. Zero Divisors in Sedonion Algebra under Floating-Point Arithmetic
• 2. Reason
• 3. Consequence
• 4. Practical Implication

Zero Divisors in Sedonion Algebra under Floating-Point Arithmetic

In exact Cayley–Dickson algebras over \mathbb R, zero divisors are well-defined, algebraically stable objects: nonzero elements whose product vanishes exactly.

This property relies on exact equality between multiple coupled components across dimensions.

When the same algebra is implemented using IEEE-754 floating-point arithmetic, this stability is lost.

Reason

Each multiplication step (sedonion → octonion → quaternion) introduces:

• multiple floating-point multiplications,
• multiple floating-point additions and subtractions,
• independent rounding at each operation.

As a result, algebraic equalities required for exact zero divisors are replaced by inequalities of the form:

where \varepsilon is the machine epsilon at the working scale.

Crucially, \varepsilon is not a neutral approximation error but a structural element of the numerical algebra.

Consequence

Zero divisors no longer behave as fixed algebraic points. Instead, they become dynamic numerical structures that:

• drift toward zero under some rounding histories,
• are repelled from zero under others,
• may cross below epsilon (numerical annihilation), or remain finite depending on accumulated perturbations.

Thus, in floating-point arithmetic zero divisors are not static objects, but evolving orbits under projection.

Practical Implication

Repeated quaternion (or higher CD) multiplications do not converge to exact zero even when the corresponding real-algebra product would.

This behavior is not a bug, noise, or instability. It is a direct consequence of treating floating-point arithmetic as a first-class algebra rather than an approximation of \mathbb R.

The observed "non-zero residue" is an invariant of the projection history, not a violation of the algebraic construction.

Crawling of zero divisors in sedonions leading to NaN

• 1. This behavior is expected.
• 2. Key points:

This behavior is expected.

The implementation operates on a 16D Cayley–Dickson algebra (sedonions), which is non-alternative, non-normed, and contains non-trivial zero divisors. The arithmetic is performed using IEEE-754 floating-point numbers, i.e. a finite-precision projection of the underlying real algebra.

Key points:

1. Zero divisors are not isolated points. In sedonions, zero divisors form extended manifolds rather than single algebraic elements. When projected onto finite-precision floats, these manifolds become \varepsilon-thick regions instead of exact null sets.

2. Deterministic drift under iteration. The system is fully deterministic. Apparent randomness arises from sensitivity to rounding and cancellation in IEEE-754 arithmetic, not from stochastic input. Small perturbations caused by rounding errors result in systematic drift of zero-divisor components between coordinates.

3. "Crawling" is a structural effect, not instability. Under repeated nonlinear mixing (e.g. sedonion → octonion → quaternion projections), zero-divisor states do not remain fixed but migrate across components. This crawling behavior is a natural consequence of iterating a non-normed algebra on a discrete numerical lattice.

4. NaN is a boundary marker, not a bug. NaN values arise when trajectories intersect algebraic singularities amplified by finite-precision projection (e.g. \infty - \infty, 0 \cdot \infty). In this context, NaN acts as an absorbing boundary condition in the IEEE-754 state space, not as an implementation error.

5. No physical randomness is involved. The computation is entirely deterministic. The observed loss of reproducibility at the real-number level is due to the impossibility of "hitting the same point" exactly in a discretized algebra with zero divisors.

In summary, this code does not approximate real-valued sedonions; it defines a deterministic dynamical system on the IEEE-754 projection of a zero-divisor algebra. The crawling of zero divisors and occasional collapse into NaN are intrinsic and expected properties of this system.

• 1. Overview
• 2. Definition
• 3. Behavior in \mathbb R (Idealized Analysis)
• 4. Behavior in IEEE-754 Floating Point
• 5. Rounding-Mode Independence
• 6. Role of Mantissa Size
• 7. Why So Many Iterations?
• 8. Geometric Intuition
• 9. What This Is NOT
• 10. What This IS
• 11. Interpretation
• 12. Intended Use
• 13. Final Note

Overview

This code defines a deterministic numerical transformation producing a scale-dependent, highly stable floating-point invariant ("fraction"), computed as a ratio of two structured sums involving fractional powers.

The construction is intentionally simple, but it exhibits a nontrivial and repeatable behavior when evaluated in finite-precision arithmetic (IEEE-754 floating point), which is qualitatively different from it's behavior in the real numbers \mathbb R.

The goal of this code is not cryptography, but the exploration of numerical structure arising from:

• finite mantissa resolution,
• deterministic rounding,
• irreversible projection from \mathbb R to a discrete numeric algebra.

This makes it suitable as: - a numerical stability probe, - a scale-sensitive fingerprint, - a didactic example of projection-induced structure.

Definition

For a given integer key k and a finite number of rounds N:

Left side:

for p in even-indexed primes

Right side:

for p in odd-indexed primes

The resulting fraction is:

The sums are truncated after N terms.

Behavior in \mathbb R (Idealized Analysis)

In exact real arithmetic:

• Both sums diverge slowly and monotonically.
• The dominant terms cancel asymptotically.
• The ratio F(k) \to 1 as N \to \infty.

This convergence does not require analytic number theory or zeta-function machinery; any balanced construction with symmetric fractional powers will exhibit similar asymptotic behavior.

In \mathbb R, the limit exists and is trivial.

Behavior in IEEE-754 Floating Point

In finite-precision arithmetic, the behavior changes qualitatively:

1. The ratio does not converge to 1.
2. After a sufficient number of rounds (typically ~1024–2048), F(k) stabilizes at a finite, key-dependent value.
3. Further iterations no longer change the result (numerical convergence).

This stabilized value is a quasi-attractor induced by projection onto the floating-point lattice.

Key empirical properties:

• Strong dependence on key magnitude (scale).
• Weak dependence on rounding mode.
• High reproducibility across runs.

Rounding-Mode Independence

Changing IEEE-754 rounding modes: - round-to-nearest-even, - toward zero, - toward + \infty, - toward - \infty,

affects the final value only at the level of \approx 1\text{e-}5 to \approx 1\text{e-} 3 relative error, even after thousands of iterations.

This indicates that:

• the structure is not rounding noise,
• the attractor is determined by the global geometry of the float lattice,
• local rounding differences average out under iteration.

Role of Mantissa Size

Two independent mantissas are relevant:

1. Mantissa of the key representation.
2. Mantissa of the floating-point arithmetic.

Important regimes:

• If the key mantissa is comparable to or larger than the FPU mantissa, nearby integer keys produce distinct fractions.
• If the FPU mantissa significantly exceeds the key mantissa, distinct keys can collapse onto the same fraction (true numerical collisions).

Thus, collision behavior is not mysterious -- it is a direct consequence of projection from a higher-resolution space into a lower-resolution one.

Why So Many Iterations?

Iterations serve to:

• drive the computation beyond the local influence of initial rounding,
• allow projection effects to accumulate,
• reach the stable orbit of the numerical system.

The required iteration count scales with mantissa size and key magnitude. Stopping earlier yields transient values, not the attractor.

Geometric Intuition

Geometrically, the construction can be viewed as:

• two slowly tightening logarithmic spirals in \mathbb R,
• whose ratio tends to 1 in the continuous limit,
• but whose discrete projections land on a stable orbit in floating-point space.

The attractor is not a fixed point in \mathbb R, but a fixed orbit under projection.

What This Is NOT

This function does NOT claim:

• cryptographic collision resistance,
• uniform randomness,
• security under adversarial models,
• independence from machine architecture.

It should not be labeled or marketed as encryption.

What This IS

This is:

• a deterministic numerical transformation,
• operating in a non-field algebra with:
  • finite resolution,
  • NaN and \pm \infty,
  • non-invertibility,
• exhibiting stable, scale-sensitive structure.

The observed behavior arises from the algebra itself, not from implementation bugs or randomness.

Interpretation

In \mathbb R, the limit exists and is trivial. In floating-point arithmetic, the limit is replaced by a stable projection.

This illustrates a general principle:

Deterministic + finite resolution + projection
⇒ apparent irreversibility without randomness.

Intended Use

• Numerical experiments.
• Studying projection-induced invariants.
• Exploring alternative algebraic intuitions.
• Educational demonstrations of finite-precision effects.

Final Note

This code treats floating-point arithmetic as a first-class algebraic structure, not as a flawed approximation of \mathbb R.

If one insists on interpreting it through the lens of ideal real analysis, the behavior appears anomalous.

If one accepts the algebra actually being used, the behavior is expected.

This code deliberately treats floating-point behavior (IEEE-754) as a primary algebraic structure, not as an approximation of \mathbb R.

Key design stance:

1. IEEE-754 arithmetic is NOT assumed to be an implementation of the real numbers \mathbb R. It is treated as a discrete, projective numerical space with:

   • minimal scale \varepsilon (machine epsilon),
   • non-numeric states (NaN, \pm \infty),
   • path-dependent evaluation (ordering matters),
   • loss of global associativity and distributivity.

2. From this perspective, deviations from \mathbb R are NOT "errors". They are structural properties of the underlying numerical space.

3. Zero divisors and near-zero states are treated as dynamical objects, not algebraic defects. Under iteration, they may:

   • persist,
   • drift ("crawl") across rounds,
   • fall below \varepsilon and collapse to 0,
   • or escape to NaN,

   depending on the number and coupling of perturbed floating-point operations.

4. Over \mathbb R, the corresponding algebra (e.g. CD algebras, sedenions) exhibits fixed zero-divisor structure. Over IEEE-754, this structure becomes a pseudo-orbit:

   • deterministic,
   • architecture-consistent,
   • but no longer stationary.

5. This behavior is EXPECTED and intentional. It arises from projecting a continuous algebra with zero divisors onto a discrete numerical lattice with finite mantissa.

6. The resulting dynamics are:

   • deterministic (no randomness involved),
   • highly stable with respect to rounding modes,
   • sensitive to global scale (mantissa/exponent geometry),
   • and unsuitable for interpretation within classical \mathbb R-based algebra.

This code therefore operates in a different ontological regime: not "real-number algebra with errors", but "projected algebra with intrinsic numerical dynamics".