Above are papers related to the following paper: [Paper_ID] Paper #592993. 	[Title] Context Preserving Crossover in Genetic Programming. [Abstract] This paper introduces two new crossover operators for Genetic Programming (GP). Contrary to the regular GP crossover, the operators presented attempt to preserve the context in which subtrees appeared in the parent trees. A simple coordinate scheme for nodes in an S-expression tree is proposed, and crossovers are only allowed between nodes with exactly or partially matching coordinates. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #579008. 	[Title] Genetic Programming and Redundancy [Abstract] The Genetic Programming optimization method (GP) elaborated by John Koza [ Koza, 1992 ] is a variant of Genetic Algorithms. The search space of the problem domain consists of computer programs represented as parse trees, and the crossover operator is realized by an exchange of subtrees. Empirical analyses show that large parts of those trees are never used or evaluated which means that these parts of the trees are irrelevant for the solution or redundant. This paper is concerned with the identification of the redundancy occuring in GP. It starts with a mathematical description of the behavior of GP and the conclusions drawn from that description among others explain the "size problem" which denotes the phenomenon that the average size of trees in the population grows with time. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #35. 	[Title] 4 Implementing Application Specific Routines  Genetic algorithms in search, optimization, and machine learning. Reading, MA: Addison-Wesley. [Abstract] To implement a specific application, you should only have to change the file app.c. Section 2 describes the routines in app.c in detail. If you use additional variables for your specific problem, the easiest method of making them available to other program units is to declare them in sga.h and external.h. However, take care that you do not redeclare existing variables. Two example applications files are included in the SGA-C distribution. The file app1.c performs the simple example problem included with the Pascal version; finding the maximum of x 10 , where x is an integer interpretation of a chromosome. A slightly more complex application is include in app2.c. This application illustrates two features that have been added to SGA-C. The first of these is the ithruj2int function, which converts bits i through j in a chromosome to an integer. The second new feature is the utility pointer that is associated with each population member. The example application interprets each chromosome as a set of concatenated integers in binary form. The lengths of these integer fields is determined by the user-specified value of field size, which is read in by the function app data(). The field size must be less than the smallest of the chromosome length and the length of an unsigned integer. An integer array for storing the interpreted form of each chromosome is dynamically allocated and assigned to the chromosome's utility pointer in app malloc(). The ithruj2int routine (see utility.c) is used to translate each chromosome into its associated vector. The fitness for each chromosome is simply the sum of the squares of these integers. This example application will function for any chromosome length. SGA-C is intended to be a simple program for first-time GA experimentation. It is not intended to be definitive in terms of its efficiency or the grace of its implementation. The authors are interested in the comments, criticisms, and bug reports from SGA-C users, so that the code can be refined for easier use in subsequent versions. Please email your comments to rob@galab2.mh.ua.edu, or write to TCGA: The authors gratefully acknowledge support provided by NASA under Grant NGT-50224 and support provided by the National Science Foundation under Grant CTS-8451610. We also thank Hillol Kargupta for donating his tournament selection implementation. Booker, L. B. (1982). Intelligent behavior as an adaptation to the task environment (Doctoral dissertation, Technical Report No. 243. Ann Arbor: University of Michigan, Logic of Computers Group). Dissertations Abstracts International, 43(2), 469B. (University Microfilms No. 8214966) Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #592996. 	[Title] Hierarchical Genetic Programming (HGP) extensions discover, modify, and exploit subroutines to accelerate the evolution of [Abstract] A fundamental problem in learning from observation and interaction with an environment is defining a good representation, that is a representation which captures the underlying structure and functionality of the domain. This chapter discusses an extension of the genetic programming (GP) paradigm based on the idea that subroutines obtained from blocks of good representations act as building blocks and may enable a faster evolution of even better representations. This GP extension algorithm is called adaptive representation through learning (ARL). It has built-in mechanisms for (1) creation of new subroutines through discovery and generalization of blocks of code; (2) deletion of subroutines. The set of evolved subroutines extracts common knowledge emerging during the evolutionary process and acquires the necessary structure for solving the problem. ARL was successfully tested on the problem of controlling an agent in a dynamic and non-deterministic environment. Results with the automatic discovery of subroutines show the potential to better scale up the GP technique to complex problems. While HGP approaches improve the efficiency and scalability of genetic programming (GP) for many applications [Koza, 1994b], several issues remain unresolved. The scalability of HGP techniques could be further improved by solving two such issues. One is the characterization of the value of subroutines. Current methods for HGP do not attempt to decide what is relevant, i.e. which blocks of code or subroutines may be worth giving special attention, but employ genetic operations on subroutines at random points. The other issue is the time-course of the generation of new subroutines. Current HGP techniques do not make informed choices to automatically decide when creation or modification of subroutines is advantageous or necessary. The Adaptive Representation through Learning (ARL) algorithm copes with both of these problems. The what issue is addressed by relying on local measures such as parent-offspring differential fitness and block activation in order to discover useful subroutines and by learning which subroutines are useful. The when issue is addressed by relying on global population measures such as population entropy in order to predict when search reaches local optima and escape them. ARL co-evolves a set of subroutines which extends the set of problem primitives. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #578669. 	[Title] Hybridized Crossover-Based Search Techniques for Program Discovery [Abstract] In this paper we address the problem of program discovery as defined by Genetic Programming [10]. We have two major results: First, by combining a hierarchical crossover operator with two traditional single point search algorithms: Simulated Annealing and Stochastic Iterated Hill Climbing, we have solved some problems with fewer fitness evaluations and a greater probability of a success than Genetic Programming. Second, we have managed to enhance Genetic Programming by hybridizing it with the simple scheme of hill climbing from a few individuals, at a fixed interval of generations. The new hill climbing component has two options for generating candidate solutions: mutation or crossover. When it uses crossover, mates are either randomly created, randomly drawn from the population at large, or drawn from a pool of fittest individuals. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #1128943. 	[Title] An Adverse Interaction between the Crossover Operator and a Restriction on Tree Depth of Crossover [Abstract] The Crossover operator is common to most implementations of Genetic Programming (GP). Another, usually unavoidable, factor is some form of restriction on the size of trees in the GP population. This paper concentrates on the interaction between the Crossover operator and a restriction on tree depth demonstrated by the MAX problem, which involves returning the largest possible value for given function and terminal sets. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #94639. 	[Title] Genetic Programming and Data Structures [Abstract]  Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #593105. 	[Title] 20 Data Structures and Genetic Programming  two techniques for reducing run time. [Abstract] In real world applications, software engineers recognise the use of memory must be organised via data structures and that software using the data must be independant of the data structures' implementation details. They achieve this by using abstract data structures, such as records, files and buffers. We demonstrate that genetic programming can automatically implement simple abstract data structures, considering in detail the task of evolving a list. We show general and reasonably efficient implementations can be automatically generated from simple primitives. A model for maintaining evolved code is demonstrated using the list problem. Much published work on genetic programming (GP) evolves functions without side-effects to learn patterns in test data. In contrast human written programs often make extensive and explicit use of memory. Indeed memory in some form is required for a programming system to be Turing Complete, i.e. for it to be possible to write any (computable) program in that system. However inclusion of memory can make the interactions between parts of programs much more complex and so make it harder to produce programs. Despite this it has been shown GP can automatically create programs which explicitly use memory [Teller 1994]. In both normal and genetic programming considerable benefits have been found in adopting a structured approach. For example [Koza 1994] shows the introduction of evolvable code modules (automatically defined functions, ADFs) can greatly help GP to reach a solution. We suggest that a corresponding structured approach to use of data will similarly have significant advantage to GP. Earlier work has demonstrated that genetic programming can automatically generate simple abstract data structures, namely stacks and queues [Langdon 1995a]. That is, GP can evolve programs that organise memory (accessed via simple read and write primitives) into data structures which can be used by external software without it needing to know how they are implemented. This chapter shows it is possible to evolve a list data structure from basic primitives. [Aho, Hopcroft and Ullman 1987] suggest three different ways to implement a list but these experiments show GP can evolve its own implementation. This requires all the list components to agree on one implementation as they co-evolve together. Section 20.3 describes the GP architecture, including use of Pareto multiple component fitness scoring (20.3.4) and measures aimed at speeding the GP search (20.3.5). The evolved solutions are described in Section 20.4. Section 20.5 presents a candidate model for maintaining evolved software. This is followed by a discussion of what we have learned (20.6) and conclusions that can be drawn (20.7). Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #1128978. 	[Title] The MAX Problem for Genetic Programming Highlighting an Adverse Interaction between the Crossover Operator and [Abstract] The Crossover operator is common to most implementations of Genetic Programming (GP). Another, usually unavoidable, factor is some form of restriction on the size of trees in the GP population. This paper concentrates on the interaction between the Crossover operator and a restriction on tree depth demonstrated by the MAX problem, which involves returning the largest possible value for given function and terminal sets. Some characteristics and inadequacies of Crossover in `normal' use are highlighted and discussed. Subtree discovery and movement takes place mostly near the leaf nodes, with nodes near the root left untouched. Diversity drops quickly to zero near the root node in the tree population. GP is then unable to create `fitter' trees via the crossover operator, leaving a Mutation operator as the only common, but ineffective, route to discovery of `fitter' trees. Please summarise all the given information.

