PowerPlay: Training an Increasingly General Problem Solver by Continually Searching for the Simplest Still Unsolvable Problem

Most of computer science focuses on automatically solving given computational problems. I focus on automatically inventing or discovering problems in a way inspired by the playful behavior of animals and humans, to train a more and more general problem solver from scratch in an unsupervised fashion. Consider the infinite set of all computable descriptions of tasks with possibly computable solutions. Given a general problem-solving architecture, at any given time, the novel algorithmic framework PowerPlay (Schmidhuber, 2011) searches the space of possible pairs of new tasks and modifications of the current problem solver, until it finds a more powerful problem solver that provably solves all previously learned tasks plus the new one, while the unmodified predecessor does not. Newly invented tasks may require to achieve a wow-effect by making previously learned skills more efficient such that they require less time and space. New skills may (partially) re-use previously learned skills. The greedy search of typical PowerPlay variants uses time-optimal program search to order candidate pairs of tasks and solver modifications by their conditional computational (time and space) complexity, given the stored experience so far. The new task and its corresponding task-solving skill are those first found and validated. This biases the search toward pairs that can be described compactly and validated quickly. The computational costs of validating new tasks need not grow with task repertoire size. Standard problem solver architectures of personal computers or neural networks tend to generalize by solving numerous tasks outside the self-invented training set; PowerPlay’s ongoing search for novelty keeps breaking the generalization abilities of its present solver. This is related to Gödel’s sequence of increasingly powerful formal theories based on adding formerly unprovable statements to the axioms without affecting previously provable theorems. The continually increasing repertoire of problem-solving procedures can be exploited by a parallel search for solutions to additional externally posed tasks. PowerPlay may be viewed as a greedy but practical implementation of basic principles of creativity (Schmidhuber, 2006a, 2010). A first experimental analysis can be found in separate papers (Srivastava et al., 2012a,b, 2013).


Introduction
Given a realistic piece of computational hardware with specific resource limitations, how can one devise software for it that will solve all, or at least many, of the a priori unknown tasks that are in principle easily solvable on this architecture?In other words, how to build a practical general problem solver, given the computational restrictions?It does not need to be universal and asymptotically optimal [17,13,41,44] like the recent (not necessarily practically feasible) general problem solvers discussed in Section 9.1; instead it should take into account all constant architecture-specific slowdowns ignored in the asymptotic optimality notation of theoretical computer science, and be generally useful for real-world applications.
Let us draw inspiration from biology.How do initially helpless human babies become rather general problem solvers over time?Apparently by playing.For example, even in the absence of external reward or hunger they are curious about what happens if they move their eyes or fingers in particular ways, creating little experiments which lead to initially novel and surprising but eventually predictable sensory inputs, while also learning motor skills to reproduce these outcomes.(See [31,30,37,42,45,62] and Section 9.3 for previous artificial systems of this type.)Infants continually seem to invent new tasks that become boring as soon as their solutions become known.Easy-to-learn new tasks are preferred over unsolvable or hard-to-learn tasks.Eventually the numerous skills acquired in this creative, self-supervised way may get re-used to facilitate the search for solutions to external problems, such as finding food when hungry.While kids keep inventing new problems for themselves, they move through remarkable developmental stages [23,2,11].
Here I introduce a novel unsupervised algorithmic framework for training a computational problem solver from scratch, continually searching for the simplest (fastest to find) combination of task and corresponding task-solving skill to add to its growing repertoire, without forgetting any previous skills (Section 2), or at least without decreasing average performance on previously solved tasks (Section 7.1).New skills may (partially) re-use previously learned skills.Every new task added to the repertoire is essentially defined by the time required to invent it, to solve it, and to demonstrate that no previously learned skills got lost.The search takes into account that typical problem solvers may learn to solve tasks outside the growing self-made training set due to generalization properties of their architectures.The framework is called POW-ERPLAY because it continually [25] aims at boosting computational prowess and problem solving capacity, reminiscent of humans or human societies trying to boost their general power/capabilities/knowledge/skills in playful ways, even in the absence of externally defined goals, although the skills learned by this type of pure curiosity may later help to solve externally posed tasks.
Unlike our first implementations of curious/creative/playful agents from the 1990s [30,54,37] (Section 9.3; compare [1,5,22,20]), POWERPLAY provably (by design) does not have any problems with online learning-it cannot forget previously learned skills, automatically segmenting its life into a sequence of clearly identified tasks with explicitly recorded solutions.Unlike the task search of theoretically optimal creative agents [42,45] (Section 9.3), POWERPLAY's task search is greedy, but at least practically feasible.Some claim that scientists often invent appropriate problems for their methods, rather than inventing methods to solve given problems.The present paper formalizes this in a way that may be more convenient to implement than those of previous work [30,37,42,45], and describes a simple practical framework for building creative artificial scientists or explorers that by design continually come up with the fastest to find, initially novel, but eventually solvable problems.

Basic Ideas
In traditional computer science, given some formally defined task, a search algorithm is used to search a space of solution candidates until a solution to the task is found and verified.If the task is hard the search may take long.
To automatically construct an increasingly general problem solver, let us expand the traditional search space in an unusual way, such that it includes all possible pairs of computable tasks with possibly computable solutions, and problem solvers.Given an old problem solver that can already solve a finite known set of previously learned tasks, a search algorithm is used to find a new pair that provably has the following properties: (1) The new task cannot be solved by the old problem solver.(2) The new task can be solved by the new problem solver (some modification of the old one).(3) The new solver can still solve the known set of previously learned tasks.
Once such a pair is found, the cycle repeats itself.This will result in a continually growing set of known tasks solvable by an increasingly more powerful problem solver.Solutions to new tasks may (partially) reuse solutions to previously learned tasks.
Smart search (e.g., Section 4.1, Algorithm 4.1) orders candidate pairs of the type (task, solver) by computational complexity, using concepts of optimal universal search [17,41], with a bias towards pairs that can be described by few additional bits of information (given the experience so far) and that can be validated quickly.
At first glance it might seem harder to search for pairs of tasks and solvers instead of solvers only, due to the apparently larger search space.However, the additional freedom of inventing the tasks to be solved may actually greatly reduce the time intervals between problem solver advances, because the system may often have the option of inventing a rather simple task with an easy-to-find solution.
A new task may be about simplifying the old solver such that it can still solve all tasks learned so far, but with less computational resources such as time and storage space (e.g., Section 3.1 and Algorithm 7.1).
Since the new pair (task, solver) is the first one found and validated, the search automatically trades off the time-varying efforts required to either invent completely new, previously unsolvable problems, or compressing/speeding up previous solutions.Sometimes it is easier to refine or simplify known skills, sometimes to invent new skills.
On typical problem solver architectures of personal computers (PCs) or neural networks (NNs), while a limited known number of previously learned tasks has become solvable, so too has a large number of unknown, never-tested tasks (in the field of Machine Learning, this is known as generalization).POWER-PLAY's ongoing search is continually testing (and always trying to go beyond) the generalization abilities of the most recent solver instance; some of its search time has to be spent on demonstrating that self-invented new tasks are not already solvable.
Often, however, much more time will have to be spent on making sure that a newly modified solver did not forget any of the possibly many previously learned skills.Problem solver modularization (Section 3.3, especially 3.3.2) may greatly reduce this time though, making POWERPLAY prefer pairs whose validation does not require the re-testing of too many previously learned skills, thus decomposing at least part of the search space into somewhat independent regions, realizing divide and conquer strategies as by-products of its built-in drive to invent and validate novel tasks/skills as quickly as possible.
A biologically inspired hope is that as the problem solver is becoming more and more general, it will find it easier and easier to solve externally posed tasks (Section 6), just like growing infants often seem to re-use their playfully acquired skills to solve teacher-given problems.

