Infinite Compression Algorithm

Ok. I studied Wolfram's ideas. And he implies, that there is a simple cellular automata, that can produce any structure in existence. The only problem left is locating that structure in the automata's output.

Hey, FrozenVoid, can you do that?

https://www.youtube.com/watch?v=R9Plq-D1gEk

>>1
Its known as "magic formula" compression.
My idea was considerably simpler, creating a large search space(x*y< gap >x*(y+1)) where a polynomial is constructed like x^8.4343+z^4.3434-k^232.34-...+... that converges into the <gap> of search space, that polynomial divided by y gives back x.zzz where fractional part is discarded and x-integer is converted back to file.

A simplified version that assumes a fixed base and only records the powers is described here:
http://void.wikidot.com/algorithms:polynom-encodings
Edit added the explanation of general method
http://void.wikidot.com/algorithms:polynomial-compression-explained Edited on 11/10/2018 15:02.

>>3
A simplified version that assumes a fixed base and only records the powers is described here:
http://void.wikidot.com/algorithms:polynom-encodings
Edit added the explanation of general method↵
http://void.wikidot.com/algorithms:polynomial-compression-explained

This should get you started: -

https://pastebin.com/0cyP5LGf

Naturally, heavy parallelism, chunking and maybe some sort of mutating fuzzy matching should be implemented to improve the time complexity.

Note that polynomial compression is not the only compression idea i have, the other is Xor-wave bitflipping to reduce entropy of files, which is much faster in principle but doesn't seem to help compression despite entropy results.
Its closer in principle to automata theory,
basically the bits are mutated by the following:
http://void.wikidot.com/algorithms:delta-encoding-with-bitflipping
delta is the "xor wave over the same number shifted one position"
0010101 is recorded as
0011111 where 0 is no change, and 1 is a bitflip,1's in 0011111 signify change every cell.
After N transitions the least-entropy form of number is discovered and compressed(by any suitable algorithm) along with number of transitions. The original is recovered by recovering bits from deltas . Example of 4 bit transform:
0110 delta->
0101 delta->
0111 delta-> least-entropy form 3
recovery->
0111 reverse is bits from delta.
0101 (nochange,change,change,change)
0110 (nochange,change,nochange,change)

