Is a strategy that pays attention to which strategy it is playing against considered "honest"?

[daira]

https://axelrod.readthedocs.org/en/latest/contributing.html#is-your-strategy-honest says:

"The rules for an ‘honest’ strategy are very simple:

• It does not change what it’s opponents do/know.
• It forgets everything every time it starts playing someone (this is implemented with the reset method)."

Consider a strategy that obtains the class name or code of its opponent (so that it is able to simulate, but not change, what its opponent will do in response to its own move). Is this honest? It seems to meet the definition.

[meatballs]

Welcome, Daira!

I'd say that your example is not honest and we need to change the description.

(Also, the apostrophe in "it's" needs to go)!!

[daira]

OK cool. Looking through the existing strategies, I think there's a useful distinction between:

• strategies that try to find out how their opponent will behave (and which cannot guarantee to succeed in doing so if their opponent is nondeterministic); and
• strategies that attempt to change what their opponent does or knows.

The latter are interesting for a "code wars"-style, anything-goes tournament, but the former are more interesting to me personally because they can model social phenomena like peer group recognition, and can be independent of low-level details of the Python environment.

(And yes, the apostrophe bugged me too :-) )

[meatballs]

OK cool. Looking through the existing strategies, I think there's a useful distinction between:

• strategies that try to find out how their opponent will behave (and which cannot guarantee to succeed in doing so if their opponent is nondeterministic); and
• strategies that attempt to change what their opponent does or knows.

I'd agree. Up until now, we've only distinguished between those that comply with Axelrod's original rules and those that do not. I'd support a more nuanced differentiation along the lines you suggest.

[langner]

In my view inspecting other players beyond a basic set of properties
related to the "actual game" crosses a boundary. Why? Because it inevitably
leads to strategies tweaking their own internals so as to mislead other
strategies. That falls into the category of strategies that attempt to
change what their opponent does or knows, except that the method is
passive. Ultimately I think the point is to stick to the IPD and not
venture into any kind of code war.

On Fri, Sep 4, 2015 at 8:25 AM, Owen Campbell notifications@github.com
wrote:

OK cool. Looking through the existing strategies, I think there's a useful
distinction between:

• strategies that try to find out how their opponent will behave (and
  which cannot guarantee to succeed in doing so if their opponent is
  nondeterministic); and
• strategies that attempt to change what their opponent does or knows.

I'd agree. Up until now, we've only distinguished between those that
comply with Axelrod's original rules and those that do not. I'd support a
more nuanced differentiation along the lines you suggest.

—
Reply to this email directly or view it on GitHub
#291 (comment)
.

[daira]

Being able to simulate the behaviour of your opponent strategy (as a black box) doesn't seem as though it would lead to excessive tweaking of internals to me. Axelrod already includes strategies that do this, as well as strategies that do more active cheating; the proposal is just to distinguish those two groups and to clarify the definition of "honest" to exclude both.

[marcharper]

You all might be interested in this article, in which strategies are able to examine the source codes of their opponents, which leads to some very interesting results.

[marcharper]

As for the definition of honest, the typical rules assume that players:

• do not retain state between tournaments
• cannot modify the source of other players
• only have access to opponents decisions, not their source code or internal variables (despite python providing these). This implies access to read (but not modify) the opponent's history (since a copy of the history of play could be retained by any player). Some tournaments go so far as to assign players generic IDs from which the player's "class" cannot be directly inferred (sometimes called tagging). My colleagues and I studied how one can infer the strategy of an opponent under these constraints (it's not difficult for memory-one strategies). See also the discussion Duplicate Strategies #138.

As for simulating play of another strategy, I don't think that is necessarily dishonest, but it needs to be done carefully so as to not mess with the internal state and history of a player. Take a look at MindReader, which does something like this, but not perfectly because of deepcopy loops. (MindReader rolls back opponent's histories, it doesn't restore opponents' internal variables.)