Outline of Remainder
Section 2 will introduce basic notation and Variant 1 of the algorithmic framework POWERPLAY, which invokes the essential procedures TASK INVENTION, SOLVER MODIFICATION, and CORRECTNESS DEMON-STRATION.Section 3 will discuss details of these procedures.
More detailed instantiations of POWERPLAY will be described in Section 4.3 (an evolutionary method, Alg.4.3) and Section 4.1 (an asymptotically optimal program search method, Alg.4.1).
As mentioned above, the skills acquired to solve self-generated tasks may later greatly facilitate solutions to externally posed tasks, just like the numerous motor skills learned by babies during curious exploration of its world often can be re-used later to maximize external reward.Sections 6 and 7.1 will discuss variants of the framework (e.g., Algorithm 7.1) in which some of the tasks can be defined externally.
Section 7.1 will also describe a natural variant of the framework that explicitly penalizes solution costs (including time and space complexity), and allows for forgetting aspects of previous solutions, provided the average performance on previously solved tasks does not decrease.Section 8 will point to illustrative experiments in separate papers [53,52].Section 9 will discuss relations to previous work.

Notation & Algorithmic Framework POWERPLAY (Variant I)
B * denotes the set of finite sequences or bitstrings over the binary alphabet B = {0, 1}, λ the empty string, x, y, z, p, q, r, u strings in B * , N the natural numbers, R the real numbers, ǫ ∈ R a positive constant, m, n, n 0 , k, i, j, k, l non-negative integers, L(x) the number of bits in x (where L(λ) = 0), f, g functions mapping integers to integers.We write The computational architecture of the problem solver may be a deterministic universal computer, or a more limited device such as a finite state automaton or a feedforward neural network (NN) [3].All such problem solvers can be uniquely encoded [9] or implemented on universal computers such as universal Turing Machines (TM) [56].Therefore, without loss of generality, the remainder of this paper assumes a fixed universal reference computer whose input programs and outputs are elements of B * .A user-defined subset S ⊂ B * defines the set of possible problem solvers.For example, if the problem solver's architecture is itself a binary universal TM or a standard computer, then S represents its set of possible programs, or a limited subset thereof-compare Sections 3.2 and 4.1.If it is a feedforward NN, then S could be a highly restricted subset of programs encoding the NN's possible topologies and weights (floating point numbers)-compare Section 8 and the original SLIM NN paper [47].
In what follows, for convenience I will often identify bitstrings in B * with things they encode, such as integers, real-valued vectors, weight matrices, or programs-the context will always make clear what is meant.
The problem solver's initial program is called s 0 .There is a set of possible task descriptions T ⊂ B * .T may be the infinite set of all possible computable descriptions of tasks with possibly computable solutions, or just a small subset thereof.For example, a simple task may require the solver to answer a particular input pattern with a particular output pattern (more formal details on pattern recognition tasks are given in Section 3.1.1).Or it may require the solver to steer a robot towards a goal through a sequence of actions (more formal details on sequential decision making tasks in unknown environments are given in Section 3.1.2).There is a particular sequence of task descriptions T 1 , T 2 , . .., where each unique T i ∈ T (i = 1, 2, . ..) is chosen or "invented" by a search method described below such that the solutions of T 1 , T 2 , . . ., T i can be computed by s i , the i-th instance of the program, but not by s i−1 (i = 1, 2, . ..).Each T i consists of a unique problem identifier that can be read by s i through some built-in input processing mechanism (e.g., input neurons of an NN [47]), and a unique description of a deterministic procedure for determining whether the problem has been solved.Denote T ≤i = {T 1 , . . ., T i }; T <i = {T 1 , . . ., T i−1 }.
A valid task T i (i > 1) may require solving at least one previously solved task T k (k < i) more efficiently, by using less resources such as storage space, computation time, energy, etc., thus achieving a wow-effect.See Section 3.1.
Tasks and problem solver modifications are computed and validated by elements of another appropriate set of programs P ⊂ B * .Programs p ∈ P may contain instructions for reading and executing (parts of) the code of the present problem solver and reading (parts of) a recorded history T race ∈ B * of previous events that led to the present solver.The algorithmic framework (Alg.2) incrementally trains the problem solver by finding p ∈ P that increase the set of solvable tasks.

TASK INVENTION, SOLVER MODIFICATION, CORRECTNESS DEMO
A program tested by Alg. 2 has to allocate its runtime to solve three main jobs, namely, TASK INVENTION, SOLVER MODIFICATION, CORRECTNESS DEMONSTRATION.Now examples of each will be listed.

Implementing TASK INVENTION
Part of the job of p i ∈ P is to compute T i ∈ T .This will consume some of the total computation time allocated to p i .Two examples will be given: pattern recognition tasks are treated in Section 3.1.1;sequential decision making tasks in Section 3.1.2.

Alg. 2: Algorithmic Framework POWERPLAY (Variant I)
Initialize s 0 in some way.T and all T k (k < i) can be solved by q.See Section 3.3.until CORRECTNESS DEMONSTRATION was successful Set p i := p; T i := T ; s i := q; update T race.end for

