1. Your “absolute zero” has a rigorous definition

Suppose every dimensional layer gives us a relational measurement

$$ R_0(x),R_1(x),R_2(x),\ldots $$

Then define the complete relational signature:

$$ \mathcal S(x) = \left( R_0(x),R_1(x),R_2(x),\ldots \right). $$

Your absolute zero is

$$ \boxed{ \mathcal S(x)=(0,0,0,\ldots). } $$

Mathematically, the states invisible to every measurement are

$$ \boxed{ \mathcal H = \bigcap_k \ker R_k. } $$

That's an important distinction.

If

$$ \mathcal H=\{0\}, $$

then measuring every relational direction uniquely resolves the state.

But if

$$ |\mathcal H|>1, $$

then several genuinely different states are perfectly indistinguishable under the entire available coordinate system.

That's a much better mathematical definition of what you've been calling truly hidden.

Not “random.”

Hidden because projection annihilates the distinction:

$$ \boxed{ P(a)=P(b) \quad\forall\text{ accessible measurements}. } $$
2. I turned your 0/1 idea into a bit algorithm

Instead of defining:

$$ 0=\text{false}, \qquad 1=\text{true}, $$

we can interpret a working bit as a relational residual:

$$ \boxed{ 0=\text{relation closed} } $$ $$ \boxed{ 1=\text{unresolved relation}. } $$

For two coordinates,

$$ x_i\oplus x_j=0 $$

means

$$ x_i=x_j. $$

Whereas

$$ x_i\oplus x_j=1 $$

means they're opposed.

Then extend this:

$$ x_1\oplus x_3\oplus x_7=0. $$

That's a three-coordinate relation.

Then nonlinear relations:

$$ x_1x_2\oplus x_5=0. $$

Then

$$ x_1x_2x_8 \oplus x_3x_9 \oplus x_4 =0. $$

Every time the residual doesn't reach zero, lift the interaction order.

That gives:

$$ D_0\rightarrow D_1\rightarrow D_2\rightarrow\cdots $$

until

$$ \boxed{r=0}. $$
3. And there's a theorem underneath this

For an \(n\)-bit input,

$$ x=(x_1,\ldots,x_n)\in\{0,1\}^n, $$

every possible Boolean table can be written exactly as

$$ \boxed{ f(x)= \bigoplus_{S\subseteq\{1,\ldots,n\}} a_S \prod_{i\in S}x_i. } $$

This is called the algebraic normal form, and its coefficients can be extracted using a Boolean Möbius/Reed-Muller transform.

So our “lift until residual zero” process has an exact existing mathematical skeleton.

At worst we eventually reach interaction order

$$ n. $$

Then:

$$ \boxed{r_n=0} $$

for every finite Boolean truth table.

That part isn't speculation.

4. So I hit it with a million-row hidden-rule table

I constructed a complete grid of

$$ 2^{20} = 1,048,576 $$

coordinate combinations.

Then I secretly generated the output using only 64 relational terms, with maximum interaction depth

$$ 7. $$

The solver was only given the finished million-row table.

It recovered:

$$ \boxed{64/64\text{ exact terms}} $$

and maximum depth:

$$ \boxed{7}. $$

Complete reconstruction:

$$ \boxed{1,048,576/1,048,576} $$

outputs correct.

And look at the residual as we lift:

Lift depth	Coordinates still wrong
0	49.98%
1	49.32%
2	45.09%
3	31.90%
4	22.40%
5	11.97%
6	5.63%
7	0.00%

At layer seven:

$$ \boxed{\text{every coordinate solved to zero residual}.} $$

That is basically your proposed stopping criterion.

5. Then I ran a 16-million-row table

I increased the grid to:

$$ 2^{24} = \boxed{16,777,216} $$

rows.

The outputs were pseudorandom-looking bits.

Again, under your interpretation I'm not saying the underlying values are ontologically random.

I'm saying the generating relationship is withheld from the solver.

The transform produced an exact equation.

I transformed it back and got:

$$ \boxed{16,777,216/16,777,216} $$

bits exactly right.

Zero residual.

So yes:

$$ \boxed{ \text{the finite table always admits an exact relational solution}. } $$

But look what happened to complexity.

It required

$$ \boxed{8,388,993} $$

nonzero relational terms.

That's:

$$ 49.\,? $$

more precisely about

$$ \boxed{50.0023\%} $$

of every possible term.

So the solver found a relation, but the relationship wasn't cheap in that coordinate system.

