Ive come up with a simple transform that can shuffle data about and is
completely reversible no matter how many times you shuffle you can
always go back to the original format. Thing is would this ever be
useful? I suppose even after a shuffle of random bytes you still have a
random set of bytes but it can be preformed as small or large blocks,
so perhaps it could shuffle to something that can be compressed
further, only problem is spotting something? I think it could be
modified to allow bytes of near values to be grouped together. It
requires no sorting algorithms and is extremely fast, only thing is if
you have for example 7 bytes to shuffle it requires 7x7 array to hold
the positions.
Anyhow back to the drawing board with this one lol.
any thoughts?

I know of no shuffling algorithm that isn't reversible.
Can you name one?

You seem to have failed to consider the size of the auxiliary
data required to make the transform reversible. Please do so,
and look up the "counting argument".

Sorry this was my point although I should have mentioned, it requires
no auxiliary data to undo the shuffle!
The array mentioned above is required for shuffling and 'unshuffling'
the data. its not required to be stored.

Graham.

"houston" <housty@hotmail.co.ukwrote in message
news:1157637569.053346.139340@
|
| I know of no shuffling algorithm that isn't reversible.
| Can you name one?
| >
| You seem to have failed to consider the size of the auxiliary
| data required to make the transform reversible. Please do so,
| and look up the "counting argument".
|
| Sorry this was my point although I should have mentioned, it requires
| no auxiliary data to undo the shuffle!
| The array mentioned above is required for shuffling and 'unshuffling'
| the data. its not required to be stored.
|
|
| Graham.

The objective is to simplify the data set for compression.

If you can order the set and then improve the odds for the standard
brute-force routines then you've got something useful.

houston wrote:
Ive come up with a simple transform that can shuffle data about and is
completely reversible no matter how many times you shuffle you can
always go back to the original format. Thing is would this ever be
useful? I suppose even after a shuffle of random bytes you still have a
random set of bytes but it can be preformed as small or large blocks,
so perhaps it could shuffle to something that can be compressed
further, only problem is spotting something? I think it could be
modified to allow bytes of near values to be grouped together. It
requires no sorting algorithms and is extremely fast, only thing is if
you have for example 7 bytes to shuffle it requires 7x7 array to hold
the positions.

Anyhow back to the drawing board with this one lol.
--
any thoughts?

does any bit within the random shuffle obtain a bit bias?

you will need some sort of count, but there are block counting methods
which are very efficient on bits.

read the counting argument and observe the use of the word argument,
and not proof.
(proof by negation has relative context of proof, and may not always
hold)

understand that if it can be used in absorbative compression, then any
fixed size extra information which has to be stored, is not too much of
a problem, as many more bits can be absorbed.

99% of people who quote the counting argument have no concept of its
bounds in relation to use within a system which takes an input string
and makes a mapped output string, and not systems which take an input
string, and change the bit pattern represented in a fixed number of
bits, depending on the input string.

i.e. only applies to system where a extension of the input data leads
to an extension of the output data, and not to systems where extension
of input data leads to more changes of the fixed size output bit
pattern.

cheers

Willem wrote:
houston wrote:
) Sorry this was my point although I should have mentioned, it requires
) no auxiliary data to undo the shuffle!

Yes it does.

he knows that he is psychic, so don't argue ;-)

>You need at least one bit to indicate if you have shuffled
the data or not.

unless you always shuffle

If you shuffle it more than once, you need a counter
to say how many times you shuffled.

not times, but blocks you've shuffled.

If you have more than one possible
shuffle then you need an indicator to say which possibility you used.

unless the goal is one shuffle only.

check http://indi.joox.net go to the bottom of the page, open the
opensquirt folder, read the opensquirt pdf for another shuffle
alogorithm, which some people sense thru the 'super mind wave eather'
to be useless too. ;-)

cheers.

lol I thought this may cause a bit of a interest lol I've been
working on this for some time I have come up with a way to "yes"
shuffle data that can be reversed no mater how many times you shuffle
the data! thing is I'm not sure if its really what you would call a
shuffle? how would you define a shuffle its kinda obscure? and no data
is required to be stored to undo or do the transformation I've been
stuck for lets say several months trying to make more sense of what can
be achieved with this! I do think however that it may be possible to
sort the data into some kind of pattern that would make it very
interesting. It's also the reason why I've been interested in
compression recently. I've agreed tho a dead-line for my own working's
on this, and if I've not solved then I will reveal how I've achieved
this

mean points:
no data stored not even a single bit changed in the stream.
can be transformed any amount of times.
can be fully undone.

Graham.

Can this be said for any signal?

