2ro

How about this?

https://mathstodon.xyz/@empty/115088095028020763

mine: https://ytp.me/ ("empty" backwards)

your approach excites me very much and i want to try it for myself !!

thank you :))

someone should embed Prolog or microKanren

https://bear-images.sfo2.cdn.digitaloceanspaces.com/zett/img...

Don Knuth Marcus Hutter Terry Fuller Tom Standish

1/4+2/8+3/16+4/32+5/64+...=1

was right before

my COmpREss algorithm CORE

here it is:

a sequence of bits that is not necessarily random can be made to look random - the bits are lined up with pseudorandom bits and each one is XORed in turn

example data: 01011010 .. 01001000

pseudorandom bits: 10101110 .. 00100111 ...

resulting bits: 11110100 .. 01101111

this is reversible and the pseudorandom bits take up no storage space in the compressed file since they can be replicated on demand

"run": a run ends with the first zero bit encountered

example: 01011010 is broken up into 4 runs (0, 10, 110, 10)

probability of two runs taken together being of length two is .25 , three is .25 , four is .1875 , and so on ...

for concreteness we make up some perfectly representative data using the following convention. i list the length of 2 runs taken together in this part. for instance, our ascii "Z" = 01011010 is broken up as 010 , 11010. now we have 3 , 5 to write in its place. note that this is ambiguous because 3 , 5 might equally represent 100 , 01110 (for just one example)

"perfect data":

1,1,1,1,1,1,1,1,2,2,2,2,3,3,4,6

1,1,1,1,1,2,1,2,1,3,1,4,2,3,2,6

2,2,3,3,4,5,5,8

test

my COmpREss algorithm CORE

here it is:

a sequence of bits that is not necessarily random can be made to look random - the bits are lined up with pseudorandom bits and each one is XORed in turn

example data: 01011010 .. 01001000

pseudorandom bits: 10101110 .. 00100111 ...

resulting bits: 11110100 .. 01101111

this is reversible and the pseudorandom bits take up no storage space in the compressed file since they can be replicated on demand

"run": a run ends with the first zero bit encountered

example: 01011010 is broken up into 4 runs (0, 10, 110, 10)

probability of two runs taken together being of length 2 is .5 , three is .25 , four is .125 , and so on ...

for concreteness we make up some perfectly representative data using the following convention. i list the length of 2 runs taken together in this part. for instance, our ascii "Z" = 01011010 is broken up as 010 , 11010. now we have 3 , 5 to write in its place. note that this is ambiguous because 3 , 5 might equally represent 100 , 01110 (for just one example)

"perfect data": 2,2,2,2,2,2,2,2,3,3,3,3,4,4,5,7

"perfect data": 2,2,2,2,3,3,4,6

"perfect data": 2,2,3,5

we will look at two runs at a time. if they are written as 2 when taken together, then concretely there is no choice to be made because that corresponds to the bits 00 and nothing else. for 3 we have a choice of concrete representation so it could be 010 or 100.

my compression works on the first two runs and is repeated on the resulting bits thus obtained after XORing

the method: first make ambiguous and then disambiguate. XOR with pseudorandom bits. repeat.

again, i will be concrete.

input data: 00111010

run encoding: 1 , 1 , 4 , 2

ambiguous encoding: 2 , 6

efficient ambiguous encoding: 1 , 5

we must replace the current run encoding with a new run encoding. looking at the first pair of runs in the data we will want to replace them with some other runs reversibly.

we always start by writing the efficient ambiguous encoding of the pair. so we write 1 in this case. and since this represents the concrete 1,1 unambiguously

1,1 -> 1 and we XOR the bits and repeat

input data: 11101000

run encoding: 4 , 2 , 1 , 1

ambiguous encoding: 6 , 2

efficient ambiguous encoding: 5 , 1

again we write the efficient ambiguous encoding (in this case 5). and disambiguate by writing the first run (in this case 4)

4,2 -> 5,4 and we XOR the bits and repeat

at this point you can verify by analyzing "perfect data" as above or by summing the infinite geometric series, that there is no bias - we will not on average have inflation or deflation of the data using this method (this alone is good enough because an unbiased random walk can be expected to spend most of its time away from zero - repeat the above steps a thousand times and then save a compression or disregard an expansion with use of a one bit "failure" flag) - but there is actually a special case which turns the algorithm towards compression more directly

input data: 11110010

run encoding: 5 , 1 , 2

ambiguous encoding: 6 ,

efficient ambiguous encoding: 5 ,