Example: Pattern Recognition Tasks
In the context of learning to recognize or analyze patterns, T i could be a 4-tuple and T i is solved if s i satisfies L(s i ) < n i and needs at most t i discrete time steps to read I i and compute O i and halt.Here I i itself may be a pair (I 1 i , I 2 i ) ∈ B * × B * , where i is constrained to be the address of an image in a given database of patterns, and I 2 i is a p i -generated "query" that uniquely specifies how the image should be classified through target pattern O i , such that the same image can be analyzed in different ways during different tasks.For example, depending on the nature of the invented task sequence, the problem solver could eventually learn that O = 1 if I 2 = 1001 (suppressing task indices) and the image addressed by I 1 contains at least one black pixel, or if I 2 = 0111 and the image shows a cow.
Since the definition of task T i includes bounds n i , t i on computational resources, T i may be about solving at least one T k (k < i) more efficiently, corresponding to a wow-effect.This in turn may also yield more efficient solutions to other tasks T l (l < i, l = k).In practical applications one may insist that such efficiency gains must exceed a certain threshold ǫ > 0, to avoid task series causing sequences of very minor improvements.
Note that n i and t i may be unnecessary in special cases such as the problem solver being a fixed topology feedforward NN [3] whose input and target patterns have constant size and whose computational efforts per pattern need constant time and space resources.
Assuming sufficiently powerful S, P, in the beginning, trivial tasks such as simply copying I 2 i onto O i may be interesting in the sense that POWERPLAY can still validate and accept them, but they will become boring (inadmissible) as soon as they are solvable by solutions to previous tasks that generalize to new tasks.

Example: General Decision Making Tasks in Dynamic Environments
In the more general context of general problem solving/sequential decision making/reinforcement learning/reward optimization [21,15,55] in unknown environments, there may be a set I ⊂ B * of possible task identification patterns and a set J ⊂ B * of programs that test properties of bitstrings.T i could then encode a 4-tuple (I i , J i , t i , n i ) ∈ I × J × N × N of finite bitstrings with the following interpretation: s i must satisfy L(s i ) < n i and may spend at most t i discrete time steps on first reading I i and then interacting with an environment through a sequence of perceptions and actions, to achieve some computable goal defined by J i .
More precisely, while T i is being solved within t i time steps, at any given time 1 ≤ t ≤ t i , the internal state of the problem solver at time t is denoted u i (t) ∈ B * ; its initial default value is u i (0).For example, u i (t) may encode the current contents of the internal tape of a TM, or of certain addresses in the dynamic storage area of a PC, or the present activations of an LSTM recurrent NN [12].At time t, s i can spend a constant number of elementary computational instructions to copy the task dscription T i or the present environmental input x i (t) ∈ B * and a reward signal r i (t) ∈ B * (interpreted as a real number) into parts of u i (t), then update other parts of u i (t) (a function of u i (t − 1)) and compute action y i (t) ∈ B * encoded as a part of u i (t).y i (t) may affect the environment, and thus future inputs.
If P allows for programs that can dynamically acquire additional physical computational resources such as additional CPUs and storage, then the above constant number of elementary computational instructions should be replaced by a constant amount of real time, to be measured by a reliable physical clock.
The sequence of 4-tuples (x i (t), r i (t), u i (t), y i (t)) (t = 1, . . ., t i ) gets recorded by the so-called trace T race i ∈ B * .If at the end of the interaction a desirable computable property J i (T race i ) (computed by applying program J i to T race i ) is satisfied, then by definition the task is solved.The set J of possible J i may represent an infinite set of all computable tasks with solutions computable by the given hardware.For practical reasons, however, the set J of possible J i may also be restricted to bit sequences encoding just a few possible goals.For example, J i may only encode goals of the form: a robot arm steered by program or "policy" s i has reached a certain target (a desired final observation x i (t i ) recorded in T race i ) without measurably bumping into an obstacle along the way, that is, there were no negative rewards, that is, If the environment is deterministic, e.g., a digital physics simulation of a robot, then its current state can be encoded as part of u(t), and it is straight-forward for CORRECTNESS DEMONSTRATION to test whether some s i still can solve a previously solved task T j (j < i).However, what if the environment is only partially observable, like the real world, and non-stationary, changing in unknown ways?Then COR-RECTNESS DEMONSTRATION must check whether s i still produces the same action sequence in response to the input sequence recorded in T race j (often this replay-based test will actually be computationally cheaper than a test involving the environment).Achieving the same goal in a changed environment must be considered a different task, even if the changes are just due to noise on the environmental inputs.(Sure, in the real world s j (j > i) might actually achieve J i faster than s i , given the description of T i , but COR-RECTNESS DEMONSTRATION in general cannot know whether this acceleration was due to plain luck-it must stick to reproducing T race j to make sure it did not forget anything.)See Section 7.2, however, for a less strict POWERPLAY variant whose CORRECTNESS DEMONSTRA-TION directly interacts with the real world to collect sufficient problem-solving statistics through repeated trials, making certain assumptions about the probabilistic nature of the environment, and the repeatability of experiments.

Implementing SOLVER MODIFICATION
Part of the job of p i ∈ P is also to compute s i , possibly profiting from having access to s i−1 , because only few changes of s i−1 may be necessary to come up with an s i that goes beyond s i−1 .For example, if the problem solver is a standard PC, then just a few bits of the previous software s i−1 may need to be changed.
For practical reasons, the set S of possible s i may be greatly restricted to bit sequences encoding programs that obey the syntax of a standard programming language such as LISP or Java.In turn, the programming language describing P should be greatly restricted such that any p i ∈ P can only produce syntactically correct s i .
If the problem solver is a feedforward NN with pre-wired, unmodifiable topology, then S will be restricted to those bit sequences encoding valid weight matrices, s i will encode its i-th weight matrix, and P will be restricted to those p ∈ P that can produce some s i ∈ S. Depending on the user-defined programming language, p i may invoke complex pre-wired subprograms (e.g., well-known learning algorithms) as primitive instructions-compare separate experimental analysis [53,52].
In general, p itself determines how much time to spend on SOLVER MODIFICATION-enough time must be left for TASK INVENTION and CORRECTNESS DEMONSTRATION.

Implementing CORRECTNESS DEMONSTRATION
Correctness demonstration may be the most time-consuming obligation of p i .At first glance it may seem that as the sequence T 1 , T 2 , . . . is growing, more and more time will be needed to show that s i but not s i−1 can solve T 1 , T 2 , . . ., T i , because one naive way of ensuring correctness is to re-test s i on all previously solved tasks.Theoretically more efficient ways are considered next.

