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¶
-
Setting up the engine to solve your problem
-
The engine/transpiler's language:
gnascor
The query protocol for the ruleset L*, relational gsm, higher order language g formats, constructs, and file definitions
-
No arrangement of anchors can lose a true occurrence
-
The proofs that every set returns their exact count, and self-terminates
-
Theory & Research
-
Be excellent to one another
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. A tie is broken by name, never by noise. Pi to ten million digits, checked against a second series that shares no arithmetic with the first, is a test the engine runs on itself.
-
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.
-
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.
-
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.
-
Compression bounded by 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.
-
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. For the binary lambda calculus, two exact bounds put Chaitin's Omega below one eighth, and its first two bits are proved.
-
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.
-
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.
-
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.
What came back¶
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, using its own categories of noise in the set N* and lossless compression in exact integers modeled on JPEG 2000.
- It doesn't claim any weakness in SHA-256. The point of measuring where SHA-256 is uneven is what the deformation of the field shows once the bits that carry the most change are known.
- It can't hold every quantum state in a few numbers. A state as plain as 100 quantum bits all 0 or all 1 together fits in 792 numbers, and a general state of 100 quantum bits still needs 2^100. What it can do is run an operation on a file that represents the state: a continuous, error-corrected transform over a sliding window, in exact integers of any number of limbs and bits. The file bus is as wide as the machine allows and the maximum register width is respected. A wider register that no hardware has yet is supported by defining the platform and its register width;
embedded_typesholds every platform switch for types. - It isn't a model, and nothing in it is trained. The engine is a search algorithm, and the transpiler uses binary relations and several algorithms. There is no neural network and no weighting.
- Some results were found by other people first. Where we know that, the published work is named. I'm autistic and working this out as I go; I name prior art as I read it, and anyone who sees prior work that isn't cited is asked to point it out so it can be cited.
- 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.