Flexible learning, rather than inveterate innovation or copying, drives cumulative knowledge gain

Cumulative cultural evolution is driven by pragmatic individuals who know when to copy, innovate, explore, and take risks flexibly.

Average score increment relative to the current leader, for each author in each contest, as a function of the number of entries, rescaled in [0,1]. Blue points indicate leading authors (i.e. authors that took the lead in any contest), red dots indicate non-leading authors (i.e. authors that never took the lead). Authors who achieved leading status tend to be highly active (in blue, top right-hand of the graph), while barely any authors who were not active achieved leading status (in red, bottom left-hand of the graph). Positive and negative score differences as a function of leadership. Distribution of positive score differences submitted by leading authors (left), negative score differences submitted by leading authors (centre), and negative score differences submitted by non-leading authors (right).

Table S1
The effect of social learning and exploration on performance. Perfomance is measured as normalized mean increment. Results from GLMM: MeanScoreDifference ~ MeanLeaderSimilarity + RangeLeaderSimilarity + (1|Contest).
Predictors are standardized -similarity ranges theoretically between 0 and 1, and score difference between -1 and 1.

Fig. S5 Influence over time.
Influence for all passed entries submitted from day 3 onwards in all 19 contests. The y-axis represents the influence (log-transformed normalized average similarity between each entry and the subsequent entries submitted by other contestants), and the x-axis plots time, normalized between 0 and 1. This contest is based on a simple peg jumping game. In a typical game of Peg Solitaire, the board contains pegs (sometimes marbles) and at least one empty space. Pegs can be removed by jumping over them with another peg, and the aim is to remove as many pegs with a combination of jumping moves. This implements an extended version of the original Peg Solitaire game, in which the pegs carry points, and the goal is to jump pegs in order to make the score as low as possible. This may mean it is not necessary to remove all the pegs. Each peg has a value, or weight. A move consists of one peg jumping over and thereby removing another peg. A "jump" is a horizontal or vertical move in which one peg passes over exactly one other peg and comes to rest on an empty space. Diagonal jumps are not permitted. There is a reward for every peg removed from the board according to its weight, and a penalty for each jump according to the weight of the jumping peg. The score is therefore the difference between the value of the peg being jumped over and the jumping peg. Therefore a good score can be achieved by jumping with a low value peg over a high value peg; the bigger the difference between the values of the two pegs, the better the score. If, however, a high value peg is used to jump over a low value peg, the score decreases.
A peg with weight 1 jumps over a peg with weight 3. The reward is 3 and the penalty is 1, therefore the value of the move is 2. If several jumps in a row can be performed using the same peg, the penalty only has to be paid once. In more detail: -Each peg has a weight, which is always positive.
-The board is a matrix. Each positive number indicates a peg, zeros indicate empty squares, and negative numbers indicate off limits squares outside of the board. -Every move is a four-element row vector with the format [from_row from_column to_row to_column] -The code must return a four-column move matrix in which each row represents one move.
This matrix can have any number of rows between 0 and (numpegs -1). Any number of rows exceeding this are ignored. -The value of each move is the sum of the removal bonus and the jumping penalty.
-Consecutive moves by a single peg only incur one jumping penalty.
-The score starts at a high value (the sum of all the peg weights). After each move, the point value of that move is subtracted from the score. The goal is to minimize the score. -An invalid move does not generate an error -the board remains unchanged and the jumping penalty is still paid. The overall score of an entry is a combination of three factors: result -the average score across all game boards runtime -how fast the code runs