A one-way function, if it should ever come to exist, would create an output file that does not allow its input file to be inferred from the output file and the algorithm alone. Many algorithms have been written in such an attempt without success.

      I am afraid I have completely lost faith in all methods (including public-key encryption) that rely on computational difficulty of an orderly sort. Over the years it seems that they all go down after a while. Here is one that may have been unexpected:

      linuxchix.org/content/courses/security/primes

      The sort of computational difficulty that I now remain focused on is the sort we have in the one-time pad. The uncertainty resides in each bit. No elementary function like multiplication or exponentiation is utilized. No bytes are manipulated or relocated - only bits.

      I started to look for sources of uncertainty. A book written in ASCII code of English sentences has a meager kind of uncertainty that got my attention: If one could attend to an arbitrary bit in the book, the very next bit is not very uncertain; but what about a bit that is a thousand bits down the file from this first bit? How related or unrelated is this bit from the first bit selected? My intuitive answer is that it must be quite unrelated. If this is true, how could this be used?

      Of course, if the book were comprised of truly random bits, the distance between two bit would not affect how related the bits were, but a copy of a random string could quickly be identified as a copy.

      There is also the mater of selecting the distance to the next bit. Each next distance to the next bit selected would need to be as arbitrarily as possible, without using a constant or an elementary function.

      In order the create an output file that disguises the source file, it has seemed best to use a source file that is random and is used not just for data (the output bits) but as a source of ever changing address offsets.

      Here is a Bitwise Transformation:

      Initial Conditions:

2**14 < N < 2**15
Random bit array X is of bit length N.
h is the greatest integer not greater than N/4.
i is the greatest integer not greater than N/2.
j is the greatest integer not greater than 3N/4.
k = 0
Integers h, i, and j are used as bit addresses (not byte addresses) in X.
Z is a bit array of bit length N.

While k is less than N

        h=(h+(The number formed by X(h), X(h+1), . . .X(h+14).))MOD N


; Each integer q of bit X(q) is calculated MOD N.
; Then, the resultant integer is evaluated MOD N to define h.
; Integers i and j are calculated the same way.

        i=(i+(The number formed by X(i), X(i+1), . . .X(i+14).))MOD N
        j=(j+(The number formed by X(j), X(j+1), . . .X(j+14).))MOD N
        Z(j)=(X(i) XOR X(h)) XOR X(j))
        k = k+1

End

-----------

      Here is the question: Is there a known method that would allow X to be inferred from Z?