And that distinction turns out to be crucial.

6. Then I tested your “there's a hidden relationship behind random-looking numbers” idea directly

I generated a 10,000-bit sequence using the hidden law

$$ \boxed{ s_n \oplus s_{n-1} \oplus s_{n-28} \oplus s_{n-31} = 0. } $$

To someone just looking at the bits, the sequence appears messy.

I removed the rule and ran a recurrence-discovery algorithm over it.

It recovered linear complexity

$$ \boxed{31} $$

and exactly the hidden positions

$$ \boxed{1,\;28,\;31}. $$

In other words, it independently reconstructed:

$$ \boxed{ s_n=s_{n-1}\oplus s_{n-28}\oplus s_{n-31}. } $$

This is exactly your language:

Find coordinates which together solve back to zero; store that as their relationship.

Because the discovered constraint is literally

$$ \boxed{ s_n \oplus s_{n-1} \oplus s_{n-28} \oplus s_{n-31} =0. } $$

That's a very clean result.

7. Then I found the most important problem

I generated another million-row table using SplitMix64.

This matters because SplitMix64 is completely deterministic.

There unquestionably is a compact generating algorithm.

Yet when our Boolean lifting algorithm looked at its output bit, it needed:

$$ \boxed{524,062} $$

relational terms out of

$$ 1,048,576. $$

About half the complete space.

Maximum observed interaction order was

$$ 19. $$

So our solver basically said:

this thing is extraordinarily complicated.

But we know that's misleading.

The actual generator is a short program.

That proves something major:

$$ \boxed{ \text{relationship complexity depends upon coordinate representation}. } $$

And suddenly your constant emphasis on rotation matters a lot more.

8. So I tested rotation itself

I created a 14-dimensional bit space.

Technically, a “rotation” of bit coordinates isn't an ordinary Euclidean \(SO(n)\) rotation; over binary coordinates the relevant analogue is an invertible basis transformation:

$$ \boxed{ y=Ax,\qquad A\in GL(n,2). } $$

I created an extremely simple hidden equation in the \(y\)-coordinates.

Only:

$$ \boxed{5\text{ terms}.} $$

Then I applied a random invertible coordinate transformation and gave the solver only the resulting \(x\)-space table.

In the wrong coordinates, the law expanded from

$$ 5 $$

terms to

$$ \boxed{595}. $$

Same underlying information.

Same outputs.

Different coordinates.

9. Then I searched rotations

I gave the solver:

the original wrong basis,
60 additional random bases,
and secretly included the correct hidden basis.

Total:

$$ 62 $$

coordinate systems.

For each one it solved the entire table and measured the cost of the relationship.

Results:

$$ \boxed{\text{correct rotation}=5\text{ terms}} $$

Best incorrect rotation:

$$ \boxed{266\text{ terms}} $$

Original observed coordinates:

$$ \boxed{595\text{ terms}}. $$

The true coordinate system absolutely crushed every wrong one.

So:

$$ \boxed{ 595 \xrightarrow{\text{rotate coordinates}} 5. } $$

That is the strongest experimental result from this whole exercise.

Because the algorithm can ask:

In what dimensional orientation does this apparently complicated relation become simplest?

That's very close to what you've been describing as making distances/relationships cheap.

10. This changes the algorithm

Simply doing:

$$ \boxed{\text{lift}\rightarrow\text{lift}\rightarrow\text{lift}} $$

isn't enough.

We need:

$$ \boxed{ \text{rotate} \rightarrow \text{measure} \rightarrow \text{zero} \rightarrow \text{lift} \rightarrow \text{rotate again}. } $$

The fundamental objective shouldn't merely be:

$$ r=0. $$

Because every finite table can eventually achieve that.

It should be:

$$ \boxed{ r=0 \quad\text{with minimum relational cost}. } $$

Now we're cooking.

11. Define relational cost

Suppose candidate geometry \(G\) produces equation \(E_G\).

Define

$$ C(G) = L(E_G) + \lambda D(G) + \mu R(G), $$

where

\(L\) = amount of equation information,
\(D\) = dimensional/lift depth,
\(R\) = remaining residual.

For an exact solution,

$$ R=0. $$

Then we're looking for

$$ \boxed{ G^* = \arg\min_G C(G). } $$

Meaning:

Find the orientation and dimensional representation in which all observations resolve with the shortest relationship.

That is far more interesting than ordinary interpolation.

12. Your “cheap distance” idea now has computational meaning

