←2020-04-06 2020-04-07 2020-04-08→ ↑2020 ↑all
00:22:15 <zzo38> Actually, I like the idea of the ability counter which allows it to band with other creatures that also have that counter. (Tokens will not work so well in this case.)
00:34:17 <esowiki> [[Talk:Minimal operation language]] M https://esolangs.org/w/index.php?diff=70676&oldid=70660 * PythonshellDebugwindow * (+231) /* Clarification */
00:36:07 <esowiki> [[Minimal operation language]] M https://esolangs.org/w/index.php?diff=70677&oldid=70672 * PythonshellDebugwindow * (+31) /* Gotos */ I see why you were cobfused
00:37:50 <esowiki> [[Talk:Minimal operation language]] M https://esolangs.org/w/index.php?diff=70678&oldid=70676 * PythonshellDebugwindow * (+38)
00:40:34 <esowiki> [[Esolang:Sandbox]] M https://esolangs.org/w/index.php?diff=70679&oldid=70581 * PythonshellDebugwindow * (+67)
00:43:49 <esowiki> [[Esolang:Sandbox]] M https://esolangs.org/w/index.php?diff=70680&oldid=70679 * PythonshellDebugwindow * (+2)
00:44:19 -!- baidicoot has quit (Ping timeout: 265 seconds).
00:47:12 <esowiki> [[Brains]] https://esolangs.org/w/index.php?diff=70681&oldid=24741 * LegionMammal978 * (+39) fixed link
00:50:51 <esowiki> [[Brainstack]] M https://esolangs.org/w/index.php?diff=70682&oldid=69681 * LegionMammal978 * (+14) fixed title
01:15:29 -!- baidicoot has joined.
01:18:58 -!- xkapastel has quit (Quit: Connection closed for inactivity).
01:38:14 <esowiki> [[Special:Log/newusers]] create * Oatmealine * New user account
01:51:11 -!- baidicoot has quit (Ping timeout: 265 seconds).
02:13:06 -!- Phantom__Hoover has joined.
02:17:21 <tswett[m]> Man, the axiom of choice sucks.
02:19:09 <tswett[m]> Also, equating cardinality with size.
02:20:25 <tswett[m]> We all know that R has a greater cardinality than N. But I don't think we should define "bigger" as "having a greater cardinality", and so I don't think we should necessarily consider R to be *bigger* than N.
02:41:45 <zzo38> Then how should you define "bigger"?
02:53:15 <tswett[m]> I don't think "bigger" necessarily needs to mean anything.
02:54:15 <zzo38> OK
02:54:22 <tswett[m]> Though of course, from a practical standpoint, it's *useful* to use the word "bigger" to mean "having a greater cardinality".
02:55:12 <zzo38> Yes, that's what I thought.
02:56:19 <tswett[m]> Just like it's useful to use the word "open" to mean "containing a neighborhood around every point".
03:04:54 -!- Phantom__Hoover has quit (Ping timeout: 240 seconds).
03:14:54 <esowiki> [[Folders]] M https://esolangs.org/w/index.php?diff=70683&oldid=70673 * Rottytooth * (+0) type correction
03:50:17 <esowiki> [[Special:Log/newusers]] create * Softengy * New user account
03:55:59 <esowiki> [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=70684&oldid=70651 * Softengy * (+176)
04:25:31 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
04:32:00 <esowiki> [[Talk:Brainfuck algorithms]] M https://esolangs.org/w/index.php?diff=70685&oldid=68845 * Softengy * (+237)
04:41:50 <esowiki> [[ELIP]] M https://esolangs.org/w/index.php?diff=70686&oldid=24473 * IFcoltransG * (+30) Added category
04:42:32 <esowiki> [[ELIP]] M https://esolangs.org/w/index.php?diff=70687&oldid=70686 * IFcoltransG * (+1) Fixed category
04:43:24 <esowiki> [[ELIP/Unlambda]] https://esolangs.org/w/index.php?diff=70688&oldid=24425 * IFcoltransG * (+30) Added category
05:05:50 <esowiki> [[Special:Log/newusers]] create * DomJob * New user account
05:26:17 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=70689&oldid=70684 * DomJob * (+249)
05:26:24 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70690&oldid=66763 * DomJob * (+286) Added an algorithm for x or y
05:56:00 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70691&oldid=70690 * Int-e * (+45) /* z = x or y (boolean, logical) (wrapping) */ golfing
05:57:00 <esowiki> [[Brainfuck algorithms]] M https://esolangs.org/w/index.php?diff=70692&oldid=70691 * Int-e * (-1) /* z = x or y (boolean, logical) (wrapping) */ match indentation
06:01:10 <int-e> weird page, that
06:01:50 <int-e> way too many different styles of commenting the code
06:03:29 <int-e> Oh, there's a convention for temporary location introduced at the very top, that resolves some of the confusion.
06:31:16 <tromp> int-e: the generalized rule gives no TODO's up to 31, 6 for 32 (of which 4 are handled by another rule), and only 3 for 33
06:41:38 <tromp> and only 15 on 34
06:42:20 <tromp> including the 5*2^16+6 one
06:43:03 <tromp> largest non-TODO at 34 is 27380
07:04:01 -!- MDude has joined.
07:15:38 <tromp> starts swapping at 35 after finding 12 TODOs
07:16:58 -!- arseniiv has joined.
07:17:56 -!- imode has quit (Ping timeout: 265 seconds).
07:22:03 -!- Phantom__Hoover has joined.
07:23:56 <int-e> tromp: impressive. I wonder how far this can push the halting probability.
07:30:09 <tromp> still focussing on BB for now, which is less arbitrary than blc halting probability (which depends on my IO conventions)
07:34:00 <tromp> can you check the generalization in BB.txt ?
07:39:41 -!- laerlingsap has joined.
07:40:25 <int-e> I will get around to it.
07:42:11 <int-e> I am tinkering more on the AIT side of things though... I've decided I don't like the KP definition all that much, because programs can cheat too easily (looking ahead on the input) and once you enhance the universal machine to prevent that, it can actually compute the tail itself.
07:44:23 <int-e> (KP is the definition where programs are supposed to produce pairs <o,xs> where o is the result and xs is the unconsumed input; my tinkering basically drops the xs part.)
07:54:42 -!- izabera has changed nick to flawful.
07:55:03 -!- flawful has changed nick to izalove.
07:55:28 -!- izalove has changed nick to iza.
07:55:57 -!- iza has changed nick to izakitten.
07:56:03 <tromp> i thought programs couldn't cheat
07:56:30 -!- izakitten has changed nick to izabera.
07:58:14 <tromp> as they can never apply the z in U(p:z)
07:59:03 <tromp> how is dropping the xs part different from using KS ?
07:59:24 <tromp> oh, no input end marker, ok
08:02:51 -!- sebbu2 has joined.
08:03:28 <int-e> Yeah, the end of input is determined by the last cons (if any) that is forced during evaluation evaluation to normal form.
08:04:41 <int-e> It's actually fairly pleasant to define (much in contrast to Chaitin's universal machine, which I find quite crazy) if you use open lists with nil = omega (ensuring the absence of a normal form when the tail is inspected by the program).
08:05:46 -!- sebbu has quit (Ping timeout: 256 seconds).
08:07:23 <int-e> (Chaitin's machine (from his thesis/book, chapter 6) evaluates all prefixes and suffixes together with the given program and takes the result of the first one to terminate... in order to ensure prefix-free programs. Which makes it awful to actually implement...)
08:07:41 -!- laerlingsap has left.
08:10:17 <int-e> Err, just the input, not the (lisp-ish) program itself. But that's bad enough, really.
08:10:48 -!- sprocklem has quit (Ping timeout: 256 seconds).
08:11:29 -!- sprocklem has joined.
08:14:15 <tromp> yes, chaitin's construction is a horrible hack
08:16:09 <int-e> (I reread that chapter last month, for the first time in 10 years I guess, and I finally got what that machine is doing.)
08:18:29 <Phantom__Hoover> i reread the jot spec last night and finally got it
08:18:34 <int-e> Hmm, of course programs-with-inputs also define a Busy Beaver function.
08:19:01 <Phantom__Hoover> the SKI translation in the article is pretty clunky though, i'm interested in minimal translations
08:19:36 <int-e> (A Busy Beaver function for every flavor... oh well, that should not be a surprise; you have one for every model of computation that has a quantifiable program size.)
08:20:23 <int-e> just jot it down
08:24:00 <Phantom__Hoover> it's somewhat interesting that leading 1s in a program are pointless
08:24:43 <int-e> I don't really like Iota/Jot, it's sacrificing too much for perceived minimality (compared to SK combinatory logic)
08:25:07 <Phantom__Hoover> i mean jot is just meant to be a goedel numbering
08:26:25 <int-e> It's also sacrificing too much (for my taste) if your goal is to assign a program to every bit string.
08:26:30 -!- laerling has joined.
08:26:33 <Phantom__Hoover> why?
08:27:01 <Phantom__Hoover> other goedel numberings are even uglier
08:29:40 <int-e> It's so, what's the word you used, clunky.
08:33:18 <Phantom__Hoover> the injection of SKI into jot is, the mapping from jot into the lambda calculus is very sleek
08:33:45 <Phantom__Hoover> i certainly can't envisage a better one
08:33:51 <int-e> I mean, it is an amazing feat in some way... making {AB} -> 1{A}{B} work, in particular, is impressive (though it's intimately tied to the translations of K and S. But 5 bits for K and 8 for S is ridiculous. And if you don't stick to the fragment defined by {.} I honestly have no clue what programs mean. Neither [F] S K nor S (K [F]) really make much operational sense to me.
08:34:53 <int-e> Just use ordered pairs to encode binary trees like everybody else.
08:36:27 <int-e> Phantom__Hoover: Let me stress again that this is a matter of taste to me. There's nothing objectively wrong with Iota or Jot, I think. They're just ugly ;-)
08:37:21 <tromp> i'm in perfect agreement with int-e :-)
08:37:56 <tromp> might be that we have similar taste...
08:41:51 <Phantom__Hoover> ah but that's what gives jot its sexy air of mystery
08:42:26 <Phantom__Hoover> clearly the vast majority of programs aren't simple encodings of SKI expressions so what's going on there?
08:43:27 <int-e> I expect it's just a terrible mess of chaos. Not that I've ever stared into that abyss at any depth ;)
08:44:18 <Phantom__Hoover> (this all started when i wondered how to encode church lists of ascii text out of boredom with normal online 'translate your text to binary!' converters)
08:45:23 <Phantom__Hoover> obviously {.} will give you a completely boring result
08:46:00 <int-e> tromp: I think we both like lambda calculus (and by extension, combinatory logic--I don't think either of us can program combinatory logic directly, but abstraction elimination does the trick without blowing programs up too much), and we both can be tracked down into golfing efforts (which favor concise encodings, obviously).
08:47:22 <int-e> Phantom__Hoover: If you find a way to navigate the swamp (yeah I'm changing analogies) that lies off the trodden path defined by {.}, I think you can really impress a few people :)
08:48:55 <tromp> you could see how far you get with a BB_jot
08:49:42 <int-e> How do you even measure the result size?
08:50:14 <tromp> there's always the blc size:-)
08:51:31 <int-e> or bcl size, I guess
08:52:31 <int-e> But I guess this is another source of ugliness... you can't do evaluation in the language that you write your programs in.
08:52:42 -!- sebbu2 has changed nick to sebbu.
08:53:01 <Phantom__Hoover> yes that's another issue, there are no clear reduction rules in terms of the 1/0 language
08:53:34 <int-e> Phantom__Hoover: Anyway I don't want to discourage you from studying this beast.
08:54:28 <Phantom__Hoover> i'll be impressed if i can find a concise encoding of 2 tbh
08:54:43 <Phantom__Hoover> 1 is just... 1, i'm p sure
08:55:35 <Phantom__Hoover> oh there's another snag which is that the majority of jot programs arent in 'normal form', i.e. the 1[A][B] construction is invalid for them
08:56:10 <Phantom__Hoover> but you can get around that by padding it on the left with enough 1s, and i think the number required is in general significantly less than you get from {.}
09:26:38 -!- xelxebar has quit (Remote host closed the connection).
09:28:23 -!- xelxebar has joined.
09:33:00 -!- Lord_of_Life_ has joined.
09:34:14 -!- Lord_of_Life has quit (Ping timeout: 265 seconds).
09:34:18 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
10:30:30 -!- rain1 has joined.
10:33:38 -!- kspalaiologos has joined.
10:38:42 -!- baidicoot has joined.
11:06:25 -!- spruit11 has joined.
11:21:43 -!- baidicoot has quit (Remote host closed the connection).
11:22:05 -!- baidicoot has joined.
11:41:32 <esowiki> [[Talk:Minimal operation language]] https://esolangs.org/w/index.php?diff=70693&oldid=70678 * A * (+147) Forgot to sign
11:45:08 <esowiki> [[Esolang:Sandbox]] https://esolangs.org/w/index.php?diff=70694&oldid=70680 * A * (+5001)
11:45:33 <esowiki> [[Esolang:Sandbox]] https://esolangs.org/w/index.php?diff=70695&oldid=70694 * A * (-13)
11:47:10 -!- baidicoot has quit (Ping timeout: 258 seconds).
11:48:13 <arseniiv> int-e: tromp: Phantom__Hoover: hm seems Jot enjoys a very interesting rule jot (f (unjot s)) = (jot f) s, how was it derived (don’t see it at Chris Barker’s page on it) and wasn’t that how Iota/Jot was constructed in the first place?
11:57:23 -!- Phantom__Hoover has quit (Ping timeout: 260 seconds).
12:18:29 -!- baidicoot has joined.
12:34:56 <int-e> arseniiv: https://en.wikipedia.org/wiki/Iota_and_Jot#Jot sketches a proof of that
12:37:07 <arseniiv> int-e: thanks, the more general form of that statement, with arbitrary w, helps
14:23:24 <tromp> int-e: i checked all my TODOs for 34. so we can say that BB(34) = 5*2^16+6 = 327686
14:24:24 <tromp> that cannot happen with TM BB; predicting a value far in advance of checking it:)
14:25:10 <int-e> Well, granularity.
14:25:24 <int-e> What is a 34 bit TM? :)
14:26:12 <tromp> a 4 state TM takes more than 34 bits to describe
14:26:21 <int-e> Also up to this point the fairly naive filters (not counting the W or W2 criteria which are a bit more clever) have been embarrassingly effective.
14:27:07 <tromp> and BB(4) = 13
14:27:14 <tromp> for TMs
14:27:21 <int-e> (I still haven't looked at the W2 thing, and I think it'll be a couple of days before I do... I really want to give this problem a bit of thought first.)
14:27:57 <int-e> There is also some simplicity to BLC.
14:28:51 <tromp> yes, it's simpler, more fine-grained, faster growing, and naturally expressed in bits. seems better in every respect...
14:30:03 <int-e> The thing is, on an abstract level, what makes programming feasible is code reusage... giving a piece of code a name, and using it by that name somewhere else. Lambda calculus basically turns that principle into an evaluation mechanism, using substitution to put code where it's used so it can be evaluated. So it's eminently programmable, which is in stark contrast to Turing Machines.
14:30:56 <int-e> So perhaps it's not completely surprising that the human understandable (\x. x x x x) 2 is also an actual good busy beaver.
14:31:33 <int-e> (At least once you discover the Church numeral accident that exponentiation is just application.)
14:32:54 <int-e> But I still think the main factor is the better granularity of measuring program size.
14:33:30 <tromp> bits beat states
14:38:02 <int-e> Is there an analogue for http://oeis.org/A052200 (number of n-state 2-symbol TMs) modulo the obvious symmetries (permuting states, and I guess demanding that all states are reachable, at least in the graph given by the state transition diagram?)
14:39:39 <int-e> > log (20^8/24)/log 2 -- naive estimate
14:39:41 <lambdabot> 29.990462258377743
14:48:55 <int-e> tromp: So... if we count closed terms... we reach that number (20^8/24) at size 41...
15:03:12 <tromp> the normal count is (4n+4)^2n for n state TMs
15:10:03 <tromp> 4*2*log(4*4+4) = 34.6
15:15:01 <tromp> in a straighforward encoding, you're use a whole number of bits per transition, and it would rise to 4*2*ceil(log(4*4+4)) = 40
15:15:08 <tromp> you'd use
15:42:00 -!- imode has joined.
15:44:02 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70696&oldid=70692 * Softengy * (+59) Added improved x = x * x algorithm
16:04:29 -!- FreeFull has quit (Quit: Rebooting).
16:10:56 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70697&oldid=70696 * Softengy * (+1) Edit to work with x=0 and not require wrapping
16:12:33 -!- FreeFull has joined.
16:12:42 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70698&oldid=70697 * Softengy * (-6) /* x = x * x */ Fixed algorithm from incorrect previous edit
16:32:08 -!- Phantom__Hoover has joined.
16:49:31 -!- rain1 has quit (Quit: Lost terminal).
17:06:36 <esowiki> [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70699&oldid=70698 * Softengy * (+367) /* x = x / y */ Added wrapping algorithm
17:49:22 <Phantom__Hoover> well i started enumerating all jot programs to find 2 but i gave up on trying it in web browser haskell
18:15:58 <esowiki> [[Talk:Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70700&oldid=70685 * Softengy * (+257)
18:21:45 <esowiki> [[Talk:Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=70701&oldid=70700 * Softengy * (+228) Improved algorithm for x = x != y
18:28:31 <esowiki> [[Special:Log/move]] move * LegionMammal978 * moved [[CaneCode]] to [[Cane Code]]: fix spacing
18:31:03 -!- ArthurStrong has joined.
19:45:52 <esowiki> [[Chevron]] M https://esolangs.org/w/index.php?diff=70704&oldid=69927 * LegionMammal978 * (+15) fixed title
20:08:14 <kspalaiologos> My paper about Mersenne Twister cracking method I used for Seed golfing will be publicly available in Phrack Magazine p71
20:08:29 <kspalaiologos> also, there's a sneak peek on my homepagE: http://kspalaiologos.now.im/?id=9
20:08:44 <kspalaiologos> maybe someone's interested in this
20:10:05 -!- kspalaiologos has quit (Quit: Leaving).
20:50:04 -!- tromp has quit (Remote host closed the connection).
20:50:40 -!- tromp has joined.
21:08:37 -!- arseniiv has quit (Ping timeout: 264 seconds).
21:32:05 -!- Lord_of_Life_ has joined.
21:34:25 -!- Lord_of_Life has quit (Ping timeout: 250 seconds).
21:34:25 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
21:50:43 <esowiki> [[Seed]] https://esolangs.org/w/index.php?diff=70705&oldid=66263 * Ais523 * (+109) link to kspalaiologos's guide to Seed programming
21:51:11 -!- ais523 has joined.
21:52:04 <ais523> kspalaiologos: I was interested, although your algorithm is more complex than I expected; I was expecting there to be an instant reversal that produced optimal output, but maybe not?
21:53:04 <ais523> I looked into reversing LCRNGs a while back, if you have all the bits it's trivial, if you have only a few bits of consecutive elements then reversing the sequence appears to be NP-complete but typically easy in practice
21:53:26 <ais523> (I forget the details but vaguely remember that you might be able to encode the subset sum problem in it)
21:57:41 <zzo38> Play Washizu Scrabble, which like Washizu mahjong, you can see half of your opponent's cards, it is played with teams, and only one player on each team has a score that counts.
22:03:25 <esowiki> [[Seed]] https://esolangs.org/w/index.php?diff=70706&oldid=70705 * Ais523 * (+777) reference formatting, cats, difference between Turing- and -complete, the existing proof is for -hardness but Turing-completeness is also possible
22:04:54 <ais523> hmm, I wonder how hard it is to write a Befunge-98 program which you can append anything to, and the resulting program will calculates its own length in bytes and interpret that as a program in some TC language
22:05:11 <ais523> err, anything made up of printable ASCII and newlines
22:05:23 <ais523> I guess there's an issue that trailing newlines might or might not be visible
22:05:35 <fizzie> Trailing spaces on a line wouldn't be visible either.
22:05:50 <ais523> ah yes, and that could be a larger problem
22:06:08 <ais523> hmm, Seed would actually still be TC if the Befunge-98 program ignored whitespace
22:06:34 <ais523> it'd be harder to calculate the length value you needed, but still fairly easy, as that only requires running the Mersenne Twister forwards and observing where the whitespace would be output
22:07:09 <ais523> there are some interpreters where you can deduce the presence of trailing spaces, though, aren't there?
22:08:03 <fizzie> I imagine so, but I don't think there's a portable way. Even the 'y' command's bounding box is defined in terms of "a non-space cell", not the original program source.
22:08:24 <fizzie> (Even though it goes on to say: "These two vectors are useful to give to the o instruction to output the entire program source as a text file.")
22:11:31 <ais523> I guess you could "simply" multiply the length value by 2¹⁹⁹³⁷-1 and have the program detect how many repeats of itself existed, although that would require proving that passing the Mersenne Twister through the modulo operation didn't create an output with a quotiented period
22:13:46 <b_jonas> Knuth's SGB defines a defines a random number generator based on linear feedback. it's a pity that that one didn't become as well spread and used as a standard as the Mersenne twister. it's probably because SGB doesn't define an initialization method that takes more than a word of seed.
22:15:15 <ais523> the Mersenne Twister's internal state is kind-of ridiculous :-D
22:15:36 <ais523> is there a benefit to having it that large?
22:18:48 <b_jonas> ais523: dunno. the SGB random generator has an internal state of 55 words, 32 bits each, plus an index into that.
22:22:23 <ais523> NH4's PRNG has a 96-bit state, IIRC
22:23:04 <b_jonas> ais523: but that has a different goal, doesn't it? NH4 wants to have an RNG that at least tries to be cryptographically secure, and sacrifices speed for that.
22:23:39 <b_jonas> the Mersenne twister and the linear consomething generators don't try to be crypto secure at all, instead they try to be as fast as possible on near future machines when they were designed
22:25:09 <b_jonas> TAOCP chapter 3.6 exercise 7 asks you to show that a linear congruential generator is very bad for cryptography, as in, find an attack
22:26:13 <ais523> NH4's PRNG is not cryptographically secure, there are two requirements for cryptographic security, it only aims to satisfy one of them
22:26:39 <ais523> (specifically, it cares about the property that observed output cannot be used to deduce future output, but not about any other CSPRNG properties)
22:27:23 <b_jonas> ais523: I know it's not cryptographically secure, but it at least tries to be closer to it
22:28:17 <b_jonas> right, it wants to make it hard to predict future outputs, whereas the Mersenne twister (and lcgs and multiply random generators) don't
22:28:41 <b_jonas> that already makes NH4's random generator necessarily somewhat slower
22:28:51 <b_jonas> to make it fully cryptographically secure would be an overkill and even slower
22:29:37 <b_jonas> ais523: doesn't NH4 also care about that you can't deduce anything about past output other than what was told to you?
22:29:51 <ais523> oh yes, good point
22:30:12 <ais523> I haven't seen that mentioned as a cryptosecurity property in the past
22:30:30 <b_jonas> that's because it's implied by stronger properties I think
22:30:39 <b_jonas> anyway, 96 bits seems pretty small even for that,
22:30:42 <ais523> right, the stronger property is "you can't deduce past output from knowledge of the seed"
22:30:52 <b_jonas> but then, we're not basing our banking system on the NH4 random generator, it's just a game
22:31:16 <ais523> and of course, if you /can/ deduce past output from future output, then you can deduce it from knowledge of the seed simply by generating some future output from it and using it to calculate past output
22:31:32 <b_jonas> ais523: that's not quite precise
22:31:57 <b_jonas> I also require that you can't deduce past output from the combination of future output and other past output before that
22:32:01 <ais523> "you can't deduce past output from knowledge of the current internal state" is the precise formulation, I think
22:32:08 <ais523> oh, of the property that NH4 has
22:32:09 <b_jonas> just the current seed isn't enough for that
22:32:23 <b_jonas> yeah
22:34:18 <ais523> "if you have a sequence of RNG outputs where some are unknown, you can't deduce the unknown elements from the known elements"
22:34:51 <ais523> of course this is trivially false if the length of the sequence exceeds the period of the RNG, but we're assuming that the number of outputs which will ever be requested is small compared to the period
22:35:02 <b_jonas> ais523: sort of, but technically you need even stronger, because your knowledge need not be granular to individual elements of the sequence
22:35:35 <b_jonas> what is the period of the NH4 random generator (at an order of magnitude)?
22:36:01 <ais523> same as the state size, 2⁹⁶
22:36:42 <ais523> well, I don't know that for certain, but if it isn't, the cryptographic hash I'm using is utterly broken :-D
22:37:45 <b_jonas> ok
22:39:05 <ais523> actually, it's pretty certain that the period is 2⁹⁶ because the only way it couldn't be would be if the hash function ignored the first bit of its input entirely if it happened to be exactly 96 bits long
22:39:21 <ais523> and there's no way that brokenness of that magnitude wouldn't be noticed
22:40:13 -!- ArthurStrong has quit (Quit: leaving).
23:01:25 -!- Phantom__Hoover has quit (Ping timeout: 264 seconds).
23:27:39 -!- zzo38 has quit (Disconnected by services).
23:27:45 -!- zzo38 has joined.
23:45:26 <esowiki> [[Alphaprint]] M https://esolangs.org/w/index.php?diff=70707&oldid=70489 * PythonshellDebugwindow * (+13) /* Output */ fixed
23:49:58 <esowiki> [[LogicF---]] M https://esolangs.org/w/index.php?diff=70708&oldid=70473 * PythonshellDebugwindow * (+28) Cat fix /* Examples */
←2020-04-06 2020-04-07 2020-04-08→ ↑2020 ↑all