Most General: Proof Search
The most general way of demonstrating correctness is to encode (in read-only storage) an axiomatic system A that formally describes computational properties of the problem solver and possible s i , and to allow p i to search the space of possible proofs derivable from A, using a proof searcher subroutine that systematically generates proofs until it finds a theorem stating that s i but not s i−1 solves T 1 , T 2 , . . ., T i (proof search may achieve this efficiently without explicitly re-testing s i on T 1 , T 2 , . . ., T i ).This could be done like in the Gödel Machine [44] (Section 9.1), which uses an online extension of Universal Search [17] to systematically test proof techniques: proof-generating programs that may invoke special instructions for generating axioms and applying inference rules to prolong an initially empty proof ∈ B * by theorems, which are either axioms or inferred from previous theorems through rules such as modus ponens combined with unification, e.g., [7].P can be easily limited to programs generating only syntactically correct proofs [44].A has to subsume axioms describing how any instruction invoked by some s ∈ S will change the state u of the problem solver from one step to the next (such that proof techniques can reason about the effects of any s i ).Other axioms encode knowledge about arithmetics etc (such that proof techniques can reason about spatial and temporal resources consumed by s i ).
In what follows, CORRECTNESS DEMONSTRATIONS will be discussed that are less general but sometimes more convenient to implement.

Keeping Track Which Components of the Solver Affect Which Tasks
Often it is possible to partition s ∈ S into components, such as individual bits of the software of a PC, or weights of a NN.Here the k-th component of s is denoted s k .For each k (k = 1, 2, . ..) a variable list L k = (T k 1 , T k 2 , . ..) is introduced.Its initial value before the start of POWERPLAY is L k 0 , an empty list.Whenever p i found s i and T i at the end of CORRECTNESS DEMONSTRATION, each L k is updated as follows: Its new value L k i is obtained by appending to L k i−1 those T j / ∈ L k i−1 (j = 1, . . ., i) whose current (possibly revised) solutions now need s k at least once during the solution-computing process, and deleting those T j whose current solutions do not use s k any more.
POWERPLAY's CORRECTNESS DEMONSTRATION thus has to test only tasks in the union of all L k i .That is, if the most recent task does not require changes of many components of s, and if the changed bits do not affect many previous tasks, then CORRECTNESS DEMONSTRATION may be very efficient.
Since every new task added to the repertoire is essentially defined by the time required to invent it, to solve it, and to show that no previous tasks became unsolvable in the process, POWERPLAY is generally "motivated" to invent tasks whose validity check does not require too much computational effort.That is, POWERPLAY will often find p i that generate s i−1 -modifications that don't affect too many previous tasks, thus decomposing at least part of the spaces of tasks and their solutions into more or less independent regions, realizing divide and conquer strategies as by-products.Compare a recent experimental analysis of this effect [53,52].

Advantages of Prefix Code-Based Problem Solvers
Let us restrict P such that tested p ∈ P cannot change any components of s i−1 during SOLVER MOD-IFICATION, but can create a new s i only by adding new components to s i−1 .(This means freezing all used components of any s k once T k is found.)By restricting S to self-delimiting prefix codes like those generated by the Optimal Ordered Problem Solver (OOPS) [41], one can now profit from a sometimes particularly efficient type of CORRECTNESS DEMONSTRATION, ensuring that differences between s i and s i−1 cannot affect solutions to T <i under certain conditions.More precisely, to obtain s i , half the search time is spent on trying to process T i first by s i−1 , extending or prolonging s i−1 only when the ongoing computation requests to add new components through special instructions [41]-then CORRECTNESS DEMONSTRATION has less to do as the set T <i is guaranteed to remain solvable, by induction.The other half of the time is spent on processing T i by a new sub-program with new components s ′ i , a part of s i but not of s i−1 , where s ′ i may read s i−1 or invoke parts of s i−1 as sub-programs to solve T ≤i -only then CORRECTNESS DEMONSTRATION has to test s i not only on T i but also on T <i (see [41] for details).
A simple but not very general way of doing something similar is to interleave TASK INVENTION, SOLVER MODIFICATION, CORRECTNESS DEMONSTRATION as follows: restrict all p ∈ P such that they must define I i := i as the unique task identifier I i for T i (see Section 3.1.2);restrict all s ∈ S such that the input of I i = i automatically invokes sub-program s ′ i , a part of s i but not of s i−1 (although s ′ i may read s i−1 or invoke parts of s i−1 as sub-programs to solve T i ).Restrict J i to a subset of acceptable computational outcomes (Section 3.1.2).Run s i until it halts and has computed a novel output acceptable by J i that is different from all outputs computed by the (halting) solutions to T <i ; this novel output becomes T i 's goal.By induction over i, since all previously used components of s i−1 remain unmodified, the set T <i is guaranteed to remain solvable, no matter s ′ i .That is, CORRECTNESS DEMONSTRATION on previous tasks becomes trivial.However, in this simple setup there is no immediate generalization across tasks like in OOPS [41] and the previous paragraph: the trivial task identifier i will always first invoke some s ′ i different from all s ′ k (k = i), instead of allowing for solving a new task solely by previously found code.

Implementations of POWERPLAY
POWERPLAY is a general framework that allows for plugging in many differents search and learning algorithms.The present section will discuss some of them.

Implementation Based on Optimal Ordered Problem Solver OOPS
Alg. 4.1: Implementing POWERPLAY with Procedure OOPS [41] (see text for details) -initialize s 0 and u (internal dynamic storage for s ∈ S) and U (internal dynamic storage for p ∈ P), where each possible p is a sequence of subprograms p ′ , p 2. Let p ′′ compute q ∈ S by modifying a copy of s i−1 , and halt.3. Let p ′′′ try to show that q but not s i−1 can solve T 1 , T 2 , . . ., T i−1 , T .If p ′′′ was successful set DONE := TRUE.end while Undo all modifications of u and U due to p.This does not cost more time than executing p in the while loop above [41].end if until DONE set p i := p; T i := T ; s i := q; add a unique encoding of the 5-tuple (i, p i , s i , T i , T race i ) to read-only storage readable by programs to be tested in the future.

