184400+ entries in 0.11s
sina: yes but your reading of
the footnote does seem correct, it starts at 1
ben_vulpes: i'm
trying
to remember why i indexed at 1
there
ben_vulpes: one difference is
that you loop from 0 up and i from 1
sina: I only mean in
the sense, glaring errors or differences
that cause disagreement between implementations, should be obvious
ben_vulpes: mircea_popescu: and i worked
this example at one point, i'm pretty sure
the expected value of 011 is correct
sina: ben_vulpes: also per above my halfscrew won't
take any action if
the len(a) is 1, can you confirm cl behaviour?
sina: also
testing with pypy
sina: I dunno, I keep deleting
the debug statements
sina: currently
trying 2048bit hash of GPLv2 out of curiosity, will lety ou know when it finally completes :P
mircea_popescu: and are very explicit : screwing iteration 22 screwing product is 946 index of element
to flip is 18 etc
sina: changing it
to
the value of
the iterator per ben_vulpes cl code fixed it
sina: I had it originally set
to
the value of
the bit, and
that was
the cause of my cycle
sina: it's
the value of
the iterator, not
the value of
the bit at
the iterator position?
sina: mircea_popescu: can you confirm/clarify "his operation consists of
taking
the bit count of either S or R, iterating over
that value, at each step multiplying
the iterator with
the current position in M" ...
ben_vulpes: yes i know, asking if
that hasa your fixed screw method
sina: mircea_popescu:
there was a bug in my screw method which caused
the cycle, once I identified it, it stopped cycling
mircea_popescu: i don't readily see a problem with
the story as displayed.
PeterL: just something
to
think of for future versions of
the hash
mircea_popescu: though in principle
the mpfhf is a function fambly -- anyone can make any sort of
thing he wants
mircea_popescu: PeterL
the problem is
that even as is
the complexity is pretty hard
to manage. making more complex primitives is not going
to help
this
sina: I keep
taking
the debug lines out because it's fucking impossible
to follow
the logic of
the code with
them in
PeterL: I had an idea for another function
to use in
the fabulous hash: a conditional screw - where on step n, for i in length S, if S[i]
then flip R[n*i mod len(R)]
sina: cos I
test with "M = [1] * 32"
mircea_popescu: see, i suspect ben_vulpes 's
thing has a subtle bug in it but i can't seem
to find it ;/
sina: I feel like my code is now correct, and it no longer loops. However I'm getting different results
to ben_vulpes
sina: mircea_popescu: ok
thanks
sina: mircea_popescu: earlier you said half screw should round down. In
that case, if len is 1
the halfscrew will be 0. so should no iterations be peformed on halfscrew where
the len is 1?
sina: the log msgs make it much harder
to follow
the code unfortunately, my code has
the same issue :(
ben_vulpes: in
the interim sina do feel free
to read what i've written and generate data
to compare yours against
ben_vulpes: i do actually enjoy
the humans i keep in my house, amazing
though
that may seem
ben_vulpes: "my own
time" meaning when i feel like it
sina: ben_vulpes: any chance you'd be willing
to
take a peek at my code>?
mircea_popescu: ben_vulpes i shall now withdraw into my cellar with
the instruments.
mircea_popescu: you prolly still have a bug in
there
though, just no longer on
this case.
sina: making
that modification and my
thing no longer loops
mircea_popescu: ben_vulpes mind making
the alterations and let's see ? ima edit
the spec later
too
mircea_popescu: if 1, half-screw S in R. If
the bit in R found at
the position equal
to
the remainder of
the division of our position in M by
the size of R is equal
to
the bit in S found at
the position equal
to
the remainder of
the division of our position in M by
the size of S
mircea_popescu: you mean
to
tell me
the idempotent value for mpfhf is actually ff ?
mircea_popescu: Our work has ended, in 4 steps and using 1 bits for
the state machine.
The message was #*1111 and
the resulting hash is #*1111
ben_vulpes: on uniform inputs and shorter desired output hashes it has
trouble breaking out of certain patterns
mircea_popescu: skipping ahead, Our work has ended, in 141 steps and using 96 bits for
the state machine.
The message was #*1001101101000010000011010111101001110001111010111110011100000110000111100111110011100001 and
the resulting hash is #*0010011100
mircea_popescu: element is now #*1010000000 << ok, seems
to make sense up
to
there.
ben_vulpes: mircea_popescu: perhaps
to start with simpler runs?
mircea_popescu: ben_vulpes ok, so was
that a half-screwing of s in r and s was 1 bit long so it did nothing ?
mircea_popescu: R bitcount is 10 in
this case ; S bitcount starts at 1.
mircea_popescu: screwing #*0000000000 at position 0 with count 0 <<
the problem. it is not possible for a bit count
to be 0.
mircea_popescu: screwed element is now #*0000000000 <<
this is not possible, you screwed nothing
ben_vulpes: kinda
thinking i should just maintain a "mpfhf currently backing candi" on
that page
ben_vulpes: also output hashes larger
than a certain size won't post because reasons i haven't run down yet
ben_vulpes: logs are not exactly
the same, bridging will be required until i match
the hashonator's log format
mircea_popescu: paste your story. and plox use wotpaste i dun have
that paste.ca
thing in hosts
sina: it seems
to be flipping correctly :(
sina: lol,
that changed it a little, now I loop at step 71 instead of 5 :P
sina: so, do we rewind, and
then still increment?
sina: mircea_popescu: per
the spec, " During each step,
the function considers whether
the position-th bit in M is 0 or 1, and executes a defined set of operations in either case. Once
the operations have been executed,
the position is incremented by one."
sina: damn debug statements make it impossible
to follow
mircea_popescu: That bit in R is flipped and we rewind. <<
the definition of
the op makes cycles impossibru as such
sina: mircea_popescu: pls help me understand rewind? doesn't it guarantee loops if I end up in a step which has a rewind? because I will go back one and
then rewind?
sina: gonna have
to switch looping mechanism
sina: hmm, I don't
think my rewind is working
sina: would you be willing
to look?
sina: I seem
to be generating junk hashes like "1001001110000000000000000000000000000000000000000000000000000000" for "MP kicks ass!" :(
sina: mircea_popescu: can you point if I'm missing something obvious? From my understanding of
the spec,
the number of "steps" is =
the length of M, but in your examples (understanding
they're of a nonworking prototype) have a lot more steps
than len(M)
ben_vulpes: i did push some changes
to it last night, but it still behaves entirely wackadoodle on arrays of all 0 or 1
mircea_popescu: im sure it does
that, but, simplifies checking. do a few printouts of something shorter and saner, say 16 bit items.
sina: so much less pretty
tho
ben_vulpes: going
to spend some people
time, will let you know when it's live
sina: fuckers, ok I will add
the debug back
ben_vulpes: sina, i have a patch sitting in my
tree
that will paste output as well
sina: because I
thought it makes my pretty code look ugly
sina: mircea_popescu: lollll I had it doing
that but removed
those lines
mircea_popescu: sina can you make it print out some detailed workout like
the original prototype did ?
sina: how
the fuck am I know my code works
sina: lel ok
that is not
the output
that I got :(
candi_lustt: sina: 290 steps, 249 bits for
the state machine. hash: #*1000100011110010000101100110011011011001111000011110110011111001
sina: ah good, python by default adopts
the C behaviour
sina: mircea_popescu: can I ask you
to verify behaviour of half screw when
the length of S or R is not even?
mircea_popescu: cool. seeing how ben_vulpes ' lisp implementation ain't working yet, you have a shot at becoming
the first cannonical mpfhf
sina: got most of a
thing working