https://0x0.st/8-v7.pdf  (nothing malicious, just an embedded svg)

The code for this is not really worth showing, because it's a very ugly 
hack 
grafting "svgo" on top of "treeprint". 

Special thanks anyways to ajstarks and xlab at github; although, did anyone 
else have a problem installing "svgo" lately? Command line get did not work 
for me, some error I couldn't yet understand. I ended up installing 
manually. 
Maybe because my version is the 18.1 served through linux apt?

Anyways, here's an example script for using treeprint that will help some 
college students figure out how to move pointers around: 

https://oeis.org/A379183/a379183.go.txt

Suggestions about style or usage are welcome if necessary. If not, then 
you're 
welcome to skip to the output: 

https://oeis.org/A379183/a379183_1.txt

This one is worth looking at for many reasons, but essentially it's just a 
nice 
counter-example to the fractal structure of the tree found in Hofstadter's 
book GEB ("Hofstadter's G sequence"). 

Fun stuff, and headed for a full length explanation built all on top of 
golang 
calculations and figure drawing. 

The calculations are where golang will beat competitors producing a lot of 
data and running into memory limitations rather than compute. 

For example, here is a mystery about the Fibonacci Word Fractal, which I've 
just recently gotten the first clue to solving: 

https://oeis.org/A171587/a171587.go.txt

This is the (filtered) output up to hitting memory constraint on kind of a 
cheap laptop with not much space:

[0 0 0] 
[1 0 1 0] 
[0 0 1 1 0 0] 
[1 0 1 1 0 1 1 0 1] 
[0 0 1 1 0 1 1 0 0 1 0 0 1 1] 
[1 0 1 1 0 1 1 0 0 1 0 0 1 0 0 1 1 0 1 1 0 1]

And then I guessed the next term would be: 

[0 0 1 1 0 1 1 0 0 1 0 0 1 0 0 1 1 0 1 1 0 0 1 0 0 1 0 0 1 1 0 1 1 0 0]

(Someone with a better computer might actually be able to just 
check this editing one parameter in the script.)

This is a turns sequence. Using svg or even png, you can plot it, and
if you flip either the first bit, the last bit or both, it should become a 
fragment of the fractal curve seen here: 

https://oeis.org/A171587/a171587.png

Based on the bit flipping property, I think it will be possible to prove 
the irreducible missing words as follows: 

Some recursive construction builds these particular curve fragments, 
which are known valid. Then bit flipping the ends is guaranteed to 
invalidate them. 

However, that still falls short of explaining why these are the **only** 
missing words, so I think this mystery will persist for a while. 

I'm not asking for help. I'm not asking for anyone to go unemployed 
to prove something about math. I'm not looking for jokes about who 
develops what, and who has a disability, etc. etc. 

I've read the code of conduct. It sounds good to me depending on 
how seniority is leveraged for gatekeeping purposes. 

If "Beginner Mind" is appreciated, then it might be possible for me 
to become a vocal golang user and contributor. We'll see. 

If anyone wants to co-work with me, I'm open to making friends and 
writing papers, and I'm also looking for a job opportunity (resume / CV
available on request). 

This Fibonacci proof is something frivolous and extra that's just now 
surfaced. In the paper I'm calling it an "Aperitivo". Some of my other 
project ideas are more substantial. 



Thanks again for your time and efforts. Nice tools you have here. 



Best wishes for 2025, 







--Brad












 

 








  




-- 
You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion visit 
https://groups.google.com/d/msgid/golang-nuts/5f1e89e9-d3ae-417f-94cb-0da0f21a4e28n%40googlegroups.com.

Reply via email to