end for
The i-th problem is to find a program p i ∈ P that creates s i and T i and demonstrates that s i but not s i−1 can solve T 1 , T 2 , . . ., T i .This yields a perfectly ordered problem sequence for a variant of the Optimal Ordered Problem Solver OOPS [41] (Algorithm 4.1).
While a candidate program p ∈ P is executed, at any given discrete time step t = 1, 2, ..., its internal state or dynamical storage U at time t is denoted U (t) ∈ B * (not to be confused with the solver's internal state u(t) of Section 3.1.2).Its initial default value is U (0). E.g., U (t) could encode the current contents of the internal tape of a TM (to be modified by p), or of certain cells in the dynamic storage area of a PC.
Once p i is found, p i , s i , T i , T race i (if applicable; see Section 3.1.2)will be saved in unmodifiable readonly storage, possibly together with other data observed during the search so far.This may greatly facilitate the search for p k , k > i, since p k may contain instructions for addressing and reading p j , s j , T j , T race j (j = 1, . . ., k − 1) and for copying the read code into modifiable storage U , where p k may further edit the code, and execute the result, which may be a useful subprogram [41].
Define a probability distribution P (p) on P to represent the searcher's initial bias (more likely programs p will be tested earlier [17]).P could be based on program length, e.g., P (p) = 2 −L(p) , or on a probabilistic syntax diagram [41,40].See Algorithm 4.1.
OOPS keeps doubling the time limit until there is sufficient runtime for a sufficiently likely program to compute a novel, previously unsolvable task, plus its solver, which provably does not forget previous solutions.OOPS allocates time to programs according to an asymptotically optimal universal search method [17] for problems with easily verifiable solutions, that is, solutions whose validity can be quickly tested.Given some problem class, if some unknown optimal program p requires f (k) steps to solve a problem instance of size k and demonstrate the correctness of the result, then this search method will need at most O(f (k)/P (p)) = O(f (k)) steps-the constant factor 1/P (p) may be large but does not depend on k.Since OOPS may re-use previously generated solutions and solution-computing programs, however, it may be possible to greatly reduce the constant factor associated with plain universal search [41].
The big difference to previous implementations of OOPS is that POWERPLAY has the additional freedom to define its own tasks.As always, every new task added to the repertoire is essentially defined by the time required to invent it, to solve it, and to demonstrate that no previously learned skills got lost.

Building on Existing OOPS Source Code
Existing OOPS source code [40] uses a FORTH-like universal programming language to define P. It already contains a framework for testing new code on previously solved tasks, and for efficiently undoing all U -modifications of each tested program.The source code will require a few changes to implement the additional task search described above.

Alternative Problem Solvers Based on Recurrent Neural Networks
Recurrent NNs (RNNs, e.g., [59,61,27,32,12]) are general computers that allow for both sequential and parallel computations, unlike the strictly sequential FORTH-like language of Section 4.1.1.They can compute any function computable by a standard PC [29].The original report [46] used a fully connected RNN called RNN1 to define S, where w lk is the real-valued weight on the directed connection between the l-th and k-th neuron.To program RNN1 means to set the weight matrix s = w lk .Given enough neurons with appropriate activation functions and an appropriate w lk , Algorithm 4.1 can be used to train s.P may itself be the set of weight matrices of a separate RNN called RNN2, computing tasks for RNN1, and modifications of RNN1, using techniques for network-modifying networks as described in previous work [33,35,34].
In first experiments [53,52], a particularly suited NN called a self-delimiting NN or SLIM NN [47] is used.During program execution or activation spreading in the SLIM NN, lists are used to trace only those neurons and connections used at least once.This also allows for efficient resets of large NNs which may use only a small fraction of their weights per task.Unlike standard RNNs, SLIM NNs are easily combined with techniques of asymptotically optimal program search [17,48,39,41] (Section 4.1).To address overfitting, instead of depending on pre-wired regularizers and hyper-parameters [3], SLIM NNs can in principle learn to select by themselves their own runtime and their own numbers of free parameters, becoming fast and slim when necessary.Efficient SLIM NN learning algorithms (LAs) track which weights are used for which tasks (Section 3.3.2),to greatly speed up performance evaluations in response to limited weight changes.LAs may penalize the task-specific total length of connections used by SLIM NNs implemented on the 3-dimensional brain-like multi-processor hardware to expected in the future.This encourages SLIM NNs to solve many subtasks by subsets of neurons that are physically close [47].

Adapting the Probability Distribution on Programs
A straightforward extension of the above works as follows: Whenever a new p i is found, P is updated to make either only p i or all p 1 , p 2 , . . ., p i more likely.Simple ways of doing this are described in previous work [48].This may be justified to the extent that future successful programs turn out to be similar to previous ones.

Implementation Based on Stochastic or Evolutionary Search
A possibly simpler but less general approach is to use an evolutionary algorithm to produce an s-modifying and task-generating program p as requested by POWERPLAY, according to Algorithm 4.3, which refers to the recurrent net problem solver of Section 4.1.2.

Alg. 4.3: POWERPLAY for RNNs Using Stochastic or Evolutionary Search
Randomly initialize RNN1's variable weight matrix w lk and use the result as s 0 (see Section 4.1.2) for i := 1, 2, . . .do set Boolean variable DONE=FALSE repeat use a black box optimization algorithm BBOA (many are possible [24,10,60,49]) with adaptive parameter vector θ to create some T ∈ T (to define the task input to RNN1; see Section 3.1) and a modification of s i−1 , the current w lk of RNN1, thus obtaining a new candidate q ∈ S if q but not s i−1 can solve T and all T k (k < i) (see Sections 3.3, 3.3.2) then set DONE=TRUE end if until DONE set s i := q; w lk := q; T i := T ; (also store T race i if applicable, see Section 3.1.2).Use the information stored so far to adapt the parameters θ of the BBOA, e.g., by gradient-based search [60,49], or according to the principles of evolutionary computation [24,10,60].end for

Outgrowing Trivial Tasks -Compressing Previous Solutions
What prevents POWERPLAY from inventing trivial tasks forever by extreme modularization, simply allocating a previously unused solver part to each new task, which thus becomes rather quickly verifiable, as its solution does not affect solutions to previous tasks (Section 3.3.3)?On realistic but general architectures such as PCs and RNNs, at least once the upper storage size limit of s is reached, POWERPLAY will start "compressing" previous solutions, making s generalize in the sense that the same relatively short piece of code (some part of s) helps to solve different tasks.
With many computational architectures, this type of compression will start much earlier though, because new tasks solvable by partial reuse of earlier discovered code will often be easier to find than new tasks solvable by previously unused parts of s.This also holds for growing architectures with potentially unlimited storage space.
Compare also POWERPLAY Variant II of Section 7.1 whose tasks may explicitly require improving the average time and space complexity of previous solutions by some minimal value.
In general, however, over time the system will find it more and more difficult to invent novel tasks without forgetting previous solutions, a bit like humans find it harder and harder to learn truly novel behaviors once they are leaving behind the initial rapid exploration phase typical for babies.Experiments with various problem solver architectures (e.g., [53,52]) are needed to analyze such effects in detail.

Adding External Tasks
The growing repertoire of the problem solver may facilitate learning of solutions to externally posed tasks.For example, one may modify POWERPLAY such that for certain i, T i is defined externally, instead of being invented by the system itself.In general, the resulting s i will contain an externally inserted bias in form of code that will make some future self-generated tasks easier to find than others.It should be possible to push the system in a human-understandable or otherwise useful direction by regularly inserting appropriate external goals.See Algorithm 7.1.
Another way of exploiting the growing repertoire is to simply copy s i for some i and use it as a starting point for a search for a solution to an externally posed task T , without insisting that the modified s i also can solve T 1 , T 2 , . . ., T i .This may be much faster than trying to solve T from scratch, to the extent the solutions to self-generated tasks reflect general knowledge (code) re-usable for T .
In general, however, it will be possible to design external tasks whose solutions do not profit from those of self-generated tasks-the latter even may turn out to slow down the search.
On the other hand, in the real world the benefits of curious exploration seem obvious.One should analyze theoretically and experimentally under which conditions the creation of self-generated tasks can accelerate the solution to externally generated tasks-see [30,54,37,38,19,4,28,62] for previous simple experimental studies in this vein.

Self-Reference Through Novel Task Search as an External Task
POWERPLAY's i-th goal is to find a p i ∈ P that creates T i and s i (a modification of s i−1 ) and shows that s i but not s i−1 can solve T ≤i .As s itself is becoming a more and more general problem solver, s may help in many ways to achieve such goals in self-referential fashion.For example, the old solver s i−1 may be able to read a unique formal description (provided by p i ) of POWERPLAY's i-th goal, viewing it as an external task, and produce an output unambiguously describing a candidate for (T i , s i ).If s has a theorem prover component (Section 3.3.1),s i−1 might even output a full proof of (T i , s i )'s validity; alternatively p i could just use the possibly suboptimal suggestions of s i−1 to narrow down and speed up the search, one of the reasons why Section 2 already mentioned that programs p ∈ P should contain instructions for reading (and running) the code of the present problem solver.

Softening Task Acceptance Criteria of POWERPLAY
The POWERPLAY variants above insist that s may not solve new tasks at the expense of forgetting to solve any previously solved task within its previously established time and space bounds.For example, let us consider the sequential decision-making tasks from Section 3.1.2.Suppose the problem solver can already solve task , would be to solve T k substantially faster: t i < t k − ǫ, as long as T i is not already solvable by s i−1 , and no solution to some T l (l < i) is forgotten in the process.
Here I discuss variants of POWERPLAY that soften the acceptance criteria for new tasks in various ways, for example, by allowing some of the computations of solutions to previous non-external (Section 6) tasks to slow down by a certain amount of time, provided the sum of their runtimes does not decrease.This also permits the system to invent new previously unsolved tasks at the expense of slightly increasing time bounds for certain already solved non-external tasks, but without decreasing the average performance on the latter.Of course, POWERPLAY has to be modified accordingly, updating average runtime bounds when necessary.
Alternatively, one may allow for trading off space and time constraints in reasonable ways, e.g., in the style of asymptotically optimal Universal Search [17], which essentially trades one bit of additional space complexity for a runtime speedup factor of 2.

POWERPLAY Variant II: Explicitly Penalizing Time and Space Complexity
Let us remove time and space bounds from the task definitions of Section 3.1.2,since the modified costbased POWERPLAY framework below (Algorithm 7.1) will handle computational costs (such as time and space complexity of solutions) more directly.In the present section, T i encodes a tuple (I i , J i ) ∈ I × J with interpretation: s i must first read I i and then interact with an environment through a sequence of perceptions and actions, to achieve some computable goal defined by J i within a certain maximal time interval t max (a positive constant).Let t ′ s (T ) be t max if s cannot solve task T , otherwise it is the time needed to solve T by s.Let l ′ s (T ) be the positive constant l max if s cannot solve T , otherwise it is the number of components of s needed to solve task T by s.The non-negative real-valued reward r(T ) for solving T is a positive constant r new for self-defined previously unsolvable T , or user-defined if T is an external task solved by s (Section 6).The real-valued cost Cost(s, T SET ) of solving all tasks in a task set T SET through s is a real-valued function of: all l ′ s (T ), t ′ s (T ) (for all T ∈ T SET ), L(s), and T ∈T SET r(T ).For example, the cost function Cost(s, T SET ) = L(s) + α T ∈T SET [t ′ s (T ) − r(T )] encourages compact and fast solvers solving many different tasks with the same components of s, where the real-valued positive parameter α weighs space costs against time costs, and r new should exceed t max to encourage solutions of novel self-generated tasks, whose cost contributions should be below zero (alternative cost definitions could also take into account energy consumption etc.) Let us keep an analogue of the remaining notation of Section 3.1.2,such as u i (t), x i (t), r i (t), y i (t), T race i , J i (T race i ).As always, if the environment is unknown and possibly changing over time, to test performance of a new solver s on a previous task T k , only T race k is necessary-see Section 3.1.2.As always, let T ≤i denote the set containing all tasks T 1 , . . ., T i (note that if T i =T k for some k < i then it will appear only once in T ≤i ), and let ǫ > 0 again define what's acceptable progress:

Alg. 7.1: POWERPLAY Framework (Variant II) Explicitly Handling Costs of Solving Tasks
Initialize s 0 in some way for i := savings of costs such as time/space/etc on all tasks so far) Freeze/store forever p i , T i , s i , c i , c * i end for By Algorithm 7.1, s i may forget certain abilities of s i−1 , provided that the overall performance as measured by Cost(s i , T ≤i ) has improved, either because a new task became solvable, or previous tasks became solvable more efficiently.
Following Section 3.3, CORRECTNESS DEMONSTRATION can often be facilitated, for example, by tracking which components of s i are used for solving which tasks (Section 3.3.2).
To further refine this approach, consider that in phase i, the list L k i (defined in Section 3.3.2) contains all previously learned tasks whose solutions depend on s k .This can be used to determine the current value It is a simple exercise to invent POWERPLAY variants that do not forget valuable components as easily as less valuable ones.
The implementations of Sections 4.1 and 4.3 are easily adapted to the cost-based POWERPLAY framework.Compare separate papers [53,52].

