The paper examines the use of the tournament approach in the educational process on the example of the economic model "repeated prisoner's dilemma". Students study the model design using the UML and implement the solution to the "Tournament of Strategies" problem using an objectoriented language. The advantages of the proposed themes are "junction" of the economy and important for programming in Computer Sciences Economic Institutions; the development of a diverse set of skills (economics, game theory, design, UML, modeling, object-oriented design and programming, Java, Eclipse); introduction of a creative, competitive moment into the educational process, as well as an element of intrigue.
IT courses at an university of economics include the preparation of a "two-headed" graduate. To
master with equal ease the methods and tools of informatics and programming on the one hand, and
methods of economics and management on the other [
The economic components are provided by such disciplines as economic theory, mathematical and simulation modeling, etc. However, there is a certain gap between these disciplines and the profile disciplines of the educational program. Knowledge of economic science is in most cases not used to solve specific programming problems. Therefore, it is often the case that these two areas do not overlap in training.
Game modeling makes it possible to bridge this gap to a large extent. Designing and programming of a game model allows on the one hand to increase competence in the design and implementation of software on the other hand to immerse oneself in the subject area, i.e. economics and management. And experiments with a game simulation model give students the opportunity to analyze in detail the work of the economic mechanisms in detail. The study of the methodological support of game modeling will be carried out using a similar problem as an example.
In order to achieve the goal of integration of education in economics and IT, it was decided to
implement the "Strategy Tournament" task. Its importance lieas in the repetition of the famous
experiment of R. Axelrod to evaluate the effectiveness of different strategies in "Prisoner's Dilemma"
[
As the task is quite simple from a technical point of view, it allows you to cover a wide range of
areas of economics and programming, ranging from different market models to problems from
cooperation in nature and society [
For the study of the proposed topic 4, 6 or 8 hours of study time can be allocated, depending on the available options. Table 1 shows an indicative lesson plan with an approximate estimate of time for each element.
After the end of the lesson, students may be offered such directions for self-study, such as:
– formation of new strategies and analysis of their effectiveness;
– analysis of the results of the experiment depending on the number of players of different classes;
– an evolutionary version of the game [
– biological, economic, social examples of the implementation of the model "Prisoner's Dilemma"
and "Repeating Prisoner's Dilemma" [
(discussing with students).
5
5
10
20
10
40
conclusion about the advantage of refusing to
cooperate with any choice of the opponent [
In order to control the assimilation of the teaching material, questions (closed form) were developed, divided into five categories: economic issues; elements of game theory; repetitive games; design and UML; object-oriented programming. Table 2 shows examples of developed questions. The test was implemented in LMS Moodle. recursive call always lose the tournament "Angry" always lose individual matches to "evil" benefit from cooperation with each other 2. Development of teaching materials for the "tournament of strategies" task 2.1
Statement of the problem of the repetitive prisoner's dilemma The well-known Prisoner's Dilemma is a popular model that illustrates various economic situations, for example, price competition in the oligopoly market. The “prisoner's dilemma” is also used in more complex cases, when two participants in economic relations make the decision to cooperate or refuse to cooperate.
The “prisoner's dilemma” can be formulated as follows: two accomplices were arrested for theft and placed in different cells. Each of them can confess to a crime or refuse to confess. The prisoner is not aware of the decision of his accomplice. The punishment assigned to each of the prisoners, depending on the testimony, can be represented by the matrix shown in Table 3.
Thus, the prisoner who has betrayed his comrade receives a bonus in the form of a small prison sentence. In case of loyalty among the prisoners, both receive rather soft conditions.
Depending on the condition of the task, it is beneficial for the prisoner to testify, thereby betraying his comrade. Suppose prisoner A assumes that prisoner B will break loyalty. In this case, it is also beneficial to violate loyalty by reducing his sentence from 10 to 5 years. If prisoner A assumes on the part of prisoner B the preservation of loyalty, then A is still beneficial to break loyalty by reducing his sentence from 2 years to 1.
A mutually beneficial solution can be achieved through mutual preservation of loyalty, but under the conditions described, such a possibility is difficult to reckon with.
The dynamic (repeating) version of the prisoner's dilemma (which corresponds more closely to economic realities), proposed by R. Axelrod, presupposes not a single decision-making about loyalty or betrayal, but a series of such decisions, continuing an unknown number of times. Both prisoners now remember the decisions of their comrade in the previous steps. Under such conditions, the benefit of betrayal in a particular step may be less than the benefit of cooperation in the following steps.
The question of the best behavioral strategy in a dynamic model is controversial.
The task is to organize a tournament of strategies (also proposed by R. Axelrod) to determine the best strategy. The following strategies participate in the tournament:
Random – random choice (the decision to betray / keep is chosen randomly, with equal probability).
Evil – renegade (betray at every step).
Talion – eye-for-eye (keep loyalty at the first step; repeat the previous move vis-a-vis at subsequent steps). This option was proposed by A. Rapport.
The game features three players implementing each strategy. The tournament is organized in a round robin system - each player plays one match with everyone else. The match consists of N steps. The players do not know the number N, while remaining the same for all matches of the tournament.
At each step, the distribution of points is set by the matrix in Table 4. The result of the tournament is determined by the total number of points scored by each player in all matches.
For programming a task, an object-oriented approach is most effective, allowing to separate the parts of the system that are responsible for decision making and for game play. At the same time, a flexible system can be created that allows new players with new strategies to be added.
For the visual representation of design decisions during their discussion, we use the UML language, which is now the de facto standard in the field of analysis, design and software development.
The language diagrams allow students to propose and discuss design solutions for the implementation
of the tournament [
In this case, two diagrams are sufficient: a class diagram (Figure 1) describes the structure of the
system, and a sequence diagram - the order of interaction of objects of different classes during the
tournament. [
Player
{abstract} + YES : int = 1 + NO : int = 0 - _name : String - _totalScore : int + <<Constructor>> Player (String _name) + getName () : String + getTotalScore () : int + startGame () : void + yourAnswer () : int + enemyAnswer (int answer) : void + finishGame (int score) : void
players
TalionPlayer - _lastAnswer : int + <<Constructor>> TalionPlayer (String _name) + <<Override>> yourAnswer () : int + <<Override>> startGame () : void + <<Override>> enemyAnswer (int answer) : void
Tourney - N : int = 25 - _matrix : int[][] = {{1,10},... + <<Constructor>> Tourney () + addPlayer (Player player) : void - game (Player a, Player b) : void + runGames () : void + showResults () : void - showPlayerResult (int i) : void
RandomPlayer + <<Constructor>> RandomPlayer (String _name) + <<Override>> yourAnswer ()
: int
EvilPlayer + <<Constructor>> EvilPlayer (String _name) + <<Override>> yourAnswer () : int
The key role is played by the abstract class Player, which is responsible for the player (strategy). This class stores the player's name (_name), calculates and stores the player's total win since the start of the tournament (_totalScore). Class method yourAnswer () - the player returns the answer on the next turn. The answer is an integer YES = 1 (cooperate) or NO = 0 (betray).
The player classes RandomPlayer, EvilPlayer, TalionPlayer, as inheritors of the Player class, override the yourAnswer () method and other methods as appropriate. In this way, they each implement their own game strategy.
The Tourney class is fully responsible for running the tournament: creating the schedule, running
the games, calculating the results. The Player class and its heirs know nothing about the tournament,
and the Torney class depends only on the Player class, without knowing its specific heirs and without
depending on their implementation of one strategy or another. When extending the task by adding a
new player, it is sufficient to create a new class that inherits from Player [
The simple structure of the task and the very simple implementation allow to touch, if necessary,
some aspects of object-oriented programming (inheritance, abstract classes, abstract methods, method
overrides, composition, scopes, constructors, static class fields). Moreover, a simple example clearly
demonstrates the usefulness of polymorphism [
To program the task, one can use, for example, the Java programming language [
Part of the program code can be created by students individually, part - together with the teacher as
part of the work with a projector. In the process, the possibilities of the Eclipse environment can be
explored, such as: automatic error detection and suggestions for automatic fixing; automatic creation
of inherited classes with overriding methods; automatic refactoring [
return _name; } public int getTotalScore() {
return _totalScore; } public void startGame(){} public abstract int yourAnswer(); public void enemyAnswer(int answer){} public void finishGame(int score){
_totalScore+=score; } } } } }
Listing 2 shows the code for the rogue player class. The yourAnswer () method always returns a
NO response. This is the only change that was required for the class, all the rest of the code is
automatically generated [
Listing 2: EvilPlayer class program code public class EvilPlayer extends Player { public EvilPlayer(String _name) {
super(_name); @Override public int yourAnswer() { return NO;
Somewhat more complex is the code for a player who implements the eye-for-eye strategy (Listing 3).
Listing 3: TalionPlayer class code public class TalionPlayer extends Player { private int _lastAnswer; public TalionPlayer(String _name) {
super(_name);
The private field _lastAnswer stores the last response of the adversary. It is written there by the overridden method enemyAnswer (). In the next step, the method yourAnswer () simply repeats the opponent's previous move.
Running the model yields the expected results-an overall win for the tit-for-tat strategy, despite this player's losses in individual matches.
The matrix of results by match and the graph of results and are shown in Table 5 and Figure 2, respectively.
Talion 2 Talion 1
Evil 2 Random 2 Random 1
Evil 3
Evil 1 Random 3
Further, the teacher may discuss the results obtained. Explain the reasons for the advantages of cooperation under certain conditions. Think about further work on the model.
Of interest is the expansion of the number of strategies [
Finally, it is possible to implement the evolutionary principle - the tournament is repeated several
times (generations), each strategy is considered an "individual" and the number of these strategies in
each next generation depends on the results of the previous step. [
To assess the effectiveness of mastery of the material as a result of the lesson, students were tested on a pre-developed set of tests.
Table 6 shows the results of the tests for one group of students. The tests were administered during the next lesson one week after the completion of the "Strategy Tournament". 13 14 15 16 17 18 total 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Total 100% 75% 100% 100% 75% 50% 79% 100% 67% 100% 33% 100% 67% 78% 50% 75% 50% 100% 25% 0% 25% 25% 50% 50% 75% 75% 50% 75% 50% 52%
The results of the control group (which examined similar sections using traditional methods) are shown in Table 7.
To assess the significance of the differences in the two groups, we use the statistical test MannWhitney. This is necessary because they are independent samples and the sample size requires the use of non-parametric methods. student
The assessment is carried out according to the formula: where Tx is the largest sum of ranks, nx is the largest of the sample sizes n1 and n2.
Calculation results:
The hypothesis H0 about the insignificance of the differences between the samples is accepted if Ucr < Uemp. Otherwise, H0 is rejected and the difference is identified as significant, where Ukp is the critical point, which is found using the Mann-Whitney table. 75% 75% 100% 100% 100% 100% 89% UML 75% 75% 50% 100% 100% 75% 50% 50% 75% 75% 50% 0% 25% 50% 25% 58% 100% 100% 100% 100% 100% 67% 93% OOP 67% 100% 67% 100% 100% 100% 67% 100% 100% 100% 67% 100% 67% 67% 67% 84% 88% 76% 100% 88% 94% 76% 85% Total 53% 71% 59% 100% 59% 41% 41% 41% 47% 71% 59% 53% 53% 53% 41% 56% From the table we find Ukp (0.05) = 99. Since Ukp > Uemp, we reject the null hypothesis. Figure 6 shows an illustration of the results obtained.
As can be seen from the tables and the figure, as a result of introducing an innovative teaching method, there is a significant increase in the uptake of material on "economic" topics, but also some increase in topics specific to computer science and programming [37].
This suggests that I program to understand learning is quite effective [
At the same time, it is necessary to pay attention to the cost of introducing the described approach into the educational process, which is associated with the need for deep study of the material for the implementation of the game "balance". At the same time, the pedagogical and methodological documentation of the university in the traditional version does not imply a reflection of this level of methodological materials, which means that the corresponding costs remain hidden. The study of the economic side of the pedagogical and methodological involvement of game methods and projectbased learning must be further developed.
In this paper, the methodological support for the construction of a game simulation model was analyzed using the example of the "Tournament of strategies" problem.
It was experimentally shown that the use of such models can improve both programming skills and understanding of the subject area (economics and management).
The research was carried out with the financial support of the Russian Foundation for Basic Research (RFBR) within the framework of the scientific project 19-013-00690 "Economics of educational and methodological activities in higher education".