I have no problem with adding more such strategies to the library, but I don't think they should be considered "ordinary strategies".

[drvinceknight]

Hi @daira: welcome :) If you haven't seen our gitter.im room feel free to jump in and say hi: https://gitter.im/Axelrod-Python/Axelrod

I have no problem with adding more such strategies to the library, but I don't think they should be considered "ordinary strategies".

Yeah, from the beginning 'code wars' have been accepted (and good fun) but they've always had to be clearly marked as cheater strategies. As @marcharper said MindReader is a good example of this. At the very beginning @langner went in to a nice best response dynamic with another contributor by better-ing each other's knowledge of how python could be used to manipulate other strategies.

[drvinceknight]

Re:

"The rules for an ‘honest’ strategy are very simple:

It does not change what it’s opponents do/know.
It forgets everything every time it starts playing someone (this is implemented with the reset method)."

Should we change that to:

"The rules for an ‘honest’ strategy are very simple:

It does not change what its opponents do/know.
It does not inspect its opponents source code.
It forgets everything every time it starts playing someone (this is implemented with the reset method)."

?

[marcharper]

Sounds good to me. Let's also keep in mind one of the goals of the library:

To produce the de-facto tool for any future Iterated Prisoner's Dilemma research.

So if people want to use the library to study strategies that read the source code of other strategies, or tournaments that relax the "no reading source code rule", that's great! The distinction between cheating and non-cheating only affects the default tournaments that are run to update the results here -- anyone is free to run tournaments with any combination of strategies that they please.

[drvinceknight]

Yeah: I completely agree @marcharper.

On 4 September 2015 at 23:09, Marc Harper, PhD notifications@github.com
wrote:

Sounds good to me. Let's also keep in mind one of the goals of the library:

1. To produce the de-facto tool for any future Iterated Prisoner's
   Dilemma research.

So if people want to use the library to study strategies that read the
source code of other strategies, or tournaments that relax the "no reading
source code rule", that's great! The distinction between cheating and
non-cheating only affects the default tournaments that are run to update
the results here https://github.com/Axelrod-Python/tournament -- anyone
is free to run tournaments with any combination of strategies that they
please.

—
Reply to this email directly or view it on GitHub
#291 (comment)
.

Dr Vincent Knight
Cardiff School of Mathematics
Senghennydd Road,
Cardiff
CF24 4AG
(+44) 29 2087 5548

[langner]

Being able to simulate the behaviour of your opponent strategy (as a black box) doesn't seem as though it would lead to excessive tweaking of internals to me. Axelrod already includes strategies that do this, as well as strategies that do more active cheating; the proposal is just to distinguish those two groups and to clarify the definition of "honest" to exclude both.

Of course, this is all fine. By 'crosses a boundary' I meant into the realm of cheating strategies.

And... welcome!

[marcharper]

So we just had a conversation in the gitter room, and came to the conclusion that whether a strategy is honest or not depends on the rules of the tournament. We're in favor of adding a dictionary to the Player class that denotes e.g.

• reads_source = True
• modifies_source = False
• memory_depth = 1
• etc.

Then whomever is running the tournament can decide if e.g. reads_source == True makes a strategy a cheater or not and include or exclude as desired. We can then calculate the list of "ordinary strategies" as those that do not read the opponent's source (and whatever other attributes) for run_axelrod without having to label strategies as cheaters or not in _strategies.py . Also new users will not have to inspect the code of each strategy to determine whether it does something unexpected.

Possible additional attributes:

• in_first_axelrod, in_second_axelrod, etc.
• Any suggestions?

Thanks to @daira for opening this issue and sparking the discussion!

[drvinceknight]

Yeah this was a great discussion and I'm super happy with the outcome :)

As well as all the advantages we discussed last night having all the strategies under axelrod.strategies will be much clearer.

Also, just to add that by default we can have a classifier set to None which would indicate no classification for a given strategy on that particular dimension which means that adding a new dimension is not a big pain.