Skip to content

orior

A unified computational foundation.

Orior finds the pattern in anything, from a crystal to a language to a file. It compares the thing with a shuffled copy of itself, and the pattern is what the copy lost. Every number is exact, with nothing rounded, guessed or trained.

Setup The algorithm The engine The transpiler Kolmogorov Complexity filetypes Areas of research

Where to go

Quick start

From a fresh clone, at the repository root:

utils/maint/engine/build_engine.sh                                  # the C engine: configure, build, run the graders
python examples/any_corpus/4_measure/collision_entropy.py           # a reading that knows nothing about its corpus
python examples/crystallography/6_oracle/proof_positive_control.py  # the positive control, against published cells
sh utils/maint/texbuild/build_theory.sh                             # the research papers

What is here

Nothing here asks to be believed: every result is traceable, every validated measurement could have failed but did not, and every claim the work took back is kept in its workbook. Most of the parts of this work are old and named as such. Their arrangements being glued together in orior using exact arithmetic with no exceptions even where the original authors allowed them or did not have access to vector calculus is what sets this work apart.

  • Exact integers, from end to end

    No rounding. No exceptions. Arbitrary precision throughout. No value is too large. A value too wide for its word is refused on compilation.

    The engine

  • The pattern is what a shuffle destroys

    Keep the same pieces, shuffle their order, and the shuffled copy is the baseline. Whatever the shuffle wipes out is the pattern. A filter built from any part of a pattern never misses a true match, and every match is still checked in full.

    The algorithm

  • Any number of dimensions, the same memory

    The filter keeps one bit for each place a match could start. Its memory doesn't grow with the alphabet or with the number of dimensions, and one formula gives its cost for anything from a line to an eight dimensional cube.

    The sift

  • Exact steps joined ahead of time

    A chain of exact steps is combined into one program before any data arrives, and runs on the device as one. It does the same work. It saves the time between the steps.

    The stack

  • Compression held to the noise of the camera

    No program can compute Kolmogorov complexity, and nothing here claims to. On 25 volumes of cell tracking images, the noise of the camera means no file can get below 38.9 percent of the raw size. The engine gets to 42.0 percent.

    Compression

  • One program at every width

    A program built only from sums, products, exclusive or and AND gives the same answer at every word width. The code writer turns it into PTX, C or SASS. When it doesn't know one of the rules of a target part, it asks the part.

    Two crystals

  • Laplace's demon, and its bill

    In practice, a boundary can rule things out but can't predict them. An exclusion is permanent and costs nothing. Each finer level of detail costs exponentially more precision. Nothing forbids prediction in principle. It just has that bill.

    Thought experiments

  • What an input stops reaching is a clock

    In SHA-256, by round seven there are 214 of 256 positions that no input bit can reach. By about round 30 of 64, every position is reached. Nothing here claims a weakness in SHA-256.

    Instruments

  • Precision spread

    Start with a few numbers known to enough digits, and every quantity an exact identity can reach from them comes out to the same number of digits. Two starting numbers, the square roots of 2 and 3, give 2,230,148 exact square roots up to 10^800.

    Precision

What came back

453 of 453crystal edges that match the published value exactly, as whole numbers, with no tolerance
0 missedout of 9,396,207 true matches in byte strings, and out of 213,840 across one to eight dimensions
1 of 200random borders did as well as the dialect border it found without ever seeing the labels
383 of 383subtraction games where it found the right Grundy period
13 to 22 timesfaster when seven hundred steps run as one combined program, with every record identical
792exact numbers are enough to hold 100 quantum bits that are all 0 or all 1 together

What it does not claim

  • It doesn't compute Kolmogorov complexity. It puts an upper limit on the complexity of a file by actually writing the file smaller.
  • It doesn't claim any weakness in SHA-256.
  • It can't hold every quantum state in a few numbers. A general state of 100 quantum bits still needs 2^100.
  • It isn't a model, and nothing in it is trained.
  • Some results were found by other people first. Where we know that, the published work is named.
  • The thought experiments are ideas whose experiment can't be built as written. They are kept apart from the results, and none of them is one.