1. the complete title of one (or more) paper(s) published in the open literature describing the work that the author claims describes a human-competitive result; Human-inspired Scaling in Learning Classifier Systems: Case Study on the n-bit Multiplexer Problem Set Proc. ACM Genetic and Evolutionary Computation Conference (GECCO) 2016 2. the name, complete physical mailing address, e-mail address, and phone number of EACH author of EACH paper(s); Isidro M. Alvarez Victoria University of Wellington New Zealand isidro.alvarez@ecs.vuw.ac.nz, (0064-463-5233) Will N. Browne Victoria University of Wellington New Zealand will.browne@ vuw.ac.nz, (0064-463-5233 x8489) Mengjie Zhang Victoria University of Wellington New Zealand mengjie.zhang@ ecs.vuw.ac.nz, (0064-463-5654) 3. the name of the corresponding author (i.e., the author to whom notices will be sent concerning the competition); Will N. Browne 4. the abstract of the paper(s); Learning classifier systems (LCSs) originated from artificial cognitive systems research, but migrated such that LCS became powerful classification techniques. Modern LCSs can be used to extract building blocks of knowledge in order to solve more difficult problems in the same or a related domain. The past work showed that the reuse of knowledge through the adoption of code fragments, GP-like sub-trees, into the XCS learning classifier system framework could provide advances in scaling. However, unless the pattern underlying the complete domain can be described by the LCS's representation of the problem, a limit of scaling will eventually be reached. This is due to LCSs' 'divide and conquer' approach utilizing rule-based solutions, which entails an increasing number of rules (subclauses) to describe a problem as it scales. Inspired by human problem-solving abilities, the novel work in this paper seeks to reuse learned knowledge and learned functionality to scale to complex problems by transferring them from simpler problems. Progress is demonstrated on the benchmark Multiplexer (Mux) domain, albeit the developed approach is applicable to other scalable domains. The fundamental axioms necessary for learning are proposed. The methods for transfer learning in LCSs are developed. Also, learning is recast as a decomposition into a series of sub-problems. Results show that from a conventional tabula rasa, with only a vague notion of what subordinate problems might be relevant, it is possible to learn a general solution to any n-bit Mux problem for the first time. This is verified by tests on the 264, 521 and 1034 bit Mux problems. 5. a list containing one or more of the eight letters (A, B, C, D, E, F, G, or H) that correspond to the criteria (see above) that the author claims that the work satisfies; (G) The result solves a problem of indisputable difficulty in its field. 6. a statement stating why the result satisfies the criteria that the contestant claims (see examples of statements of human-competitiveness as a guide to aid in constructing this part of the submission); This work does solve a very difficult problem in the 1034-bit Multiplexer problem, but it is how it implements evolutionary computation for the meta-problem of how to solve complex problems that is of most value. The multiplexer problem consists of Boolean states linked to a binary action where address bits determine the data bit to output. It is highly epistatic as the importance of data bits depends on whether they are addressed or not, which disrupts frequentist approaches. Hence, both the techniques of Learning Classifier Systems (LCS) and Genetic Programming commonly utilise this as a benchmark problem, e.g. the 6-bit and 11-bit multiplexer (Ffrancon and Schoenauer, Gecco 2015). A major reason for the adoption of this benchmark is that as the number of address bits increase, the sample space (and hence search space) also increases, testing the scalability of the technique. Previous state-of-the-art results were successfully learning the 135-bit problem, which has a sample space of 4.3x10^40 - the known fastest supercomputer operating from the estimated dawn of time could not enumerate completely this number of samples. The 1034-bit problem in this paper is 1.84x10^311 samples, which are more than a googol number of samples with corresponding search space size, so is indisputably difficult. Tabula-rasa learning by sampling a search space using trial and error learning (or even supervised learning) appears implausible in such domains. Thus the standard Evolutionary Computation-based methodologies for learning will not scale here. Hence the really difficult problem addressed in this paper is how to begin to learn in such complex problems. 7. a full citation of the paper (that is, author names; publication date; name of journal, conference, technical report, thesis, book, or book chapter; name of editors, if applicable, of the journal or edited book; publisher name; publisher city; page numbers, if applicable); Human-inspired Scaling in Learning Classifier Systems: Case Study on the n-bit Multiplexer Problem Set Isidro M. Alvarez, Will N. Browne, Mengjie Zhang To appear. 8. a statement either that "any prize money, if any, is to be divided equally among the co-authors" OR a specific percentage breakdown as to how the prize money, if any, is to be divided among the co-authors; Any prize money, if any, is to be divided equally among the co-authors. 9. a statement stating why the authors expect that their entry would be the "best," This is the first instance of any technique learning any scale above the 135-bit multiplexer problem, let alone the vast search space of 1034-bits. However, it 'cheats' as it uses a human to set a curriculum, but by this argument almost all human learning is cheating as human learning is also not tabula-rasa or without a curriculum. This paper is of interest as it reconsiders how evolutionary computation can 'solve' complex problems. The standard EC method for creating solutions is starting from blank knowledge, sample a domain and adjust solutions through feedback from the environment (normally reinforcement or supervised learning). An experimenter decides the environmental features and functions available for the system to learn representative patterns. Thus, one solution for the 6-bit multiplexer problem in disjunctive normal form is F6 = X0'X1'X2+X0'X1X3+X0X1'X4+X0X1X5. However, as the problem scales the solution needs to scale, which is not the method adopted by humans. They learn underlying patterns of knowledge and functionality that inherently scale. Humans learn in a layered-learning manner where past learnt knowledge and functionality are transferred to new problems in the same and related domains to build general solutions. In the layered-learning approach developed here the EC experimenter as before must set base knowledge and functionality (albeit this can be much simpler), and most importantly, set a curriculum by which the learning algorithm can progressively acquire relevant knowledge and relevant functionality connected to that knowledge. The introduced methods capture functionality by reusing populations of rules generated from past problems and fragments of knowledge that have assisted in previous solutions. The system does require a human to know the superset of likely functionality needed to solve a problem, e.g. that binary numbers (sums of 2^x), are useful in solving Boolean problems. It is noted that a conventional EC approach when sampling from {0, 1} could never learn that functions involving {2} were needed for a compact solution. Reusing learnt knowledge and functionality is not trivial as which knowledge connected by which functions form useful underlying patterns must be learnt. If the sample space is large, then the search space is larger so layering is vital and achieved in LCS for the first time here. Thus the general solution learnt for 6-bit problem is equally applicable to the 1034-bit problem, although 100% accuracy on 2 million test samples is not a conclusive test. Only by human analysis can it be determined that the solution evolved can solve any n-bit multiplexer problem. 10. An indication of the general type of genetic or evolutionary computation used, such as GA (genetic algorithms), GP (genetic programming), ES (evolution strategies), EP (evolutionary programming), LCS (learning classifier systems), GE (grammatical evolution), GEP (gene expression programming), DE (differential evolution), etc. LCS (learning classifier systems) Reference: [Robyn Ffrancon and Marc Schoenauer. Memetic Semantic Genetic Programming. GECCO '15 1023-1030. 2015]