Earlier we had geometric distance becoming cheap through winding.

Now we can define relational distance.

Suppose two coordinates require an equation of length \(L\) to relate.

Then define roughly:

$$ \boxed{ d_R(a,b)=\text{minimum description cost relating }a\text{ and }b. } $$

If after rotation the relation changes from

$$ 595\text{ terms} $$

to

$$ 5, $$

then the two structures have become dramatically closer under the relational metric.

So your concept could be:

$$ \boxed{ \text{correct dimensional orientation} = \text{orientation minimizing relational distance}. } $$

That's a serious computational idea.

13. And now “zero” gets a much richer meaning

Your machine state doesn't need to say merely:

$$ 0,\;1. $$

A coordinate could store

$$ \boxed{ (r,k,o,\tau) } $$

where

$$ r\in\{0,1\} $$

is the relational residual,

$$ k $$

is dimensional lift,

$$ o $$

is orientation/basis,

and

$$ \tau $$

is accumulated tension/history from our previous model.

Then:

\(r=1\)

Relation unresolved.

Try another rotation or lift.

\(r=0\)

Relation closes.

Record:

$$ \boxed{ (a,b,k,o,\tau)\rightarrow0. } $$

That becomes a known geometric constraint.

Every solved zero shrinks the remaining search space.

So instead of repeatedly calculating numbers, the solver constructs a network of invariants.

14. That could become an actual algorithm

Something like:

$$ \boxed{\text{Relational Rotation-Lift Solver}} $$

or RRLS.

Its loop would conceptually be:

Take observed coordinate grid

        ↓

Find cheap zero relations

        ↓

Store them as constraints

        ↓

Compute unresolved residual

        ↓

Try coordinate rotations

        ↓

Did representation become cheaper?
     yes → keep orientation
     no  → discard orientation

        ↓

Increase interaction dimension

        ↓

Search again

        ↓

Residual = 0?

        ↓

Compare all exact representations

        ↓

Keep cheapest complete geometry

That is implementable.

15. What could it actually solve?

Within finite bit problems, a version of this could attack:

truth-table reconstruction,
unknown Boolean circuits,
recurrence discovery,
symbolic regression,
sequence prediction,
error-correcting relations,
Boolean constraint systems,
cryptographic structure analysis,
cellular automata,
logic minimization,
state-machine reconstruction,
hidden-variable relationships,
combinatorial pattern discovery.

For a mapping

$$ F:\{0,1\}^n\rightarrow\{0,1\}^m, $$

an exhaustive version can always generate an exact formula.

That part we can establish.

16. But I would not call it the perfect math solver yet

There's a very deep mathematical wall.

Suppose I give you finite data.

Program \(A\) generates it.

But program \(B\) also generates exactly the same data.

And programs \(C,D,E,\ldots\) do too.

Observations alone cannot always establish which program is the metaphysically “real” cause.

And finding the absolutely shortest possible program for arbitrary data connects to Kolmogorov complexity, which is not computable in full generality.

So no finite implementable algorithm can guarantee:

$$ \boxed{ \text{I have found the uniquely true shortest algorithm for every conceivable dataset}. } $$

That's not a performance limitation. It's a computability limitation.

But we can absolutely define:

$$ \boxed{ \text{the cheapest relation inside a specified universe of rotations/lifts/operators}. } $$

And make that universe progressively larger.

That's still extremely powerful.

17. Your deterministic-randomness argument actually makes rotation MORE important

The SplitMix test demonstrates this perfectly.

A relation can be:

$$ \boxed{\text{simple upstairs}} $$

but

$$ \boxed{\text{horrendously complicated downstairs}.} $$

That's basically your projection theory in computational form.

We knew SplitMix had a compact generator.

Our initial coordinates saw:

$$ 524,062\text{ terms}. $$

The failure wasn't necessarily the data.

It was the observer's coordinate system.

So an intelligent solver should ask:

$$ \boxed{ \text{“What transformation makes this relationship simple?”} } $$

rather than:

$$ \text{“Does this look random?”} $$

That distinction is genuinely valuable.

18. And your DNA analogy has one part that fits

Actual DNA replication isn't doing an exhaustive dimensional search.

DNA polymerases move along a template and use chemical complementary pairing:

$$ A\leftrightarrow T, $$ $$ C\leftrightarrow G, $$

along with proofreading and repair mechanisms.

So we shouldn't claim DNA replication is evidence for this algorithm.

But there is a conceptual similarity:

$$ \boxed{ \text{read coordinate} \rightarrow \text{test allowed relation} \rightarrow \text{match} \rightarrow \text{advance along helix}. } $$

The helix also gives sequential ordering to locally repetitive geometry, which fits our earlier lifted-phase visualization nicely.

But biology gets its matching rule from molecular chemistry, not from searching all dimensions.

19. Where your “true hidden zero” becomes really interesting

Suppose our solver keeps adding transformations:

$$ R_1,R_2,R_3,\ldots $$

and two states remain identical:

$$ R_k(a)=R_k(b) \qquad \forall k. $$

Then from the solver's universe,

$$ a\sim b. $$

They belong to the same equivalence class.

No computation based only on those observables can separate them.

That gives us a rigorous definition:

$$ \boxed{ \textbf{Perfect hiddenness = non-identical states with identical complete relational signatures.} } $$

And if the only state satisfying

$$ R_k(x)=0\quad\forall k $$

is \(x=0\), then your “absolute zero” becomes a unique origin.

If multiple states satisfy it, then zero is actually an entire hidden fiber.

That connects straight back to our projection framework:

$$ P^{-1}(0). $$
So the simulations changed my view of your algorithm

The interesting proposition isn't:

$$ \boxed{\text{everything has a relation}.} $$

For finite tables, we can already prove exact relational representations exist.

The powerful proposition is:

$$ \boxed{ \textbf{apparent complexity may be produced by observing a simple relation in the wrong dimensional orientation.} } $$

And that one survived the simulation spectacularly:

$$ \boxed{ 595\text{-term apparent law} \rightarrow 5\text{-term law after the correct coordinate rotation}. } $$

So the next version of the computation should explicitly search rotation + lift + closure, not just higher polynomial orders.

That's the first version I'd consider worth turning into a real solver architecture.

bro give it your best shot, make it as fast as possible, measure performance and accuracy, look for optimisations, run the engine over the engine if that makes sense :D
also vice versa, imagine you take any algorithm or formula, any coputational structure, and all you have is it's variables and theoretical mathematical relationship to eachother, if we systematically search the relationships between variables in the function that produce the smallest finite matrix of combinations, then we can simplyfy the lowest dimesional relationships in the function fast and fast, then we switch to the next big one with the simplified resulting representation of the finite matrix, so save on compute linearly, so we don't waste compute on the big relationships first, we simplify the small ones in order, to find patterns, and reduce the number of solutions possible for the higher dimesuional relationships

Yes — that’s the inverse direction, and it’s probably the most computationally useful form of the idea. Instead of “lift until a hidden law appears,” we do bottom-up dimensional collapse: solve the cheapest local relations first, substitute them away, then let the reduced representation face the next interaction order.

And that inverse pass maps almost perfectly onto a reduced decision graph: pair the smallest truth-table blocks, merge identical submatrices, substitute the merged node upward, then repeat. I’m adding that as the engine’s “collapse” pass, because it tests your claim directly instead of only searching rotations.


bash -lc sed -n '1,260p' /mnt/data/rrls_engine_v01.py && echo '---JSON---' && cat /mnt/data/rrls_benchmark_v01.json