For instance there are two possible signals using one bit.
They are

0 and 1.

If I select one, can you tell me which your transform started with?
how many times it was performed?

To do so you must add information. And this is true for a signal of
any length.
It does not matter if the signal is entirely random or completely
redundant.

Before you go any further you might choose a simple example like 1 or 2
bits and see
if your transform, without overhead, works. It should not take long
for you to see
that it logically can not.
- Michael

houston wrote:
lol I thought this may cause a bit of a interest lol I've been
working on this for some time I have come up with a way to "yes"
shuffle data that can be reversed no mater how many times you shuffle
the data! thing is I'm not sure if its really what you would call a
shuffle? how would you define a shuffle its kinda obscure? and no data
is required to be stored to undo or do the transformation I've been
stuck for lets say several months trying to make more sense of what can
be achieved with this! I do think however that it may be possible to
sort the data into some kind of pattern that would make it very
interesting. It's also the reason why I've been interested in
compression recently. I've agreed tho a dead-line for my own working's
on this, and if I've not solved then I will reveal how I've achieved
this
--
mean points:
no data stored not even a single bit changed in the stream.
can be transformed any amount of times.
can be fully undone.
>
>
>
Graham.

"Phil Carmody" <thefatphil_demunged@yahoo.co.ukwrote in message
news:87hczhwo2t.fsf@nonospaz.fatphil.org
| "michael" <michael@michael-maniscalco.comwrites:
| Can this be said for any signal?
|
| Can what be said? Please don't top post.
|
| houston wrote:
| no data stored not even a single bit changed in the stream.
|
| Do you think that he's simply proposing 'cp' as a compression
| program? That indeed works equally well an infinite number of
| times on the same data.
|
| Phil
| --
| "Home taping is killing big business profits. We left this side blank
| so you can help." -- Dead Kennedys, written upon the B-side of tapes of
| /In God We Trust, Inc./.

Nah, I'm imagining a basic 9x9 puzzle-square shuffle routine
(2-directional remapping) with sliding an open spot about to achieve order.

The other option is an ordered shuffle on complex data sets (a linear
1-directional remapping swap squares #1 and #7 then move to next
square). a pseudo-random shuffle doing the previous line using the
generated numbers for reordering. using a complex set shuffle (same
thing 2 sentences back) using some large generator like roots of prime
numbers, non-integer decimal base conversions, or formulaic methods.

taking this one step further and going for the very first sentence
and doing a multi-dimensional array using a 3-directional mapping in cubic
space or higher orders. course once we go into non-cubic space arrays we
can go with complex 3-directional regular mapping tiles. We can move to
toroidal-spaces or hyper-surface remappings of a dataset.

The problem is again the very core of higher-order compression routines.
The resulting data set has to be smaller than the index mapping and / or the
dynamic function listings. No point in pushing data about without having a
reduction in the overall data set (that would be bijective at best and
additive at worst).

And everyone knows that the ushers won't let you sneak about the various
bijective arrays without buying a large soda and enough corn in a buttery
tub to pack a human intestine (yeah, David, this was an amusing campaign to
get the compression community to use the word "Bijective" for no good
reason, but also an annoying campaign) as they don't earn money off the
movies but the overpriced snacks.

Anyhoo, the crucial thing for any of us folks here is basic to the core.
Show us a repeatable example of dataset reduction with lossless recoverable
results without any boring showmanship or sales pitches and we'll be a tad
more serious. If you have an advanced form of dataset reordering which can
result in better compression, then we have interest. Theory is all well and
good for idle chatter with pleasure-inducing substances in a casual setting,
but proof requires you produce a functional bit of code which can compress
and decompress general datasets or specific common useful datasets (think
JPEG, MPEG, MP3, etc) or some tool that results in better results using
an existing compression technique. If math theory cannot be functionally
coded into a computer program, then well, refine it until it works or redo
the theory.

I love great theory, but it has to lead somewhere or the theory is just
a philosophical hobby and usually less entertaining than a digital
self-pleasuring session. So toss us a few clues that we can use dude or
show us some amusing Photoshops.

all taken aboard!; as I said I've given myself a set dead line to come
up with an improvement after this I will provide how this is done to
the group I'd first like the chance to improve and make it into
something useful for compression as for now I cant see how its useful?
its resulting in somewhat random data but yes I stand corrected
William yes I do retain a count of how many times its been shuffled
thing is this is a single global count resulting in a single byte no
matter how big the data source is originally. okay its a byte if below
256 turns. lol

so for a file of say 30meg to be shuffled I only need a single byte to
hold the count hope this clears the confusion up a little
apologies.

Graham.