Probabilistic POWERPLAY Variants
Section 3.1.2pointed out that in partially observable and/or non-stationary unknown environments COR-RECTNESS DEMONSTRATION must use T race k to check whether a new s i still knows how to solve an earlier task T k (k < i).A less strict variant of POWERPLAY, however, will simply make certain assumptions about the probabilistic nature of the environment and the repeatability of trials, assuming that a limited fixed number of interactions with the real world are sufficient to estimate the costs c * i , c i in Algorithm 7.1.Another probabilistic way of softening POWERPLAY is to add new tasks without proof that s won't forget solutions to previous tasks, provided CORRECTNESS DEMONSTRATION can at least show that the probability of forgetting any previous solution is below some real-valued positive constant threshold.

First Illustrative Experiments
First experiments are reported in separate papers [53,52] (some experiments were also briefly mentioned in the original report [46]).Standard NNs as well as SLIM RNNs [47] are used as computational problem solving architectures.The weights of SLIM RNNs can encode essentially arbitrary computable tasks as well as arbitrary, self-delimiting, halting or non-halting programs solving those tasks.These programs may affect both environment (through effectors) and internal states encoding abstractions of event sequences.In open-ended fashion, the POWERPLAY-driven NNs learn to become increasingly general solvers of selfinvented problems, continually adding new problem solving procedures to the growing repertoire, sometimes compressing/speeding up previous skills, sometimes preferring to invent new tasks and corresponding skills.The NNs exhibit interesting developmental stages.It is also shown how a POWERPLAY-driven SLIM NN automatically self-modularizes [52], frequently re-using code for previously invented skills, always trying to invent novel tasks that can be quickly validated because they do not require too many weight changes affecting too many previous tasks.

