1 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 architecturespecific slowdowns ignored in the asymptotic optimality notation of theoretical computer science, and be generally useful for realworld 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. Easytolearn new tasks are preferred over unsolvable or hardtolearn tasks. Eventually the numerous skills acquired in this creative, selfsupervised way may get reused 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 tasksolving 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) reuse 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 selfmade training set due to generalization properties of their architectures. The framework is called PowerPlay 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.
1.1 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 easytofind 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 timevarying 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, nevertested tasks (in the field of Machine Learning, this is known as
generalization). PowerPlay’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 selfinvented 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 retesting 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 byproducts of its builtin 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 reuse their playfully acquired skills to solve teachergiven problems.
1.2 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 Demonstration. 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 selfgenerated 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 reused 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.
2 Notation & Algorithmic Framework PowerPlay (Variant I)
denotes the set of finite sequences or bitstrings over the binary alphabet , the empty string, strings in , the natural numbers, the real numbers, a positive constant, nonnegative integers, the number of bits in (where ), functions mapping integers to integers. We write if there exist positive such that for all .
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 . A userdefined subset 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 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 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
with things they encode, such as integers, realvalued vectors, weight matrices, or programs—the context will always make clear what is meant.
The problem solver’s initial program is called . There is a set of possible task descriptions . 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 , where each unique is chosen or “invented” by a search method described below such that the solutions of can be computed by , the th instance of the program, but not by . Each consists of a unique problem identifier that can be read bythrough some builtin 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 ; .A valid task may require solving at least one previously solved task more efficiently, by using less resources such as storage space, computation time, energy, etc., thus achieving a woweffect. See Section 3.1.
Tasks and problem solver modifications are computed and validated by elements of another appropriate set of programs . Programs may contain instructions for reading and executing (parts of) the code of the present problem solver and reading (parts of) a recorded history of previous events that led to the present solver. The algorithmic framework (Alg. 2) incrementally trains the problem solver by finding that increase the set of solvable tasks.
3 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.
3.1 Implementing Task Invention
Part of the job of is to compute . This will consume some of the total computation time allocated to . Two examples will be given: pattern recognition tasks are treated in Section 3.1.1; sequential decision making tasks in Section 3.1.2.
3.1.1 Example: Pattern Recognition Tasks
In the context of learning to recognize or analyze patterns, could be a 4tuple , where , and is solved if satisfies and needs at most discrete time steps to read and compute and halt. Here itself may be a pair , where is constrained to be the address of an image in a given database of patterns, and is a generated “query” that uniquely specifies how
the image should be classified through target pattern
, 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 if (suppressing task indices) and the image addressed by contains at least one black pixel, or if and the image shows a cow.Since the definition of task includes bounds on computational resources, may be about solving at least one more efficiently, corresponding to a woweffect. This in turn may also yield more efficient solutions to other tasks . In practical applications one may insist that such efficiency gains must exceed a certain threshold , to avoid task series causing sequences of very minor improvements.
Note that and 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 , in the beginning, trivial tasks such as simply copying onto 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.
3.1.2 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 of possible task identification patterns and a set of programs that test properties of bitstrings. could then encode a 4tuple of finite bitstrings with the following interpretation: must satisfy and may spend at most discrete time steps on first reading and then interacting with an environment through a sequence of perceptions and actions, to achieve some computable goal defined by .More precisely, while is being solved within time steps, at any given time , the internal state of the problem solver at time is denoted ; its initial default value is . For example, 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 , can spend a constant number of elementary computational instructions to copy the task dscription or the present environmental input and a reward signal (interpreted as a real number) into parts of , then update other parts of (a function of ) and compute action encoded as a part of . may affect the environment, and thus future inputs.
If 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 4tuples gets recorded by the socalled trace . If at the end of the interaction a desirable computable property (computed by applying program to ) is satisfied, then by definition the task is solved. The set of possible may represent an infinite set of all computable tasks with solutions computable by the given hardware. For practical reasons, however, the set of possible may also be restricted to bit sequences encoding just a few possible goals. For example, may only encode goals of the form: a robot arm steered by program or “policy” has reached a certain target (a desired final observation recorded in ) without measurably bumping into an obstacle along the way, that is, there were no negative rewards, that is, for .
If the environment is deterministic, e.g., a digital physics simulation of a robot, then its current state can be encoded as part of , and it is straightforward for Correctness Demonstration to test whether some still can solve a previously solved task . However, what if the environment is only partially observable, like the real world, and nonstationary, changing in unknown ways? Then Correctness Demonstration must check whether still produces the same action sequence in response to the input sequence recorded in (often this replaybased 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 might actually achieve faster than , given the description of , but Correctness Demonstration in general cannot know whether this acceleration was due to plain luck—it must stick to reproducing to make sure it did not forget anything.)
See Section 7.2, however, for a less strict PowerPlay variant whose Correctness Demonstration directly interacts with the real world to collect sufficient problemsolving statistics through repeated trials, making certain assumptions about the probabilistic nature of the environment, and the repeatability of experiments.
3.2 Implementing Solver Modification
Part of the job of is also to compute , possibly profiting from having access to , because only few changes of may be necessary to come up with an that goes beyond . For example, if the problem solver is a standard PC, then just a few bits of the previous software may need to be changed.
For practical reasons, the set of possible 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 should be greatly restricted such that any can only produce syntactically correct .
If the problem solver is a feedforward NN with prewired, unmodifiable topology, then will be restricted to those bit sequences encoding valid weight matrices, will encode its th weight matrix, and will be restricted to those that can produce some . Depending on the userdefined programming language, may invoke complex prewired subprograms (e.g., wellknown learning algorithms) as primitive instructions—compare separate experimental analysis [53, 52].
In general, itself determines how much time to spend on Solver Modification—enough time must be left for Task Invention and Correctness Demonstration.
3.3 Implementing Correctness Demonstration
Correctness demonstration may be the most timeconsuming obligation of . At first glance it may seem that as the sequence is growing, more and more time will be needed to show that but not can solve , because one naive way of ensuring correctness is to retest on all previously solved tasks. Theoretically more efficient ways are considered next.
3.3.1 Most General: Proof Search
The most general way of demonstrating correctness is to encode (in readonly storage) an axiomatic system that formally describes computational properties of the problem solver and possible , and to allow to search the space of possible proofs derivable from , using a proof searcher subroutine that systematically generates proofs until it finds a theorem stating that but not solves (proof search may achieve this efficiently without explicitly retesting on ). 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: proofgenerating programs that may invoke special instructions for generating axioms and applying inference rules to prolong an initially empty proof by theorems, which are either axioms or inferred from previous theorems through rules such as modus ponens combined with unification, e.g., [7]. can be easily limited to programs generating only syntactically correct proofs [44]. has to subsume axioms describing how any instruction invoked by some will change the state of the problem solver from one step to the next (such that proof techniques can reason about the effects of any ). Other axioms encode knowledge about arithmetics etc (such that proof techniques can reason about spatial and temporal resources consumed by ).
In what follows, Correctness Demonstrations will be discussed that are less general but sometimes more convenient to implement.
3.3.2 Keeping Track Which Components of the Solver Affect Which Tasks
Often it is possible to partition into components, such as individual bits of the software of a PC, or weights of a NN. Here the th component of is denoted . For each a variable list is introduced. Its initial value before the start of PowerPlay is , an empty list. Whenever found and at the end of Correctness Demonstration, each is updated as follows: Its new value is obtained by appending to those whose current (possibly revised) solutions now need at least once during the solutioncomputing process, and deleting those whose current solutions do not use any more.
PowerPlay’s Correctness Demonstration thus has to test only tasks in the union of all . That is, if the most recent task does not require changes of many components of , 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 that generate 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 byproducts. Compare a recent experimental analysis of this effect [53, 52].
3.3.3 Advantages of Prefix CodeBased Problem Solvers
Let us restrict such that tested cannot change any components of during Solver Modification, but can create a new only by adding new components to . (This means freezing all used components of any once is found.) By restricting to selfdelimiting 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 and cannot affect solutions to under certain conditions. More precisely, to obtain , half the search time is spent on trying to process first by , extending or prolonging only when the ongoing computation requests to add new components through special instructions [41]—then Correctness Demonstration has less to do as the set is guaranteed to remain solvable, by induction. The other half of the time is spent on processing by a new subprogram with new components , a part of but not of , where may read or invoke parts of as subprograms to solve — only then Correctness Demonstration has to test not only on but also on (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 such that they must define as the unique task identifier for (see Section 3.1.2); restrict all such that the input of automatically invokes subprogram , a part of but not of (although may read or invoke parts of as subprograms to solve ). Restrict to a subset of acceptable computational outcomes (Section 3.1.2). Run until it halts and has computed a novel output acceptable by that is different from all outputs computed by the (halting) solutions to ; this novel output becomes ’s goal. By induction over , since all previously used components of remain unmodified, the set is guaranteed to remain solvable, no matter . 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 will always first invoke some different from all , instead of allowing for solving a new task solely by previously found code.
4 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.
4.1 Implementation Based on Optimal Ordered Problem Solver OOPS
The th problem is to find a program that creates and and demonstrates that but not can solve . 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 is executed, at any given discrete time step , its internal state or dynamical storage at time is denoted (not to be confused with the solver’s internal state of Section 3.1.2). Its initial default value is . E.g., could encode the current contents of the internal tape of a TM (to be modified by ), or of certain cells in the dynamic storage area of a PC.
Once is found, (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 , since may contain instructions for addressing and reading and for copying the read code into modifiable storage , where may further edit the code, and execute the result, which may be a useful subprogram [41].
Define a probability distribution
on to represent the searcher’s initial bias (more likely programs will be tested earlier [17]). could be based on program length, e.g., , 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 requires steps to solve a problem instance of size and demonstrate the correctness of the result, then this search method will need at most steps—the constant factor may be large but does not depend on . Since OOPS may reuse previously generated solutions and solutioncomputing 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.
4.1.1 Building on Existing OOPS Source Code
Existing OOPS source code [40] uses a FORTHlike universal programming language to define . It already contains a framework for testing new code on previously solved tasks, and for efficiently undoing all modifications of each tested program. The source code will require a few changes to implement the additional task search described above.
4.1.2 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 FORTHlike 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 , where is the realvalued weight on the directed connection between the th and th neuron. To program RNN1 means to set the weight matrix
. Given enough neurons with appropriate activation functions and an appropriate
, Algorithm 4.1 can be used to train . 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 networkmodifying networks as described in previous work [33, 35, 34].In first experiments [53, 52], a particularly suited NN called a selfdelimiting 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 prewired regularizers and hyperparameters [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 taskspecific total length of connections used by SLIM NNs implemented on the 3dimensional brainlike multiprocessor hardware to expected in the future. This encourages SLIM NNs to solve many subtasks by subsets of neurons that are physically close [47].
4.2 Adapting the Probability Distribution on Programs
A straightforward extension of the above works as follows: Whenever a new is found, is updated to make either only or all 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.
4.3 Implementation Based on Stochastic or Evolutionary Search
A possibly simpler but less general approach is to use an evolutionary algorithm to produce an
modifying and taskgenerating program as requested by PowerPlay, according to Algorithm 4.3, which refers to the recurrent net problem solver of Section 4.1.2.5 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 is reached, PowerPlay will start “compressing” previous solutions, making generalize in the sense that the same relatively short piece of code (some part of ) 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 . 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.
6 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 , is defined externally, instead of being invented by the system itself. In general, the resulting will contain an externally inserted bias in form of code that will make some future selfgenerated tasks easier to find than others. It should be possible to push the system in a humanunderstandable 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 for some and use it as a starting point for a search for a solution to an externally posed task , without insisting that the modified also can solve . This may be much faster than trying to solve from scratch, to the extent the solutions to selfgenerated tasks reflect general knowledge (code) reusable for .
In general, however, it will be possible to design external tasks whose solutions do not profit from those of selfgenerated 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 selfgenerated 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.
6.1 SelfReference Through Novel Task Search as an External Task
PowerPlay’s th goal is to find a that creates and (a modification of ) and shows that but not can solve . As itself is becoming a more and more general problem solver, may help in many ways to achieve such goals in selfreferential fashion. For example, the old solver may be able to read a unique formal description (provided by ) of PowerPlay’s th goal, viewing it as an external task, and produce an output unambiguously describing a candidate for (). If has a theorem prover component (Section 3.3.1), might even output a full proof of ()’s validity; alternatively could just use the possibly suboptimal suggestions of to narrow down and speed up the search, one of the reasons why Section 2 already mentioned that programs should contain instructions for reading (and running) the code of the present problem solver.
7 Softening Task Acceptance Criteria of PowerPlay
The PowerPlay variants above insist that 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 decisionmaking tasks from Section 3.1.2. Suppose the problem solver can already solve task . A very similar but admissible new task would be to solve substantially faster: , as long as is not already solvable by , and no solution to some 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 nonexternal (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 nonexternal 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.
7.1 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, encodes a tuple with interpretation: must first read and then interact with an environment through a sequence of perceptions and actions, to achieve some computable goal defined by within a certain maximal time interval (a positive constant). Let be if cannot solve task , otherwise it is the time needed to solve by . Let be the positive constant if cannot solve , otherwise it is the number of components of needed to solve task by . The nonnegative realvalued reward for solving is a positive constant for selfdefined previously unsolvable , or userdefined if is an external task solved by (Section 6). The realvalued cost of solving all tasks in a task set through is a realvalued function of: all , (for all ), , and . For example, the cost function encourages compact and fast solvers solving many different tasks with the same components of , where the realvalued positive parameter weighs space costs against time costs, and should exceed to encourage solutions of novel selfgenerated 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 . As always, if the environment is unknown and possibly changing over time, to test performance of a new solver on a previous task , only is necessary—see Section 3.1.2. As always, let denote the set containing all tasks (note that if = for some then it will appear only once in ), and let again define what’s acceptable progress:
By Algorithm 7.1, may forget certain abilities of , provided that the overall performance as measured by 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 are used for solving which tasks (Section 3.3.2).
To further refine this approach, consider that in phase , the list (defined in Section 3.3.2) contains all previously learned tasks whose solutions depend on . This can be used to determine the current value of some component of : . It is a simple exercise to invent PowerPlay variants that do not forget valuable components as easily as less valuable ones.
7.2 Probabilistic PowerPlay Variants
Section 3.1.2 pointed out that in partially observable and/or nonstationary unknown environments Correctness Demonstration must use to check whether a new still knows how to solve an earlier task . 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
in Algorithm 7.1.Another probabilistic way of softening PowerPlay is to add new tasks without proof that 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 realvalued positive constant threshold.
8 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, selfdelimiting, halting or nonhalting programs solving those tasks. These programs may affect both environment (through effectors) and internal states encoding abstractions of event sequences. In openended fashion, the PowerPlaydriven 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 PowerPlaydriven SLIM NN automatically selfmodularizes [52], frequently reusing 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.
9 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).
9.1 Existing Theoretically Optimal Universal Problem Solvers
The new millennium brought universal problem solvers that are theoretically optimal in a certain sense. The fully selfreferential [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 userdefined 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. Selfrewrites due to this approach can be shown to be globally optimal, relative to Gödel’s wellknown fundamental restrictions of provability [9]. To make sure the Gödel machine is at least asymptotically optimal even before the first selfrewrite, one may initialize it by Hutter’s nonselfreferential but asymptotically fastest algorithm for all welldefined problems Hsearch [13], which uses a hardwired brute force proof searcher and ignores the costs of proof search. Assuming discrete input/output domains , a formal problem specification (say, a functional description of how integers are decomposed into their prime factors), and a particular (say, an integer to be factorized), Hsearch orders all proofs of an appropriate axiomatic system by size to find programs that for all provably compute within time bound . Simultaneously it spends most of its time on executing the with the best currently proven time bound . Hsearch is as fast as the fastest algorithm that provably computes for all , save for a constant factor smaller than (arbitrarily small realvalued ) and an specific but 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 realworld problems? Because most realworld problems are so small that the ominous constant slowdowns (potentially relevant at least before the first selfrewrite) 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.
9.2 Connection to Traditional Active Learning
Traditional active learning methods
[6] such as AdaBoost [8] have a totally different setup 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. Openended PowerPlay, however, (1) considers arbitrary computational problems (not necessarily classification tasks); (2) can selfinvent all computational tasks. There is no need for a predefined 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.9.3 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 woweffects, 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 selfgenerated 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 userdefined 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 selfgenerated pairs like in Section 3.1.1, and limiting it to predict only , given (instead of also trying to predict future pairs from previous ones, which the general agent would do), there will be a motivation to actively generate a sequence of pairs such that the are first subjectively unpredictable from their 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:

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 longterm gains for small shortterm 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 nevertried tasks will become solvable by solutions to the few explicitly tested ). Compare Section 5.

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 always allows for defining the task of better compressing the history so far.

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 informationtheoretic measure. The costbased 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:

Some previous approximative implementations [30, 54] used traditional RL methods [15] with theoretically unlimited lookahead, but those are not guaranteed to work well in partially observable and/or nonstationary environments where the reward function changes over time, and won’t necessarily generate an optimal sequence of future tasks or experiments.
Hence PowerPlay may be viewed as a greedy but feasible implementation of certain basic principles of creativity [42, 45]. PowerPlaybased 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.
9.4 Beyond Algorithmic ZeroSum Games [37, 38] (19972002)
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] (19972002) are implemented as two very general, coevolving, symmetric, opposing modules called the right brain and the left brain. Both are able to construct selfmodifying 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 zerosum 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 socalled successstory 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 woweffects), 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 selfgenerated 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 builtin guarantee that it cannot forget previously learned skills, while PowerPlay as in Section 2 does (and the time and space complexitybased variant Alg. 7.1 of Section 7 can forget only if this improves the average efficiency of previous solutions).
9.5 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 timeminimizing search for new tasks automatically manages the tradeoff 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.
9.6 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 theoremproving 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 can be viewed as a theoremproving procedure implementing certain enumerable axioms and computable inference rules. PowerPlay continually tries to modify such that the previously proven theorems remain provable within certain time bounds, and a new previously unprovable theorem becomes provable.
10 Words of Caution
The behavior of PowerPlay is determined by the nature and the limitations of , , , and its algorithm for searching . If includes all computable task descriptions, and both and 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 multicomputer 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, PowerPlaybased systems will continually change in a way hard to predict, incessantly inventing and solving novel, selfgenerated tasks, only driven by a desire to increase their general problemsolving 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.
11 Acknowledgments
Thanks to Mark Ring, Bas Steunebrink, Faustino Gomez, Sohrob Kazerounian, Hung Ngo, Leo Pape, Giuseppe Cuccu, for useful comments.
References
 [1] A. Barto. Intrinsic motivation and reinforcement learning. In G. Baldassarre and M. Mirolli, editors, Intrinsically Motivated Learning in Natural and Artificial Systems. Springer, 2012. In press.
 [2] D. E. Berlyne. A theory of human curiosity. British Journal of Psychology, 45:180–191, 1954.
 [3] C. M. Bishop. Pattern Recognition and Machine Learning. Springer, 2006.
 [4] G. Cuccu, M. Luciw, J. Schmidhuber, and F. Gomez. Intrinsically motivated evolutionary search for visionbased reinforcement learning. In Proceedings of the 2011 IEEE Conference on Development and Learning and Epigenetic Robotics IEEEICDLEPIROB. IEEE, 2011.
 [5] P. Dayan. Exploration from generalization mediated by multiple controllers. In G. Baldassarre and M. Mirolli, editors, Intrinsically Motivated Learning in Natural and Artificial Systems. Springer, 2012. In press.
 [6] V. V. Fedorov. Theory of optimal experiments. Academic Press, 1972.
 [7] M. C. Fitting. FirstOrder Logic and Automated Theorem Proving. Graduate Texts in Computer Science. SpringerVerlag, Berlin, 2nd edition, 1996.
 [8] Y. Freund and R. E. Schapire. A decisiontheoretic generalization of online learning and an application to boosting. Journal of Computer and System Sciences, 55(1):119–139, 1997.
 [9] K. Gödel. Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I. Monatshefte für Mathematik und Physik, 38:173–198, 1931.
 [10] F. J. Gomez, J. Schmidhuber, and R. Miikkulainen. Efficient nonlinear control through neuroevolution. Journal of Machine Learning Research JMLR, 9:937–965, 2008.
 [11] H. F. Harlow, M. K. Harlow, and D. R. Meyer. Novelty and curiosity as determinants of exploratory behavior. Journal of Experimental Psychology, 41:68–80, 1950.
 [12] S. Hochreiter and J. Schmidhuber. Long shortterm memory. Neural Computation, 9(8):1735–1780, 1997.
 [13] M. Hutter. The fastest and shortest algorithm for all welldefined problems. International Journal of Foundations of Computer Science, 13(3):431–443, 2002. (On J. Schmidhuber’s SNF grant 2061847).

[14]
M. Hutter.
Universal Artificial Intelligence: Sequential Decisions based on Algorithmic Probability
. Springer, Berlin, 2005. (On J. Schmidhuber’s SNF grant 2061847).  [15] L. P. Kaelbling, M. L. Littman, and A. W. Moore. Reinforcement learning: a survey. Journal of AI research, 4:237–285, 1996.
 [16] A. N. Kolmogorov. Three approaches to the quantitative definition of information. Problems of Information Transmission, 1:1–11, 1965.
 [17] L. A. Levin. Universal sequential search problems. Problems of Information Transmission, 9(3):265–266, 1973.
 [18] M. Li and P. M. B. Vitányi. An Introduction to Kolmogorov Complexity and its Applications (2nd edition). Springer, 1997.
 [19] M. Luciw, V. Graziano, M. Ring, and J. Schmidhuber. Artificial curiosity with planning for autonomous perceptual and cognitive development. In Proceedings of the First Joint Conference on Development Learning and on Epigenetic Robotics ICDLEPIROB, Frankfurt, August 2011.
 [20] U. Nehmzow, Y. Gatsoulis, E. Kerr, J. Condell, N. H. Siddique, and T. M. McGinnity. Novelty detection as an intrinsic motivation for cumulative learning robots. In G. Baldassarre and M. Mirolli, editors, Intrinsically Motivated Learning in Natural and Artificial Systems. Springer, 2012. In press.
 [21] A. Newell and H. Simon. GPS, a program that simulates human thought. In E. Feigenbaum and J. Feldman, editors, Computers and Thought, pages 279–293. McGrawHill, New York, 1963.
 [22] P.Y. Oudeyer, A. Baranes, and F. Kaplan. Intrinsically motivated learning of real world sensorimotor skills with developmental constraints. In G. Baldassarre and M. Mirolli, editors, Intrinsically Motivated Learning in Natural and Artificial Systems. Springer, 2012. In press.
 [23] J. Piaget. The Child’s Construction of Reality. London: Routledge and Kegan Paul, 1955.
 [24] I. Rechenberg. Evolutionsstrategie  Optimierung technischer Systeme nach Prinzipien der biologischen Evolution. Dissertation, 1971. Published 1973 by FrommanHolzboog.
 [25] M. B. Ring. Continual Learning in Reinforcement Environments. PhD thesis, University of Texas at Austin, Austin, Texas 78712, August 1994.
 [26] J. Rissanen. Modeling by shortest data description. Automatica, 14:465–471, 1978.
 [27] A. J. Robinson and F. Fallside. The utility driven dynamic error propagation network. Technical Report CUED/FINFENG/TR.1, Cambridge University Engineering Department, 1987.
 [28] T. Schaul, Yi Sun, D. Wierstra, F. Gomez, and J. Schmidhuber. CuriosityDriven Optimization. In IEEE Congress on Evolutionary Computation (CEC), New Orleans, USA, 2011.
 [29] J. Schmidhuber. Dynamische neuronale Netze und das fundamentale raumzeitliche Lernproblem. Dissertation, Institut für Informatik, Technische Universität München, 1990.
 [30] J. Schmidhuber. Curious modelbuilding control systems. In Proceedings of the International Joint Conference on Neural Networks, Singapore, volume 2, pages 1458–1463. IEEE press, 1991.
 [31] J. Schmidhuber. A possibility for implementing curiosity and boredom in modelbuilding neural controllers. In J. A. Meyer and S. W. Wilson, editors, Proc. of the International Conference on Simulation of Adaptive Behavior: From Animals to Animats, pages 222–227. MIT Press/Bradford Books, 1991.
 [32] J. Schmidhuber. A fixed size storage time complexity learning algorithm for fully recurrent continually running networks. Neural Computation, 4(2):243–248, 1992.
 [33] J. Schmidhuber. Learning to control fastweight memories: An alternative to recurrent nets. Neural Computation, 4(1):131–139, 1992.
 [34] J. Schmidhuber. On decreasing the ratio between learning complexity and number of timevarying variables in fully recurrent nets. In Proceedings of the International Conference on Artificial Neural Networks, Amsterdam, pages 460–463. Springer, 1993.
 [35] J. Schmidhuber. A selfreferential weight matrix. In Proceedings of the International Conference on Artificial Neural Networks, Amsterdam, pages 446–451. Springer, 1993.
 [36] J. Schmidhuber. What’s interesting? Technical Report IDSIA3597, IDSIA, 1997. ftp://ftp.idsia.ch/pub/juergen/interest.ps.gz; extended abstract in Proc. Snowbird’98, Utah, 1998; see also [38].
 [37] J. Schmidhuber. Artificial curiosity based on discovering novel algorithmic predictability through coevolution. In P. Angeline, Z. Michalewicz, M. Schoenauer, X. Yao, and Z. Zalzala, editors, Congress on Evolutionary Computation, pages 1612–1618. IEEE Press, 1999.
 [38] J. Schmidhuber. Exploring the predictable. In A. Ghosh and S. Tsuitsui, editors, Advances in Evolutionary Computing, pages 579–612. Springer, 2002.
 [39] J. Schmidhuber. Biasoptimal incremental problem solving. In S. Becker, S. Thrun, and K. Obermayer, editors, Advances in Neural Information Processing Systems 15 (NIPS 15), pages 1571–1578, Cambridge, MA, 2003. MIT Press.
 [40] J. Schmidhuber. OOPS source code in crystalline format: http://www.idsia.ch/~juergen/oopscode.c, 2004.
 [41] J. Schmidhuber. Optimal ordered problem solver. Machine Learning, 54:211–254, 2004.
 [42] J. Schmidhuber. Developmental robotics, optimal artificial curiosity, creativity, music, and the fine arts. Connection Science, 18(2):173–187, 2006.
 [43] J. Schmidhuber. Gödel machines: Fully selfreferential optimal universal selfimprovers. In B. Goertzel and C. Pennachin, editors, Artificial General Intelligence, pages 199–226. Springer Verlag, 2006. Variant available as arXiv:cs.LO/0309048.
 [44] J. Schmidhuber. Ultimate cognition à la Gödel. Cognitive Computation, 1(2):177–193, 2009.
 [45] J. Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (19902010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010.
 [46] J. Schmidhuber. PowerPlay: Training an Increasingly General Problem Solver by Continually Searching for the Simplest Still Unsolvable Problem. Technical Report arXiv:1112.5309v1 [cs.AI], 2011.
 [47] J. Schmidhuber. Selfdelimiting neural networks. Technical Report IDSIA0812, arXiv:1210.0118v1 [cs.NE], IDSIA, 2012.
 [48] J. Schmidhuber, J. Zhao, and M. Wiering. Shifting inductive bias with successstory algorithm, adaptive Levin search, and incremental selfimprovement. Machine Learning, 28:105–130, 1997.
 [49] F. Sehnke, C. Osendorfer, T. Rückstieß, A. Graves, J. Peters, and J. Schmidhuber. Parameterexploring policy gradients. Neural Networks, 23(4):551–559, 2010.
 [50] R. J. Solomonoff. A formal theory of inductive inference. Part I. Information and Control, 7:1–22, 1964.
 [51] R. J. Solomonoff. Complexitybased induction systems. IEEE Transactions on Information Theory, IT24(5):422–432, 1978.
 [52] R. K. Srivastava, B. R. Steunebrink, and J. Schmidhuber. First Experiments with PowerPlay. Technical Report arXiv:1210.8385v1 [cs.AI], 2012.
 [53] R. K. Srivastava, B. R. Steunebrink, M. Stollenga, and J. Schmidhuber. Continually adding selfinvented problems to the repertoire: First experiments with powerplay. In Proceedings of the 2012 IEEE Conference on Development and Learning and Epigenetic Robotics IEEEICDLEPIROB. IEEE, 2012.
 [54] J. Storck, S. Hochreiter, and J. Schmidhuber. Reinforcement driven information acquisition in nondeterministic environments. In Proceedings of the International Conference on Artificial Neural Networks, Paris, volume 2, pages 159–164. EC2 & Cie, 1995.
 [55] R. S. Sutton and A. G. Barto. Reinforcement Learning: An Introduction. MIT Press, Cambridge, MA, 1998.
 [56] A. M. Turing. On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, Series 2, 41:230–267, 1936.
 [57] C. S. Wallace and D. M. Boulton. An information theoretic measure for classification. Computer Journal, 11(2):185–194, 1968.
 [58] C. S. Wallace and P. R. Freeman. Estimation and inference by compact coding. Journal of the Royal Statistical Society, Series ”B”, 49(3):240–265, 1987.

[59]
P. J. Werbos.
Generalization of backpropagation with application to a recurrent gas market model.
Neural Networks, 1, 1988.  [60] D. Wierstra, T. Schaul, J. Peters, and J. Schmidhuber. Natural evolution strategies. In Congress of Evolutionary Computation (CEC 2008), 2008.
 [61] R. J. Williams and D. Zipser. Gradientbased learning algorithms for recurrent networks and their computational complexity. In Backpropagation: Theory, Architectures and Applications. Hillsdale, NJ: Erlbaum, 1994.
 [62] S. Yi, F. Gomez, and J. Schmidhuber. Planning to be surprised: Optimal Bayesian exploration in dynamic environments. In Proc. Fourth Conference on Artificial General Intelligence (AGI), Google, Mountain View, CA, 2011.
Comments
There are no comments yet.