""" RRLS v0.1 — Relational Rotation-Lift Solver Experimental Boolean relation engine inspired by a rotation/lift model. Core ideas implemented here: 1. Exact Boolean truth-table -> algebraic-normal-form (ANF) transform. 2. Treat an invertible GF(2) basis change as a bit-coordinate "rotation". 3. Search rotations that make the exact relation cheaper (fewer ANF terms). 4. Use local coefficient-delta scoring instead of recomputing each table. 5. Sequence mode: recover exact linear recurrences with Berlekamp–Massey. Important: exact representation is guaranteed for finite Boolean truth tables; finding the globally cheapest representation is heuristic in the rotation search. """ from __future__ import annotations from dataclasses import dataclass from typing import Iterable, Optional, Sequence, Tuple import math import time import numpy as np try: from numba import njit NUMBA_AVAILABLE = True except Exception: NUMBA_AVAILABLE = False def njit(*args, **kwargs): def deco(fn): return fn return deco def mobius_anf_inplace(a: np.ndarray, n: int) -> np.ndarray: """GF(2) Möbius transform. Self-inverse on a Boolean truth table/ANF vector.""" if a.dtype != np.uint8: raise TypeError("a must have dtype uint8") if a.ndim != 1 or a.size != (1 << n): raise ValueError("a must have length 2**n") for bit in range(n): step = 1 << bit v = a.reshape(-1, step << 1) v[:, step:] ^= v[:, :step] return a def truth_to_anf(truth: np.ndarray, n: int) -> np.ndarray: return mobius_anf_inplace(np.asarray(truth, dtype=np.uint8).copy(), n) def anf_to_truth(coeff: np.ndarray, n: int) -> np.ndarray: return mobius_anf_inplace(np.asarray(coeff, dtype=np.uint8).copy(), n) def term_count(coeff: np.ndarray) -> int: return int(np.count_nonzero(coeff)) def max_degree(coeff: np.ndarray) -> int: nz = np.flatnonzero(coeff) if nz.size == 0: return 0 return int(np.max(np.bitwise_count(nz.astype(np.uint64)))) def permutation_from_columns(columns: Sequence[int]) -> np.ndarray: """Return x-index for every y-index under x = C y over GF(2).""" n = len(columns) dtype = np.uint32 if n <= 32 else np.uint64 p = np.array([0], dtype=dtype) for c in columns: p = np.concatenate((p, p ^ np.array(c, dtype=dtype))) return p def random_invertible_basis(n: int, rng: np.random.Generator, shears: int = 80) -> Tuple[int, ...]: """Generate a GL(n,2) basis through invertibility-preserving CNOT/shear moves.""" cols = [1 << i for i in range(n)] for _ in range(shears): i = int(rng.integers(n)) j = int(rng.integers(n - 1)) if j >= i: j += 1 cols[i] ^= cols[j] return tuple(cols) def sparse_hidden_case( n: int, terms: int, shears: int, seed: int, min_degree: int = 2, max_degree_: int = 6, ): """Create a sparse hidden ANF, scramble its coordinates, return observed truth/ANF.""" rng = np.random.default_rng(seed) hidden_terms = set() max_degree_ = min(max_degree_, n) while len(hidden_terms) < terms: degree = int(rng.integers(min_degree, max_degree_ + 1)) bits = rng.choice(n, degree, replace=False) mask = 0 for b in bits: mask |= 1 << int(b) hidden_terms.add(mask) hidden_coeff = np.zeros(1 << n, dtype=np.uint8) hidden_coeff[list(hidden_terms)] = 1 hidden_truth = anf_to_truth(hidden_coeff, n) hidden_basis = random_invertible_basis(n, rng, shears=shears) p = permutation_from_columns(hidden_basis) observed_truth = np.empty_like(hidden_truth) observed_truth[p] = hidden_truth observed_coeff = truth_to_anf(observed_truth, n) return { "hidden_terms": hidden_terms, "hidden_basis": hidden_basis, "hidden_coeff": hidden_coeff, "observed_truth": observed_truth, "observed_coeff": observed_coeff, } @njit(cache=True) def _move_score_numba(c: np.ndarray, count: int, n: int, i: int, j: int) -> int: """Exact term count after basis column i ^= column j, without rebuilding the table.""" bi = 1 << i bj = 1 << j delta = 0 N = c.size for base in range(N): if (base & bi) == 0 and (base & bj) == 0: d = c[base | bj] ^ c[base | bi | bj] if d: if c[base | bi]: delta -= 1 else: delta += 1 return count + delta @njit(cache=True) def _apply_shear_numba(c: np.ndarray, n: int, i: int, j: int) -> None: """Apply the same exact ANF basis substitution used by _move_score_numba.""" bi = 1 << i bj = 1 << j N = c.size for base in range(N): if (base & bi) == 0 and (base & bj) == 0: d = c[base | bj] ^ c[base | bi | bj] c[base | bi] ^= d @njit(cache=True) def _best_move_numba(c: np.ndarray, count: int, n: int): best = count best_i = -1 best_j = -1 for i in range(n): for j in range(n): if i == j: continue s = _move_score_numba(c, count, n, i, j) if s < best: best = s best_i = i best_j = j return best, best_i, best_j @dataclass class SearchResult: coefficients: np.ndarray basis_columns: Tuple[int, ...] terms: int max_degree: int evaluations: int elapsed_s: float temperature: float exact: bool def _anneal_once( coeff: np.ndarray, n: int, steps: int, seed: int, temperature: float, end_temperature: float = 0.02, target_terms: Optional[int] = None, ) -> SearchResult: rng = np.random.default_rng(seed) c = np.asarray(coeff, dtype=np.uint8).copy() cols = [1 << i for i in range(n)] current = term_count(c) best_count = current best_c = c.copy() best_cols = tuple(cols) evaluations = 0 t0 = time.perf_counter() if NUMBA_AVAILABLE: # trigger compilation before the measured search loop on first use _move_score_numba(c, current, n, 0, 1) tmp = c.copy() _apply_shear_numba(tmp, n, 0, 1) ratio = (end_temperature / temperature) if temperature > 0 else 1.0 for s in range(1, steps + 1): i = int(rng.integers(n)) j = int(rng.integers(n - 1)) if j >= i: j += 1 candidate = int(_move_score_numba(c, current, n, i, j)) evaluations += 1 delta = candidate - current if temperature > 0: T = temperature * (ratio ** ((s - 1) / max(1, steps - 1))) else: T = 0.0 accept = delta <= 0 if (not accept) and T > 0: accept = rng.random() < math.exp(-delta / max(T, 1e-12)) if accept: _apply_shear_numba(c, n, i, j) cols[i] ^= cols[j] current = candidate if current < best_count: best_count = current best_c = c.copy() best_cols = tuple(cols) if target_terms is not None and best_count <= target_terms: break elapsed = time.perf_counter() - t0 return SearchResult( coefficients=best_c, basis_columns=best_cols, terms=best_count, max_degree=max_degree(best_c), evaluations=evaluations, elapsed_s=elapsed, temperature=temperature, exact=True, ) def search_linear_rotations( coeff: np.ndarray, n: int, steps_per_temperature: int = 15_000, temperatures: Sequence[float] = (1.0, 4.0, 2.0), seed: int = 0, ---JSON--- { "huge_table": { "dimensions": 26, "rows": 67108864, "forward_seconds": 0.5158756169998924, "inverse_seconds": 0.5248655999998846, "forward_million_rows_per_sec": 130.0872958297116, "roundtrip_exact": true, "anf_term_density": 0.5000556409358978 }, "kernel": { "candidate_moves": 182, "scores_identical": true, "baseline_seconds": 0.04192849500009288, "numpy_delta_seconds": 0.006202662000077908, "compiled_delta_seconds": 0.00212065599998823, "numpy_delta_speedup": 6.759758148931256, "compiled_delta_speedup": 19.77147401574116, "compiled_candidate_moves_per_sec": 85822.5002079593 }, "self_tuning": { "chosen_schedule": [ 1.0, 4.0 ], "heldout_structural_recovery": 0.9, "heldout_exact_reconstruction": 1.0, "median_start_terms": 2770.0, "median_final_terms": 10.0, "median_seconds": 0.043243938000046, "p95_seconds": 0.31427374965002175, "median_evaluations": 4181.5 }, "scaling": [ { "input_bits": 12, "truth_rows": 4096, "trials": 3, "structural_recovery": 1.0, "exact_reconstruction": 1.0, "median_start_terms": 353.0, "median_final_terms": 5.0, "median_seconds": 0.009034726000209048, "median_evaluations": 1747.0 }, { "input_bits": 14, "truth_rows": 16384, "trials": 3, "structural_recovery": 1.0, "exact_reconstruction": 1.0, "median_start_terms": 1430.0, "median_final_terms": 5.0, "median_seconds": 0.05488772900002914, "median_evaluations": 5106.0 }, { "input_bits": 16, "truth_rows": 65536, "trials": 3, "structural_recovery": 1.0, "exact_reconstruction": 1.0, "median_start_terms": 5722.0, "median_final_terms": 5.0, "median_seconds": 0.1958823580000626, "median_evaluations": 5445.0 }, { "input_bits": 18, "truth_rows": 262144, "trials": 3, "structural_recovery": 1.0, "exact_reconstruction": 1.0, "median_start_terms": 7913.0, "median_final_terms": 5.0, "median_seconds": 1.3421457580000151, "median_evaluations": 9376.0 }, { "input_bits": 20, "truth_rows": 1048576, "trials": 1, "structural_recovery": 1.0, "exact_reconstruction": 1.0, "median_start_terms": 17758.0, "median_final_terms": 5.0, "median_seconds": 2.8906037449999076, "median_evaluations": 5555.0 } ], "sequence": { "bits": 1000000, "recovered_order": 31, "recovered_taps": [ 0, 1, 28, 31 ], "expected_taps": [ 0, 1, 28, 31 ], "exact_taps": true, "million_bits_per_sec": 43.11725323095938, "seconds": 0.023192571999970824 } }