>>5
This is evolving a CA to match your data...it has probability of being your data close to zero. Consider that a string of 256 bytes has 256^256=32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 possible combinations. That is assuming your CA even reaches all of them(most CA won't reach them).
It will take (assuming you can check 10^9 of them per second, being generous) on average
16158503035655503650357438344334975980222051334857742016065172713762327569433945446598600705761456731844358980460949009747059779575245460547544076193224141560315438683650498045875098875194826053398028819192033784138396109321309878080919047169238085235290822926018152521443787945770532904303776199561965192760957166694834171210342487393282284747428088017663161029038902829665513096354230157075129296432088558362971801859230928678799175576150822952201848806616643615613562842355410104862578550863465661734839271290328348967522998634176499319107762583194718667771801067716614802322659239302476074096777926805529.798115328 seconds or
4488473065459862125099288428981937772283903148571595004462547976045090991509429290721833529378182425512321939016930280485294383215345961263206687831451150433420955189902916123854194131998562792610563560886676051149554474811474966133588624213677245898691895257227264589289941096047370251195493388767212553544710324081898380891761802053689523540952246671573100285844139674907086971209508376965313693453357932878603278294230813521888659882264117486722735779615734337670434122876502806906271819684296017148566464247313430268756388509493472033085489606442977407714389185476837445089627566472910020582438313001.53605503203555555556 hours or
187019711060827588545803684540914073845162631190483125185939499001878791312892887113409730390757601063013414125705428353553932633972748385966945326310464601392539799579288171827258088833273449692106815036944835464564769783811456922232859342236551912445495635717802691220414212335307093799812224531967189731029596836745765870490075085570396814206343611315545845243505819787795290467062849040221403893889913869941803262259617230078694161761004895280113990817322264069601421786520950287761325820179000714523602676971392927864849521228894668045228733601790725321432882728201560212067815269704584190934929708.39733562633481481481 days or
512382770029664626152886806961408421493596249836940069002573969868161072090117498940848576413034523460310723632069666722065568860199310646484781715919081099705588491998049785828104352967872464909881685032725576615245944613182073759542080389689183321768481193747404633480586883110430393972088286388951204742546840648618536631479657768686018669058475647439851630804125533665192576622089997370469599709287435260114529485642786931722449758249328480219490385800882915259181977497317672021263906356654796478146856649236692953054382249942177172726654064662440343346391459529319343046761137725218038879273780.02300639897625976662 years.(for reference the universe is only ~13799000000 years old)
Just for a string of 256 bytes.

There is a way to compress with Conway's Game of life.
1.Load the file as final state of Conway's game of Life X/Y grid.
2.Run the algorithm in reverse to find a state which minimizes the amount of live cells.
This is the step which is problematic:
Will the number of live cells decreases or increase? Maybe some ruleset guarantees growth in one direction, that would be suitable for this task(original 23/3 ruleset is too chaotic imho).
3.Compress it with zip/gzip.
Write the file+ number of backward generations.
4.Decompress the file.
5.Run Conways game of life normally for number of generations specified.
6.Record the original file.

>> 7
I wouldn't shoot the moon and go for the whole file. Perhaps chunking it into n parts and working on those in parallel would be sensible. Part size would probably depend on what you could push through the architecture & algo as quickly as possible.

Also would it not make more sense to search for parts that only needed to be a near match? Then you could store the position in the rule30 chain with a mutation factor (bit flipping look up table) as the representation of the compressed data.

You could of course run it back through, making compression a factor of time. Alas this is all just theoretical and I'll admit might need a few qubits for a working PoC.

How else are we supposed to send a hologram through a wormhole?

>>8
that's basically a "seed" idea
see: minecraft
the seed is very short but generates an entire world

>>10
The idea is to compress the world down to the "seed" the backwards state from which CA rules evolve back the seed to the full world.
I think the problem is getting to these backward steps, as some states probably lack a "parent step" and thus incompressible
Its called "Garden of Eden pattern".
https://en.wikipedia.org/wiki/Garden_of_Eden_(cellular_automaton)

https://nbickford.wordpress.com/2012/04/15/reversing-the-game-of-life-for-fun-and-profit/

>>10
pseudo random number generators are cell 0d cell automatas?

Yes, brute force can do absolutely anything, we already know that (we've known it for a long time), and this is just another instance of it if you look at it well, the problem is the time it actually takes when we run it for real.

AI has also already been solved if you take feasibility out of the question. I remember a paper like that.

Your mother has also already stopped turning tricks for dimebags if you take feasibility out of the question. I remember a paper like that.

>>16
http://www.mindmakers.org/projects/agi-dict/wiki/Universal_theories_of_intelligence
I thought everybody knew of this event.

>>13
If you consider bits as black-white cells the pseudo random iterations are essentially automata steps applied on 1d binary string.

Bytecode really, well designed bytecode.
It's how Java did it, Shockwave replicated, Sharp's EVA competed, and
https://web.archive.org/web/20181012073633/https://en.wikipedia.org/wiki/Sloot_digital_coding_system
described.
It's not about the number=data, but the process to get to that number, that instruction.

To me, this confirms P≠NP, since you have to have instruction even to boot strap the [finite] compression scheme.

>where sender and receiver know what kind of data recipes can be transferred, without the data itself actually being sent."[4]
Wait, did Romke Jan Bernhard Sloot innovate a general quantum encoding?
It was theorized for a long time:
https://en.wikipedia.org/wiki/Quantum_computing#Timeline

This sort of thing would pop up on alt.compression every so often, surprisingly handled more kindly here. Maybe the game of Go being beaten 10 or so years ahead of expert predictions has made us a little more open minded.

>>21
Are they still obsessed with useless "random data" being incompressible? All useful subsets of data have structure and lower-entropy parts.

>>21
Open minded to mathematically impossible bullshit

>>23
I wonder how the universe was able to reduce the search space required evolve a single cell through plasma ball power stations into your kind self.

Kolmogorov complexity tells me it's not possible, you must not exist.

>>24
Too obvious
le unpolite sage

most things we observe about mathematics, physics, etc. are just emergent properties

what we really need to find is the unifying theory that explains everything

what modern STEM is is basically like studying complex patterns in conway's game of life without knowing or thinking about the basic rules that result in said complex patterns

we are studying emergent properties of cellular automata instead of the cellular automata itself

Emerge from my anus

>>3
The key problem is optimizing the polynomial into a shorter form: essentially on one side you have
sum of (x^y+z^k+m^N) subtracted by another sum (l^z+a^b+u^d) which have to balance out to a number inside the search range.

On July 11, 1999 Sloot was found dead, in his garden[2] at his home in Nieuwegein of an apparent heart attack.[1] He died one day before an attractive deal was signed with Roel Pieper, former CTO and board member of Philips.

Killed by frozen void

https://en.wikipedia.org/wiki/Jan_Sloot

data encoding technique that could store an entire feature film in only 8 kilobytes.

Lets take minimum: super jerky 8 frames per second, and 30 minutes film. That will require:
8*60*30 = 14400 (14kb), or ~0.6 bytes per frame.

I doubt you can compress even the soundtrack to that number of bytes. Even if you convert it into text, compress and do text to speech for restoration.

>>32
I don't know much about this dumb sloot, but it sounds like they're confusing compression with checksums

md5 is not compression, unless you don't mind going through every single combination to try and brute force it, if you would consider that to be decompression

>>32
The only way to restore the story of such film is to do a simulating under a set of constraints (i.e. from synopsis). But that is impossible even with modern technology.

OR maybe they were talking about vector graphics or something, like flash instead of raster graphics

also I read a little bit about h264 and i frames vs. p frames and how you can convey motion instead of individual pixels

also fax machines say pixels are white or black follower by how many are the same color contiguously

>>34
Because even film's script would be too big to produce a film from.

>>35
Consider compressing Star Wars plot into 8000kb of plain text. Of course picture is worth a thousand of words, but still...

>>37
star wars sucks ass so who gives a shit

>>37
https://www.asciimation.co.nz

>>32,35
I thought >>19 already implied it is instruction code, the difference is that it's based on a goal and result mathematical functions. f(x) -> x(f).
In Postscript, when you "draw", you're preparing statements about how a needle is supposed to plot the canvas. The printer needs transcode the plot instructions into the firmware protocol that handles the actual needle.
In the case of SDCS, I assume Stool made something similar, since at result, the monitor needs to flicker on/off the RGB dots in respect to time in its grid. He would have had to designed a basic programming language that would get transcoded into monitor instructions.
Extended Vector Animation format was extremely similar Stool's description, but I assume he was granular to his bytecode compiler.

In the case of finite compression, you would need to design a filesystem similar to the above, plotting disc or solid state data blocks. With a libre firmware for a NAND or NOR gate, it should be easier than a HDD platter.
I don't believe in infinity, but omega: the last number.
Plus, in terms of storage, we have finite physical limitations like their sizes.