Previous Relevant Work
Here I discuss related research, in particular, why the present work is of interest despite the recent advent of theoretically optimal universal problem solvers (Section 9.1), and how it can be viewed as a greedy but feasible and sound implementation of the formal theory of creativity (Section 9.3).

Existing Theoretically Optimal Universal Problem Solvers
The new millennium brought universal problem solvers that are theoretically optimal in a certain sense.The fully self-referential [9] Gödel machine [43,44] may interact with some initially unknown, partially observable environment to maximize future expected utility or reward by solving arbitrary user-defined computational tasks.Its initial algorithm is not hardwired; it can completely rewrite itself without essential limits apart from the limits of computability, but only if a proof searcher embedded within the initial algorithm can first prove that the rewrite is useful, according to the formalized utility function taking into account the limited computational resources.Self-rewrites due to this approach can be shown to be globally optimal, relative to Gödel's well-known fundamental restrictions of provability [9].To make sure the Gödel machine is at least asymptotically optimal even before the first self-rewrite, one may initialize it by Hutter's non-self-referential but asymptotically fastest algorithm for all well-defined problems Hsearch [13], which uses a hardwired brute force proof searcher and ignores the costs of proof search.Assuming discrete input/output domains X/Y ⊂ B * , a formal problem specification f : X → Y (say, a functional description of how integers are decomposed into their prime factors), and a particular x ∈ X (say, an integer to be factorized), Hsearch orders all proofs of an appropriate axiomatic system by size to find programs q that for all z ∈ X provably compute f (z) within time bound t q (z).Simultaneously it spends most of its time on executing the q with the best currently proven time bound t q (x).Hsearch is as fast as the fastest algorithm that provably computes f (z) for all z ∈ X, save for a constant factor smaller than 1+ǫ (arbitrarily small real-valued ǫ > 0) and an f -specific but x-independent additive constant [13].Given some problem, the Gödel machine may decide to replace Hsearch by a faster method suffering less from large constant overhead, but even if it doesn't, its performance won't be less than asymptotically optimal.
Why doesn't everybody use such universal problem solvers for all computational real-world problems?Because most real-world problems are so small that the ominous constant slowdowns (potentially relevant at least before the first self-rewrite) may be large enough to prevent the universal methods from being feasible.
POWERPLAY, on the other hand, is designed to incrementally build a practical more and more general problem solver that can solve numerous tasks quickly, not in the asymptotic sense, but by exploiting to the max its given particular search algorithm and computational architecture, with all its space and time limitations, including those reflected by constants ignored by the asymptotic optimality notation.
As mentioned in Section 6, however, one must now analyze under which conditions POWERPLAY's self-generated tasks can accelerate the solution to externally generated tasks (compare previous experimental studies of this type [30,54,37,38]).

Connection to Traditional Active Learning
Traditional active learning methods [6] such as AdaBoost [8] have a totally different set-up and purpose: there the user provides a set of samples to be learned, then each new classifier in a series of classifiers focuses on samples badly classified by previous classifiers.Open-ended POWERPLAY, however, (1) considers arbitrary computational problems (not necessarily classification tasks); (2) can self-invent all computational tasks.There is no need for a pre-defined global set of tasks that each new solver tries to solve better, instead the task set continually grows based on which task is easy to invent and validate, given what is already known.

Greedy Implementation of Aspects of the Formal Theory of Creativity
The Formal Theory of Creativity [42,45] considers agents living in initially unknown environments.At any given time, such an agent uses a reinforcement learning (RL) method [15] to maximize not only expected future external reward for achieving certain goals, but also intrinsic reward for improving an internal model of the environmental responses to its actions, learning to better predict or compress the growing history of observations influenced by its behavior, thus achieving wow-effects, actively learning skills to influence the input stream such that it contains previously unknown but learnable algorithmic regularities.I have argued that the theory explains essential aspects of intelligence including selective attention, curiosity, creativity, science, art, music, humor, e.g., [42,45].Compare recent related work, e.g., [1,5,22,20].
Like POWERPLAY, such a creative agent produces a sequence of self-generated tasks and their solutions, each task still unsolvable before learning, yet becoming solvable after learning.The costs of learning as well as the learning progress are measured, and enter the reward function.Thus, in the absence of external reward for reaching user-defined goals, at any given time the agent is motivated to invent a series of additional tasks that maximize future expected learning progress.
For example, by restricting its input stream to self-generated pairs (I, O) ∈ I × O like in Section 3.1.1,and limiting it to predict only O, given I (instead of also trying to predict future (I, O) pairs from previous ones, which the general agent would do), there will be a motivation to actively generate a sequence of (I, O) pairs such that the O are first subjectively unpredictable from their I but then become predictable with little effort, given the limitations of whatever learning algorithm is used.
Here some cons and pros of POWERPLAY are listed in light of the above.Its drawbacks include: 1. Instead of maximizing future expected reward, POWERPLAY is greedy, always trying to find the simplest (easiest to find and validate) task to add to the repertoire, or the simplest way of improving the efficiency or compressibility of previous solutions, instead of looking further ahead, as a universal RL method [42,45] would do.That is, POWERPLAY may potentially sacrifice large long-term gains for small short-term gains: the discovery of many easily solvable tasks may at least temporarily prevent it from learning to solve hard tasks.
On general computational architectures such as RNNs (Section 4.1.2),however, POWERPLAY is expected to soon run out of easy tasks that are not yet solvable, due to the architecture's limited capacity and its unavoidable generalization effects (many never-tried tasks will become solvable by solutions to the few explicitly tested T i ).Compare Section 5.
2. The general creative agent above [42,45] is motivated to improve performance on the entire history of previous still unsolved tasks, while POWERPLAY may discard much of this history, keeping only a selective list of previously solved tasks.However, as the system is interacting with its environment, one could store the entire continually growing history, and make sure that T always allows for defining the task of better compressing the history so far.
3. POWERPLAY as in Section 2 has a binary criterion for adding knowledge (was the new task solvable without forgetting old solutions?),while the general agent [42,45] uses a more informative information-theoretic measure.The cost-based POWERPLAY framework (Alg.7.1) of Section 7, however, offers similar, more flexible options, rewarding compression or speedup of solutions to previously solved tasks.
On the other hand, drawbacks of previous implementations of formal creativity theory include: 1. Some previous approximative implementations [30,54] used traditional RL methods [15] with theoretically unlimited look-ahead, but those are not guaranteed to work well in partially observable and/or non-stationary environments where the reward function changes over time, and won't necessarily generate an optimal sequence of future tasks or experiments.
2. Theoretically optimal implementations [42,45] are currently still impractical, for reasons similar to those discussed in Section 9.1.
Hence POWERPLAY may be viewed as a greedy but feasible implementation of certain basic principles of creativity [42,45].POWERPLAY-based systems are continually motivated to invent new tasks solvable by formerly unknown procedures, or to compress or speed up problem solving procedures discovered earlier.Unlike previous implementations, POWERPLAY extracts from the lifelong experience history a sequence of clearly identified and separated tasks with explicitly recorded solutions.By design it cannot suffer from online learning problems affecting its solver's performance on previously solved problems.