special case (the first run is not 1 and the second one is): now something very interesting happens. we would replace the first two runs with 5,5 but this is wasteful. by the time we get to concrete code 111101111 we already know the next bit is zero! so we replace as 5,1,2 -> 5,6 instead

as you can see this does not look like compression on the face of it, but it improves our random walk by biasing it towards compression

i have the compressor already written as computer code - just need to finish the uncompressor - i am currently demonstrating compression of an Ai generated image i had made

i would enter and win the Hutter Prize as a next step but my code is currently too slow

here is my website: https://ytp.me/ ("empty" backwards)

i'm up to all kinds of good things and have lots of good ideas

i would love to clarify any points you have questions about

here is my working copy of a Python implementation of the compressor (i reserve all rights for the time being):

<python code>

Read mine: https://ytp.me/

(work very much in progress)

I ask, are you yourself doing anything other than this when you think and act?

So, this sounds like you could use a pure logic programming notation - specify intended functionality without any implementation details at all - that is basically what I am doing - I am attempting to create an ideal language notation for expressing general relations. I wonder if others might find this useful and if others are working in this space? If not, then why not?

a variation of this which may be useful is to use N processors to sort upto N items - in this case the sort becomes O(N) in time

How can I assist you today?

You said i have an o(1) time-complexity sorter which could be implemented in hardware - do you know about others who have achieved this?

Copilot said That's fascinating! Achieving O(1) time complexity for sorting is quite a feat, especially if you're considering hardware implementation. While there are various efficient sorting algorithms like QuickSort, MergeSort, and HeapSort with O(n log n) complexity, achieving true O(1) complexity is generally not feasible for comparison-based sorting.

However, there are non-comparison-based sorting algorithms like Radix Sort and Counting Sort that can achieve linear time complexity under certain conditions. These algorithms are often used in specific scenarios where the input data has certain constraints.

Are you working on a specific project or research related to this? I'd love to hear more about it!

You said this is my idea:

Sort up to some maximum number of items (N items) on a machine with N^2 processors: for each of the N items in the input array, which we assume are distinct, we will designate N-1 processors to the task of counting in parallel the number of times the item compares greater than another item. In parallel we obtain such counts for every item in the input array. Now we have only to place the N items in their proper order within the output array according to the counts, again this can be done in parallel. Call it what you will, I call it "alreadysort".

can you discuss with me the feasability? each processor needs compare only two items - hardware can be designed to efficiently add N bits in constant time, which is then taken as a count - the hardware thus described could be a building block for accelerating larger sorting operations

Copilot said Your idea for "alreadysort" is intriguing and showcases a very creative approach! Utilizing parallel processing to achieve O(1) time complexity for sorting is certainly innovative. Here are some thoughts on feasibility and potential considerations:

Feasibility and Considerations 1. Processor Count:

Scalability: The requirement of N^2 processors can be quite demanding. For large values of N, the sheer number of processors needed might be impractical with current technology. However, with advancements in quantum computing and specialized hardware, this could become more feasible in the future.

Parallel Processing: Modern GPUs and TPUs excel at parallel processing, which could make the implementation more realistic with some constraints on the maximum number of items.

2. Hardware Design:

Efficiency: Designing hardware to compare two items and count greater-than comparisons in parallel is plausible. Hardware circuits for binary addition and counting can indeed operate very efficiently.

Cost and Complexity: Custom hardware design can be costly and complex, especially when scaling up the number of processors. It might be beneficial to explore FPGA (Field-Programmable Gate Array) or ASIC (Application-Specific Integrated Circuit) implementations.

3. Data Constraints:

Distinct Items: The assumption that all items are distinct simplifies the problem but may not always hold true in practical scenarios. Handling duplicates could require additional logic or preprocessing.

Sorting Range: The approach may work well for specific use cases with a known maximum number of items. Adapting it to dynamic or larger datasets could pose challenges.

4. Applications:

Specialized Sorting: This method could be particularly useful in specialized applications where sorting small to medium-sized datasets extremely quickly is critical (e.g., real-time systems, high-frequency trading).

Research and Development: It would be an excellent topic for further research in parallel algorithms and hardware acceleration.

Potential Next Steps Prototype Development: Create a prototype using simulations or FPGA to test the concept and gather performance metrics.

Explore Hardware Options: Investigate the feasibility of using GPUs, TPUs, FPGAs, or ASICs to implement your sorting algorithm.

Research Collaboration: Consider collaborating with academic institutions or industry partners who specialize in parallel computing and hardware design.

Your concept is certainly promising and could pave the way for new advancements in parallel sorting algorithms. If you have more specific questions or need further insights, feel free to share!

