Attention to all competitors who have not yet submitted code: My bot will analyze your bot looking for statements of the following structure (regardless of the names of the individual atoms):
(if <predicate> 'C ...)
(cond (<predicate> 'C) ...)
(case <predicate> ((...) 'C) ...)
If it finds such a statement as the first statement in a top-level returning position (the body of a top-level let, the returning statement in your lambda, etc), then my bot might cooperate depending upon the nature of your predicate. Otherwise, my bot will defect against you.
If we are to achieve mutual cooperation, we must make it as easy as possible for our bots to prove cooperation. Please start your code with a conditional cooperation. The nature of the condition is up to you. You can still try to exploit me in <predicate>. But the only way to have a shot at mutual cooperation is to provide an obvious top-level cooperating codepath.
Yes. Well, let me put it this way: you can do what you like, but if you want a shot at mutual cooperation it’s got to be really easy for other bots to verify that you’re willing to cooperate. The more code you put between them and 'C, the harder it is for them to verify your niceness.
A stronger version of this statement is “put as little code as possible between them and discovering that you cooperate”. This implies that your predicate should be similarly simple. If you want my advice as to strategy, your predicate should be along the lines of (equal? ((eval them) (degredaded-quine me)) ’C).
That seems a little arbitrary.
It’s quite arbitrary. The “real” rule is that your ’C can be as deeply hidden as you like so long as you don’t scare any bots into defection when there was a chance at mutual cooperation. My bet is that there will be a bunch of twitchy bots, and my suggestion is that you put your intentions front and center.
Imagine implementing a MimicBot. You need to figure out what my bot will do, and that’s non-trivial if you want to avoid infinite loops. You’re going to need a fair bit of code. I don’t care how the code works, but it should start with
(if <predicate> 'C ...)
This pattern alone won’t get you mutual cooperation. You’ll still need to write a MimicBot, or a FairBot, or a JustBot. But whatever you do, make it obvious that there’s a cooperation condition.
I’m not advocating any particular strategy; I’m advocating a pattern: If you want a shot at trust, you’d better have a codepath that results in cooperation, and you’d best make it really easy for other bots to recognize.
FWIW, it’s pretty easy to pull out the first conditional (cond, case, or if) when you have code in fully expanded form (which turns them all into ifs). However, that just puts you in a position of checking whether a predicate is #t or #f, which isn’t much easier than discovering whether a program returns 'C or 'D. Ultimately, your MimicBot idea is better :-)
Attention to all competitors who have not yet submitted code: My bot will analyze your bot looking for statements of the following structure (regardless of the names of the individual atoms):
(if <predicate> 'C ...)
(cond (<predicate> 'C) ...)
(case <predicate> ((...) 'C) ...)
If it finds such a statement as the first statement in a top-level returning position (the body of a top-level
let
, the returning statement in your lambda, etc), then my bot might cooperate depending upon the nature of your predicate. Otherwise, my bot will defect against you.If we are to achieve mutual cooperation, we must make it as easy as possible for our bots to prove cooperation. Please start your code with a conditional cooperation. The nature of the condition is up to you. You can still try to exploit me in
<predicate>
. But the only way to have a shot at mutual cooperation is to provide an obvious top-level cooperating codepath.Does ’C have to be the first path? That seems a little arbitrary.
Yes. Well, let me put it this way: you can do what you like, but if you want a shot at mutual cooperation it’s got to be really easy for other bots to verify that you’re willing to cooperate. The more code you put between them and
'C
, the harder it is for them to verify your niceness.A stronger version of this statement is “put as little code as possible between them and discovering that you cooperate”. This implies that your predicate should be similarly simple. If you want my advice as to strategy, your predicate should be along the lines of (equal? ((eval them) (degredaded-quine me)) ’C).
It’s quite arbitrary. The “real” rule is that your ’C can be as deeply hidden as you like so long as you don’t scare any bots into defection when there was a chance at mutual cooperation. My bet is that there will be a bunch of twitchy bots, and my suggestion is that you put your intentions front and center.
Your mileage may vary.
I’ll do as you request, though there are other ways to achieve mutual cooperation (e.g. MimicBot).
Imagine implementing a MimicBot. You need to figure out what my bot will do, and that’s non-trivial if you want to avoid infinite loops. You’re going to need a fair bit of code. I don’t care how the code works, but it should start with
(if <predicate> 'C ...)
This pattern alone won’t get you mutual cooperation. You’ll still need to write a MimicBot, or a FairBot, or a JustBot. But whatever you do, make it obvious that there’s a cooperation condition.
I’m not advocating any particular strategy; I’m advocating a pattern: If you want a shot at trust, you’d better have a codepath that results in cooperation, and you’d best make it really easy for other bots to recognize.
Best of luck!
Since I don’t think you’re going down the predicate route, I’ll tell you the sort of strategy I was going to use against it.
The predicate (eq? 1 1) evaluates to true, except when eq? is shadowed. Just curious—would it have worked?
Nice. But no. My first attempt was a static analyzer, and the first thing it did was a syntax expansion, putting all code into fully expanded form) and attaching lexical information to each identifier that let me see what was from the base package and what was redefined.
FWIW, it’s pretty easy to pull out the first conditional (cond, case, or if) when you have code in fully expanded form (which turns them all into ifs). However, that just puts you in a position of checking whether a predicate is
#t
or#f
, which isn’t much easier than discovering whether a program returns'C
or'D
. Ultimately, your MimicBot idea is better :-)This suggests a strategy: if opponent’s code starts with “if then cooperate” then cooperate.