Beyond Algorithmic Zero-Sum Games [37, 38] (1997-2002)
This guaranteed robustness against forgetting previous skills also represents a difference to the most closely related previous work [37,38].There, to address the computational costs of learning, and the costs of measuring learning progress, computationally powerful encoders and problem solvers [36, 38] (1997-2002) are implemented as two very general, co-evolving, symmetric, opposing modules called the right brain and the left brain.Both are able to construct self-modifying probabilistic programs written in a universal programming language.An internal storage for temporary computational results of the programs is viewed as part of the changing environment.Each module can suggest experiments in the form of probabilistic algorithms to be executed, and make predictions about their effects, betting intrinsic reward on their outcomes.The opposing module may accept such a bet in a zero-sum game by making a contrary prediction, or reject it.In case of acceptance, the winner is determined by executing the experiment and checking its outcome; the intrinsic reward eventually gets transferred from the surprised loser to the confirmed winner.Both modules try to maximize reward using a rather general RL algorithm (the so-called success-story algorithm SSA [48]) designed for complex stochastic policies (alternative RL algorithms could be plugged in as well).Thus both modules are motivated to discover novel algorithmic patterns/compressibility (= surprising wow-effects), where the subjective baseline for novelty is given by what the opponent already knows about the (external or internal) world's repetitive patterns.Since the execution of any computational or physical action costs something (as it will reduce the cumulative reward per time ratio), both modules are motivated to focus on those parts of the dynamic world that currently make surprises and learning progress easy, to minimize the costs of identifying promising experiments and executing them.The system learns a partly hierarchical structure of more and more complex skills or programs necessary to solve the growing sequence of self-generated tasks, reusing previously acquired simpler skills where this is beneficial.Experimental studies exhibit several sequential stages of emergent developmental sequences, with and without external reward [37,38].
However, the previous system [37,38] did not have a built-in guarantee that it cannot forget previously learned skills, while POWERPLAY as in Section 2 does (and the time and space complexity-based variant Alg.7.1 of Section 7 can forget only if this improves the average efficiency of previous solutions).
To analyze the novel framework's consequences in practical settings, experiments are currently being conducted with various problem solver architectures with different generalization properties.See separate papers [53,52] and Section 8.

Opposing Forces: Improving Generalization Through Compression, Breaking Generalization Through Novelty
Two opposing forces are at work in POWERPLAY.On the one hand, the system continually tries to improve previously learned skills, by speeding them up, and by compressing the used parameters of the problem solver, reducing its effective size.The compression drive tends to improve generalization performance, according to the principles of Occam's Razor and Minimum Description Length (MDL) and Minimum Message Length (MML) [50,16,57,58,51,26,18,14]. On the other hand, the system also continually tries to invent new tasks that break the generalization capabilities of the present solver.POWERPLAY's time-minimizing search for new tasks automatically manages the trade-off between these opposing forces.Sometimes it is easier (because fewer computational resources are required) to invent and solve a completely new, previously unsolvable problem.Sometimes it is easier to compress (or speed up) solutions to previously invented problems.

Relation to Gödel's Sequence of Increasingly Powerful Axiomatic Systems
In 1931, Kurt Gödel showed that for each sufficiently powerful (ω-) consistent axiomatic system there is a statement that must be true but cannot be proven from the axioms through an algorithmic theorem-proving procedure [9].This unprovable statement can then be added to the axioms, to obtain a more powerful formal theory in which new formerly unprovable theorems become provable, without affecting previously provable theorems.
In a sense, POWERPLAY is doing something similar.Assume the architecture of the solver is a universal computer [9,56].Its software s can be viewed as a theorem-proving procedure implementing certain enumerable axioms and computable inference rules.POWERPLAY continually tries to modify s such that the previously proven theorems remain provable within certain time bounds, and a new previously unprovable theorem becomes provable.

Words of Caution
The behavior of POWERPLAY is determined by the nature and the limitations of T , S, P, and its algorithm for searching P. If T includes all computable task descriptions, and both S and P allow for implementing arbitrary programs, and the search algorithm is a general method for search in program space (Section 4), then there are few limits to what POWERPLAY may do (besides the limits of computability [9]).
It may not be advisable to let a general variant of POWERPLAY loose in an uncontrolled situation, e.g., on a multi-computer network on the internet, possibly with access to control of physical devices, and the potential to acquire additional computational and physical resources (Section 3.1.2)through programs executed during POWERPLAY.Unlike, say, traditional virus programs, POWERPLAY-based systems will continually change in a way hard to predict, incessantly inventing and solving novel, self-generated tasks, only driven by a desire to increase their general problem-solving capacity, perhaps a bit like many humans seek to increase their power once their basic needs are satisfied.This type of artificial curiosity/creativity, however, may conflict with human intentions on occasion.On the other hand, unchecked curiosity may sometimes also be harmful or fatal to the learning system itself (Section 6)-curiosity can kill the cat.