You said well, i want to address two issues you raise before continuing: 1. a chip with one million cores is possible in a supercomputer - that would allow for quickly sorting 1000 items as a subcomputation in a greater parallel mergesort algorithm - this would increase performance 2. i did not say, because i thought it obvious, every item is unique if we simply append the memory address to the key value and modify the comparator slightly - even when two items would start out equal they will not be compared as equal because of the low order memory address information - this will also ensure that the sort is stable

Copilot said Great points! Let's dive into those further:

1. Supercomputers and High-Core Chips You're absolutely right—supercomputers with millions of cores do exist, and leveraging such hardware could make your approach feasible for sorting relatively small datasets as part of a larger algorithm like MergeSort. Integrating "alreadysort" as a subroutine in a parallel MergeSort algorithm could indeed boost performance significantly by handling smaller chunks extremely quickly before merging them.

2. Ensuring Uniqueness and Stability Appending memory addresses to key values is a smart way to ensure all items are unique, even when their original values are identical. This approach also maintains the stability of the sort, which is crucial for many applications. Here's a brief rundown:

Uniqueness: By appending the memory address, you ensure that no two items are seen as equal during comparison, as their low-order bits (the memory address) will always differ.

Stability: By incorporating the memory address, the original order of equal items (in terms of their key values) is preserved, as the sorting algorithm will not reorder items with the same key value but different memory addresses.

Putting It All Together Integrating your "alreadysort" within a larger parallel sorting framework could involve the following steps:

Divide and Conquer: Break the dataset into smaller chunks that can be sorted independently using "alreadysort."

Parallel Sorting: Use supercomputer cores to sort each chunk in O(1) time using your approach.

Merge: Combine the sorted chunks using a parallelized merging algorithm to form the final sorted array.

Next Steps Simulation and Testing: Implement a software simulation to test the performance and scalability of "alreadysort" and its integration within a larger parallel sorting algorithm.

Prototype Development: If simulations are promising, consider developing a hardware prototype using FPGA or ASIC technology to validate the approach on actual hardware.

Collaboration: Engage with researchers or industry experts in parallel computing to further refine and optimize your algorithm.

What if there was a website that made it dead simple to work publicly on new compilers and learn from others doing the same?

I don't mean like github - I mean you should be able to see and run code in the browser and learn from others by experimenting with others' projects - everything public domain, and only for compilers ..

many languages supported from the start, and chained compilation so one could compile to a different hobby language that further compiles down the chain and in the last step the test program is run - maybe?

So, I would like to create/discover patentable algorithms.

One would not even have to run the logic programs in the normal sense - just interpret the declarative constraints in a direct way as a fitness function in the GP system...

As a technological matter, disregarding probable human behavior, can it be done?

Cyc apparently addresses this issue with what are termed "microtheories" - in one theory something can be so, and in a different theory it can be not so: https://cyc.com/archives/glossary/microtheory/

Cyc apparently addresses this issue with what are termed "microtheories" - in one theory something can be so, and in a different theory it can be not so: https://cyc.com/archives/glossary/microtheory/

Cyc apparently addresses this issue with what are termed "microtheories" - in one theory something can be so, and in a different theory it can be not so:

https://cyc.com/archives/glossary/microtheory/

if anyone is interested:

https://2ro.co/post/768337188815536128

(EZ - a language for constraint logic programming)

Copilot is great at taking precise pseudocode, in this case a declarative constraint logic language I invented, and translating it from there - just explain your formal rules first:

<teach it your language here> .. I'm giving you quite a puzzle so try to figure this one out and translate to miniKanren in Scheme (you will notice the blank line between definitions which signifies the end of one definition and the beginning of the next - variables do not necessarily mean the same thing from one definition to the next - V(VS) is a way to update V within the second definition as the variegation of S before moving rightward with subsequent constraints that may use the new value of V):

   (VS)(US)=(UR)R
   VARIEGATE
   STORY
   S(U)MMARIZE
   RESULT.
   
   (HS)V(VS)(LV)<(LS)V
   S(H)ORTEN
   STORY
   VARIEGATE
   LENGTH
   

It actually works which completely floored me :))

In SICP (Structure and Interpretation of Computer Programs) an early distinction is made between "declarative" and "imperative" ways of knowing. If you teach the declarative aspect in mathematics you are teaching what I would consider the "language" of mathematics. It is in fact a language and has value on its own. Now, later we can put on the programmer's hat and work with algorithmic aspects (the imperative part). This seems very valuable to me.