Posts
Comments
My tentative plan is something along those lines.
8 players submitted legitimate CloneBots. 1 person submitted nothing. Multicore submitted EarlyBirdMimicBot.
It is working against AbstractSpyTreeBot. EarlyBirdMimicBot is secure against it.
Useful writing tells people something true and important that they didn't already know, and tells them as unequivocally as possible.
―How to Write Usefully by Paul Graham
Removing qualifiers from my speech and writing helps me think clearly because it forces me to make positive statements about reality. Compare the following three statements.
- "China is the center of human history."
- "I think China is the center of human history." ― If you actually () thought China is the center of human history then you wouldn't say "think". You would say "China is the center of human history". If you are unsure then you could say "I wonder if China is the center of human history." Saying "I think…" isn't exactly wrong, but it would be better to suspend judgment while you find out whether China is the center of human history. If you know the truth then you can state it with confidence. Using prefaces like "I think…" is putting your opinion before the facts. It changes the topic of a conversation from reality to your thoughts, often precipitating an epistemic train wreck.
- "I believe China is the center of human history." ― The "I believe…" qualifier is even worse than "I think…" because believing in belief damages your epistemics.
A statement without qualifiers is the most meaningful because it is the most narrow. (More precisely, it forces entropy out of a probability distribution.) Qualifiers like "I think" signal lack of confidence. Such signals accurately calibrate statements when you truly do lack confidence. Signaling lack of confidence when you are confident obfuscates communication.
In my real life experience, people who demand unnecessary qualifiers are dangerous to consort with. (By unnecessary qualifier, I mean redundant words like "It seems to me…" when you know something to be true. Qualifiers like "one of the ___s" are fine if you really mean "one of the ___s".)
If " is true" then I will say " is true". If " is not true" then I will say " is not true".
I think the "I think" could perhaps be considered (basically) part of a joke, from a certain point of view.
What would good and ethical advertising look like? Maybe I decide that I want to be advertised to now, and go to my preferred advertising venue.
Advertising you want to look at is called "news", "media" or "product placement".
I love Hy and use it all the time for data science and other applications. Thank you for all your work on the project!
Your entry is in. I implemented the If (their score > my score and round > 5) play 3. Else Play 2. algorithm. I hope I got the rest of it right.
(import random)
(setv +sequence-1+ [2 3 3 2 2 2 3 2 3 2 3 3 2 2 2 3 3])
(setv +sequence-2+ [2 2 2 2 2 2 2 3])
(defclass BendBot []
(defn --init-- [self &optional [round 0]]
(setv self.round round)
(setv self.opponent-record [])
(setv self.record [])
(setv self.turn -1)
(setv self.count-to-four 0)
(setv self.terminal-behavior False))
(defn move [self &optional [previous None]]
(+= self.turn 1)
(if previous
(.append self.opponent-record previous))
(setv output
(if (= self.opponent-record self.record)
(if (or (% self.round 2)
(< self.round 4))
(if (< self.turn (len +sequence-1+))
(. +sequence-1+ [self.turn])
(. +sequence-2+ [(% (- (len +sequence-1+)
self.turn)
(len +sequence-2+))]))
(if (< self.turn (len +sequence-1+))
(. (list (reversed +sequence-1+)) [self.turn])
(. +sequence-2+ [(% (- (len +sequence-1+)
self.turn)
(len +sequence-2+))])))
(if (< count-to-four 4)
(do
(+= count-to-four 1)
(if (= (last self.record) 3)
2
3))
(if (or self.terminal-behavior
(= 5 (+ (last self.record) previous)))
(if (= (last self.record) 3)
2
3)
(do
(setv self.terminal-behavior True)
(if (all (map (fn [x] (<= x 0)) self.opponent-record))
5
(all (map (fn [x] (<= x 1)) self.opponent-record))
4
(all (map (fn [x] (<= x 2)) self.opponent-record))
3
(if (> (+ (last self.record)
previous)
5)
3
2)
))))))
(.append self.record output)
output))
I agree that my knowledge of history is biased towards events politically relevant to the USA. I appreciate how this comment of yours helps correct against that bias.
As soon as I can. Hopefully by the end of this week.
The "article" you link to isn't an article. It is a letter to the editor. And it wasn't written by a historian. It was written by a retired U.S. Foreign Service officer.
The real article is a book review about "a CIA-backed coup". The book in question is written by a professor of human rights and political philosophy at the University of London (Birkbeck) who won the Frantz Fanon Prize in 2010 for one of his several other books about Latin American history.
It's worth noting that the 1966-1976 Cultural Revolution was official government policy of the Chinese Communist Party (CCP) under Chairman Mao Zedong and (for our purposes here) represented neither a transfer of power nor a bottom-up social movement. The transfer of power which put Mao and the CCP in charge was the 1927-1949 Chinese Civil War. But the concept of a "1927-1949 Chinese Civil War" is an anachronism. China: A History by John Keay describes China as more-or-less in a state of civil war from the fall of the Qing Dynasty (well before 1927) until its domination by the CCP.
In other words, the first domino was "civil war", not "Maoism". The CCP didn't even come into existence until years after the fall of the Qing Dynasty
If you want to use modern Chinese history as a model for predicting political catastrophe then the place to look is for indicators of the breakdown of the Qing Dynasty. The obvious place to begin an examination for that would be the Opium Wars and the Taiping Rebellion, both of which are out-of-scope of "the last century".
If our goal is to specifically look for "a transfer of power from democracy to non-democracy in China" then that happened when Yuan Shikai took power from Sun Yat-sen. But to emphasize that particular transfer of power is to examine history through a narrow, biased lens. After all, the Kuomintang lost the war. Rather than look for situations where democracy turned into non-democracy, I think we can get a better understanding of historical forces by looking for indicators of a transfer of power more generally, and then applying these general indicators to the specific places we care about.
The parent comment comes from a private conversation between me and philh in which I conveyed erroneous information. The mistake is my fault—not philh's. A line such as foo = 'bar' is legal in some contexts. A line which uses the global namespace to preserve information between class instances is illegal.
In my private conversation with you (philh) I stated "Writing variables to the global namespace is forbidden." I then doubled down on the error by stating "Yes. All data must be saved in a class instance."
I apologize for the error. What I should have written was that using the global namespace to get around information restrictions is illegal but that writing constants to your module's global namespace in a way that does not evade information restrictions is fine.
Setting constants into the global state of your own file is fine. What I care about is whether you're setting variables into the global state for the purpose of preserving information between bot instantiations or otherwise messing with the game engine. simon's bot clearly does neither.
simon will not be disqualified.
- In 1923, a bohemian corporal attempted to seize power from the Weimar Republic. He tried again in 1933 and succeeded.
- In 1949, a coup overthrew Syria's democratic government.
- In 1953, the USA overthrew the Iranian constitutional monarchy.
- In 1954, the USA overthrew the Guatemalan representative democracy.
- In 1960, the USA overthrew the Congo's legally-elected prime minister.
- In 1964, the USA overthrew the democratic government of Brazil.
- From 1968-1972, the Panamanian military replaced the civilian government.
- In 1973, the USA overthrew Chile's democratic government.
- In 1979, the USA overthrew the democratic government of Salvador.
See here.
Pacific Time Zone.
I appreciate these continued reports. They save me from having to choose between wasting time on noise and not keeping tabs on things at all.
My previous answer was a mistake. It is actually 100 move calls in 0.05 seconds. Sorry.
The numbers are brutal.
If a game goes for 50 rounds and 10 different bots each use 5[1] seconds per move and there are 550 moves per bot per pairing then it would take 4.36 years to run this tournament.
However, do note that the guarantee is "0.05 seconds per 100 moves" as opposed to "0.0005 seconds per move". If you only have to run expensive computations once then, depending on your algorithm, the right caching system might get you close to 100× performance.
I can add caching functions to the extra package if that would help. The computer in question has 4 processors and runs Linux so multiprocessing can get you up to a 4× speedup.
500 seconds per move is 100× my original limit which equals 10,000× the corrected limit. ↩︎
I will not disqualify anyone who can complete 100 move calls in 5 seconds (0.05 seconds per call on average) on my T450s.
I will not disqualify anyone who can complete 100 move calls in 0.05 seconds on my T450s.
Edit: Corrected time limit downward by 100×.
Like in the code?
# Comments are allowed in the code.
Python 3.6.9 or Hy 0.18.0.
Since quining is "trivial but annoying", I am willing to provide a quining function in the extra package if anyone requests it.
First a run your program against one or more simple programs without any simulations. If your program hits an infinite loop there then you will be disqualified before you get to infect any other programs. In this way you can be disqualified before the others.
If your program passes the simple tests then it will join the pool and against all other programs which have passed the initial test. All programs which fail to terminate at this stage will be removed simultaneously.
Thank you for the bug report. I have corrected __init__(self, round=1) [..] to __init__(self, round=0) [..]
Run-time. I disqualify the entire program—not just the one copy—and then restart the game with one (or fewer) competitors.
I am neither kind nor fair-minded enough to provide a symmetry-breaking bit in the extra package.
Hacking the game engine is against the rules. If your opponent decides to simulate your code then hacking them from inside your opponents' simulation is allowed. Your code is allowed to peek at the game engine for the purposes of figuring out if it is being simulated by someone else's code. Peeking at the game engine for other reasons, like figuring out how many of each opponents remain or attempting to modify the game engine itself or attempting to modify your opponents' code from anywhere outside their own simulation of you is against the rules.
Anything that could damage the game's execution environment is a security risk and grounds for disqualification. Forkbombing your opponent is really pushing things…but technically legal. I would prefer something more mundane like calling exit() or an infinite loop. Anything more damaging than a forkbomb constitutes a security risk and is not allowed under any circumstances. If you are going to write any malware-like then code (including forkbombs) then please draw my attention to it in some way what the intended behavior is so I can mitigate any unintended consequences to my own systems. Even better would be to PM me for explicit permission.
Any code which gets disabled by malware will get disqualified from the tournament. I will then restart the tournament with the broken competitor(s) removed.
The resolution is #3 "Untrusted code is untrusted code; simulate at your own risk."
The function get_opponent_source returns source code as a string. You can trivially overwrite it in your local environment with the command get_opponent_source = my_custom_get_opponent_source. (This is standard Python.) If you execute your opponent's code in a simulation where get_opponent_source has been rebound[1] to a new function (and have not otherwise left alternate attack vectors open) I see no reason why this would would trigger infinite recursion.
If you rebind the get_opponent_source function in your local environment in a reasonable way that is itself obviously not an attempt to breach anything then I will consider that a bug in the game engine and attempt to engineer a fix.
I have not yet read over Zak's code in detail nor have I attempted to execute it. If it infinitely recurses then it will be disqualified.
Edit: Do note that an unobfuscated simulator bot is likely to have a statement something along the lines of
from extra import get_opponent_source. If you overwrite theget_opponent_sourcefunction and then execute your opponent's code, it is possible your opponent'sfrom extra import get_opponent_sourcemay un-overwrite your rebinding. ↩︎
Good question! My time travel technology will not be available to contestants' bots. This is in accordance with Less Wrong's established norm of containing dangerous technology.
I have edited the original post in a futile attempt to cover-up this leak and have removed the relevant API call from the extra module.
Simulator bots are legal for programmers to write provided they never crash, slow the game to a crawl, etc. Any bot (even a non-simulator) that does will be disqualified.
I have not yet read the AbstractSpyTreeBot source code in detail nor run it myself. A cursory glance suggests it's within the rules.
If you're worried whether something is too complicated then the best solution is to PM me with your most complicated dream bot and I'll tell you how much of it I'm willing to code.
An example of something that is too complicated is Zach_M_Davis's AbstractSpyTreeBot which runs a simulation of its opponent. Another example of something too complicated is is a neural network trained on your opponent's past history. Such bots are perfectly legal if you code them yourself to reasonable speed constraints but I will not write one for you.
A hard-coded decision tree with several unambiguously-specified simple options is well within reason if that is all there is to it and you write a good specification. For example, using regular expressions to analyze your opponent's source code if fine.
The rules are that, from the game engine's perspective, everyone's code is going to be written in Python 3 or Hy. It is theoretically possible that someone's code might, say, include some code in a different language that is then executed from the Python runtime.
There are two active bots. The self argument tells the game client which bot's code not to return.
General intelligence is still increasing at 10 years old. Simply getting older is sufficient to explain your experience.
Short-selling a security means borrowing it and then immediately selling it with the intention to repurchase it later at a lower time-discounted price right before you return the principal (in the form a a security instead of cash) to your creditor. In this case, you borrow exactly enough of the underlying security such that you will acquire in cash by immediately selling it.
Competitive or not it is technically competing. Welcome to the game!
It's the latter.
Many ideas in this post can be broadened to paradigm shifts in general. Painters and mystics traverse similar obstacles.
The number of turns per round is at least 100 and no more than 1000. I have not yet determined the number of rounds. If practical, I will iterate until there is a stable equilibrium.
Edit: I have edited the original post to reflect the latter statement about rounds.
Vague. The only limitations are obvious stuff like hacking the game client to get around information restrictions, using so much compute you slow the game itself to a crawl, installing anything that takes me significant effort to set up and anything I consider a security risk. You may PM me for clarification on your specific situation. I can easily perform speed tests as I have already written the game client.
If you are a programmer then you may request reasonable features such as reading your opponent's source code.
Edit #1: In order to maximize resource use, you may provide an adjustable constant such as TREE_DEPTH.
Edit #2: Any code that can always complete 10,000 move calls within 5 seconds is guaranteed to be "fast enough".
See this answer.
Yes. You may read the opponent's source code via the get_opponent_source(self) function.
from extra import get_opponent_source
class SpyBot():
def __init__(self, round=1):
self.round = round
def move(self, previous=None):
opponent_source = get_opponent_source(self) # return value is of class `str`
if '3' in opponent_source:
return 2
return 3
Beware the halting problem. Infinite recursion constitutes overuse of compute resources and may be grounds for disqualification.
I fixed the self.previous mistake. I think I'll leave the other bug as it is.
See this comment concerning 2.5.
I am aware of the potential strategic implication you bring up. However, as the organizer of this game, I believe it is my place neither to confirm nor deny beforehand any strategic implications of these rules.
Explaining my rationale necessarily involves discussing the strategic implications. I will explain my rationale for this choice after the game.
The obvious disadvantage of steroids in the ancestral environment is that building muscle requires a lot of calories and our ancestral environment was food-scarce. The disadvantage of taking steroids right now (aside from legal concerns) is that they come with all sorts of nasty side effects our genome hasn't been selected against to mitigate.
Fixed.
Furthermore, if you seek to contribute to a global cause via technical means then it often makes sense to specialize. If you know you can have a greater marginal impact in biosafety than AGW then you should allocate (almost) all of your altruistic attention to biosafety and (almost) none of it to AGW.
I believe climate change will provide a significant (>90%) net-negative (>90%) impact on future human welfare in the forseeable future. I believe (>90%) that climate change is a large-scale policy and technology problem i.e. individual self-regulation has more to do with fuzzies than utilons. I have triaged climate change as a less-than-optimal target of my limited resources. Climate change therefore deserves no more further attention from me.
To put it bluntly, I believe
- Strong AGI is potentially imminent.
- If strong AGI is imminent then it outweighs all other large-scale altruistic concerns.
- I personally have a non-negligible probability of impacting the trajectory of AGI.
AGI therefore overwhelms all my other actionable large-scale altruistic concerns. In particular, climate change is a relatively minor (>%75) threat I am unlikely to significantly influence directly via intentional action (>95%). Furthermore, climate change is likely (>75%) to have relatively minor (affecting <10% of my overall material standard of living) negative personal impact on me. Thought climate change is important to human welfare, I ought not to be "concerned" about it at all.
As for mass media's respresentation of climate change, I think it's crap—just like all other propaganda. This is by design.
So by the end Glue is almost never chosen, while Rock reverts to being a regular option which risks defeat by paper, that in time becomes more popular.
This sentence confuses me. It seems to me like you're implying that there is a time when the probability of choosing rock exceeds the probability of choosing glue when in fact the Nash equilibrium strategy is rock, paper, glue and scissors.