Above are papers related to the following paper: [Paper_ID] Paper #22229. 	[Title] The Automatic Programming of Agents that Learn Mental Models and Create Simple Plans of Action [Abstract] An essential component of an intelligent agent is the ability to notice, encode, store, and utilize information about its environment. Traditional approaches to program induction have focused on evolving functional or reactive programs. This paper presents MAPMAKER, an approach to the automatic generation of agents that discover information about their environment, encode this information for later use, and create simple plans utilizing the stored mental models. In this approach, agents are multipart computer programs that communicate through a shared memory. Both the programs and the representation scheme are evolved using genetic programming. An illustrative problem of 'gold' collection is used to demonstrate the approach in which one part of a program makes a map of the world and stores it in memory, and the other part uses this map to find the gold The results indicate that the approach can evolve programs that store simple representations of their environments and use these representations to produce simple plans. 1. Introduction Please summarise all the given information.

Paper #592993 has the title `Context Preserving Crossover in Genetic Programming.  
` and the abstract `This paper introduces two new crossover operators for Genetic Programming (GP). Contrary to the regular GP crossover, the operators presented attempt to preserve the context in which subtrees appeared in the parent trees. A simple coordinate scheme for nodes in an S-expression tree is proposed, and crossovers are only allowed between nodes with exactly or partially matching coordinates. 
`.
Question: Which category should Paper #592993 be classified as ?
You can select one from ['Neural_Networks', 'Case_Based', 'Theory', 'Reinforcement_Learning', 'Probabilistic_Methods', 'Rule_Learning', 'Genetic_Algorithms'].


Paper #592993 has the title `Context Preserving Crossover in Genetic Programming.  
` and the abstract `This paper introduces two new crossover operators for Genetic Programming (GP). Contrary to the regular GP crossover, the operators presented attempt to preserve the context in which subtrees appeared in the parent trees. A simple coordinate scheme for nodes in an S-expression tree is proposed, and crossovers are only allowed between nodes with exactly or partially matching coordinates. 
`.
Question: Which category should Paper #592993 be classified as ?
You can select one from ['Neural_Networks', 'Case_Based', 'Theory', 'Reinforcement_Learning', 'Probabilistic_Methods', 'Rule_Learning', 'Genetic_Algorithms'].

This paper should be classified into: Genetic_Algorithms