Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A non-transitory computer readable medium storing instructions which, when executed by one or more computing devices, cause the one or more computing devices to perform a process of: determining a first label associated with functionality of first candidate code; determining a second label associated with functionality of second candidate code; determining whether the first candidate code and the second candidate code are compatible for evolution based at least in part on the first label and the second label; when the first candidate code and the second candidate code are determined to be compatible for evolution based at least in part on the first label and the second label, evolving third candidate code, using evolutionary programming techniques, based on the first candidate code and second candidate code, wherein the third candidate code differs from both the first candidate code and second candidate code, and contains no more than a subset of code from each of the first candidate code and the second candidate code; performing a fitness test based at least in part on the third candidate code; determining whether exit criteria are met based at least in part on the fitness test; and when the exit criteria are met, providing the third candidate code as evolved code and causing execution of the evolved code, wherein: the first candidate code comprises a first set of one or more actions; the second candidate code comprises a second set of one or more actions; wherein evolving the third candidate code based on the first candidate code and second candidate code comprises: when a first action in the first set of one or more actions is different from a corresponding second action in the second set of one or more actions, evolving a third, evolved action from the first action and the second action; and including in the third candidate code the third, evolved action.
This invention relates to automated software evolution using evolutionary programming techniques. The problem addressed is the challenge of combining different code segments to generate improved, optimized, or adapted software versions while ensuring compatibility and functionality. The system determines compatibility between two code segments by analyzing their associated labels, which describe their functionality. If compatible, the system evolves a new code segment by selectively combining parts of the original segments using evolutionary programming. The new code is generated by merging actions from the original segments, resolving differences by evolving new actions when discrepancies exist. The evolved code is then tested for fitness, and if it meets predefined exit criteria, it is executed. The process ensures that the evolved code retains functional elements from both original segments while introducing novel variations. This approach automates software improvement, adaptation, or optimization by leveraging evolutionary algorithms to iteratively refine code based on compatibility and performance metrics.
2. The non-transitory computer readable medium of claim 1 , wherein: the first candidate code comprises a first context-action pair comprising two or more first context elements; the second candidate code comprises a second context-action pair comprising two or more second context elements; and wherein evolving the third candidate code based on the first candidate code and second candidate code comprises: when a first context element of the first one or more context elements is different from a corresponding second context element of the second one or more context elements, evolving a third, evolved context element from the first context element and the second context element; and including in the third candidate code the third, evolved context element.
This invention relates to a computer-implemented method for evolving code snippets, particularly in the context of automated programming or code generation systems. The problem addressed is the need to generate improved code snippets by combining and evolving multiple candidate code snippets, each containing context-action pairs, to produce a more optimized or effective version. The system processes two or more candidate code snippets, each containing a context-action pair with multiple context elements. When corresponding context elements from different candidate snippets differ, the system evolves a new, optimized context element by combining the differing elements. This evolved context element is then incorporated into a new, third candidate code snippet. The process ensures that the resulting code snippet retains beneficial aspects from both original candidates while resolving conflicts or differences in their context elements. This approach is useful in automated code generation, machine learning-based programming, or software development environments where iterative refinement of code snippets is required. The method improves code quality by systematically merging and evolving code fragments, enhancing functionality, efficiency, or correctness. The non-transitory computer-readable medium stores instructions for performing this evolution process, enabling automated or semi-automated code optimization.
3. The non-transitory computer readable medium of claim 1 , wherein the process further comprises determining a resultant program based at least in part on the third candidate code; determining whether the exit criteria are met based at least in part on the resultant program; and if the exit criteria are met, providing the resultant program as an evolved program.
This invention relates to automated software evolution, specifically a method for iteratively improving computer programs using evolutionary algorithms. The problem addressed is the need for automated systems to generate optimized or improved software versions without manual intervention, particularly in scenarios where human oversight is impractical or inefficient. The system operates by generating multiple candidate code variations, evaluating their performance, and iteratively refining them based on predefined criteria. The process involves selecting a third candidate code from a pool of generated variations, which may include mutations or recombinations of existing code. A resultant program is then derived from this candidate, and its performance is assessed against exit criteria, such as achieving a target efficiency, correctness, or other metrics. If the criteria are satisfied, the resultant program is designated as the evolved program and output for use. If not, the process continues with further iterations. The invention leverages evolutionary computation techniques, such as genetic algorithms, to automate the optimization of software. It is particularly useful in fields like automated programming, software testing, and adaptive systems where continuous improvement of code is necessary. The method ensures that the evolved program meets specified performance benchmarks before being deployed, reducing the need for manual review in each iteration.
4. The non-transitory computer readable medium of claim 3 , wherein the process further comprises: determining whether the second label does not occur in a first candidate executable program associated with the first candidate code; and when the second label does not occur in the first candidate executable program, determining the resultant program based at least in part on the second candidate code.
This invention relates to software development tools that analyze and optimize code execution. The problem addressed is ensuring that code modifications do not introduce errors or unintended behavior, particularly when integrating new code into existing programs. The invention provides a method for validating and selecting code candidates based on label occurrences in executable programs. The process involves comparing labels in candidate code segments against labels in an existing executable program. If a required label (second label) is missing from the first candidate executable program, the system defaults to a second candidate code segment to generate the resultant program. This ensures that critical labels, which may represent function calls, variables, or other program elements, are properly included in the final executable. The method helps prevent runtime errors by verifying label consistency before integrating new code. The invention builds on a prior step of generating candidate code segments (first and second candidate code) and their corresponding executable programs. The validation step checks for label presence to determine which candidate should be used. This approach is useful in automated code generation, refactoring, or patching systems where maintaining label integrity is critical. The solution improves reliability by programmatically enforcing label requirements during code integration.
5. The non-transitory computer readable medium of claim 3 , wherein the resultant program is executable and determining the resultant program comprises determining the resultant program based on the third candidate code and a first candidate executable program associated with the first candidate code.
The invention relates to software development tools, specifically systems for generating executable programs from candidate code snippets. The problem addressed is the challenge of efficiently combining multiple code fragments into a functional, executable program, particularly when the fragments may come from different sources or versions. The solution involves a method for selecting and integrating candidate code snippets to produce a coherent, executable program. The process includes analyzing multiple candidate code snippets, evaluating their compatibility, and generating a resultant program that incorporates the most suitable snippet while ensuring it can be executed alongside other components. The system may also compare the candidate code against existing executable programs to ensure compatibility and functionality. The resultant program is determined by selecting the best candidate code snippet and integrating it with a pre-existing executable program, ensuring the final output is both functional and optimized. This approach improves software development efficiency by automating the integration of code fragments while minimizing errors and conflicts.
6. The non-transitory computer readable medium of claim 3 , wherein determining whether the resultant program meets exit criteria comprises determining whether the resultant program meets exit criteria based at least in part on a fitness measure for the resultant program.
This invention relates to automated program generation, specifically a method for evaluating whether a generated program meets predefined exit criteria using a fitness measure. The system generates a program through an iterative process, where each iteration produces a resultant program. To assess whether the program is complete or satisfactory, the system evaluates the resultant program against exit criteria, which are conditions that determine if the program meets desired performance or functionality standards. The evaluation is based on a fitness measure, a quantitative metric that assesses how well the program fulfills its intended purpose. The fitness measure may consider factors such as correctness, efficiency, or adherence to constraints. If the fitness measure indicates the program meets the exit criteria, the process terminates; otherwise, the system continues refining the program. This approach ensures that only programs meeting specified quality standards are accepted, improving the reliability of automated program generation. The invention is particularly useful in fields like genetic programming, where programs are evolved through iterative optimization.
7. The non-transitory computer readable medium of claim 1 , wherein the process further comprises, when the first candidate code and second candidate code are not compatible, evolving the third candidate code based at least in part on first candidate code without the second candidate code.
The invention relates to a method for generating optimized code in software development, particularly for improving compatibility and performance in code generation systems. The problem addressed is the challenge of combining incompatible code segments while maintaining functionality and efficiency. The system generates candidate code segments, evaluates their compatibility, and evolves a final optimized code segment based on the most suitable candidates. When two candidate code segments are incompatible, the system evolves the final code segment using only the compatible candidate, excluding the incompatible one. This ensures that the generated code remains functional and optimized, even when merging incompatible segments. The process involves iterative refinement, where candidate code segments are assessed for compatibility, and the final output is derived from the most viable candidates. The invention improves code generation by dynamically adapting to compatibility issues, ensuring robust and efficient software development.
8. The non-transitory computer readable medium of claim 1 , wherein determining whether the first label and the second label are compatible comprises determining a premetric based at least in part on the first label and the second label.
This invention relates to a computer-implemented method for evaluating label compatibility in a machine learning or data processing system. The problem addressed is the need to accurately determine whether two labels, such as those assigned to data points in a dataset, are compatible or conflicting, which is critical for tasks like data annotation, model training, and decision-making. The method involves comparing a first label and a second label to assess their compatibility. This is done by calculating a premetric, a mathematical measure derived from the labels, which quantifies their relationship. The premetric may incorporate factors such as label similarity, semantic meaning, or domain-specific rules to determine whether the labels can coexist without contradiction. The system may also use additional techniques, such as label normalization or transformation, to ensure consistent evaluation. The invention is particularly useful in applications where label consistency is essential, such as automated data labeling, conflict detection in datasets, or improving the reliability of machine learning models. By providing a structured way to assess label compatibility, the method helps reduce errors and improve the quality of labeled data used in training and inference. The approach is adaptable to various labeling schemes and can be integrated into existing data processing pipelines.
9. The non-transitory computer readable medium of claim 1 , wherein determining whether the first candidate code and the second candidate code are compatible comprises determining whether there is an exact match between the first label and the second label.
The invention relates to software development tools that analyze code compatibility. The problem addressed is ensuring that different code segments can work together without conflicts, particularly when integrating third-party or legacy code. The system compares candidate code segments by analyzing their labels, which are metadata descriptors indicating functionality, dependencies, or other attributes. The invention improves upon prior methods by using exact label matching to determine compatibility, reducing false positives and ensuring precise integration. This approach is particularly useful in modular programming, where code components must be compatible to function correctly. The system may also include additional compatibility checks, such as version matching or dependency resolution, to further validate integration. The exact label matching ensures that only code segments with identical labels are deemed compatible, minimizing integration errors. This method is implemented in a non-transitory computer-readable medium, allowing it to be executed by a software tool during development or deployment. The invention enhances code integration reliability by providing a strict, label-based compatibility check.
10. The non-transitory computer readable medium of claim 1 , wherein the first candidate code is associated with a first set of two or more labels and the second candidate code is associated with a second set of one or more labels, and determining whether the first candidate code and the second candidate code are compatible comprises determining whether the first set of two or more labels is compatible with the second set of one or more labels.
This invention relates to software development tools that analyze code compatibility, particularly for integrating or comparing code segments with different labeling systems. The problem addressed is ensuring that code components with distinct labeling schemes can be correctly evaluated for compatibility, which is critical in modular programming, code reuse, and integration scenarios. The system involves a non-transitory computer-readable medium storing instructions for executing a method to assess code compatibility. The method compares a first candidate code segment, which is associated with a first set of two or more labels, against a second candidate code segment, which is associated with a second set of one or more labels. The compatibility determination is based on whether the first set of labels is compatible with the second set of labels. This involves analyzing the labels to check for conflicts, dependencies, or required relationships between the code segments. The labels may represent metadata such as version numbers, dependencies, security requirements, or functional attributes. The system ensures that code integration or substitution is only performed when the labels indicate compatibility, preventing errors or unintended behavior in the software system. This approach is particularly useful in large-scale software projects where multiple developers or modules with different labeling conventions must work together seamlessly.
11. The non-transitory computer readable medium of claim 1 , wherein determining whether the first candidate code and the second candidate code are compatible comprises determining a measure of compatibility based on the first label, the second label, the first candidate code, and the second candidate code.
The invention relates to a system for evaluating the compatibility of software code snippets, particularly in automated programming assistance or code generation applications. The problem addressed is the need to accurately assess whether different code segments can be integrated or used together without conflicts, errors, or unintended behavior. This is critical for tasks such as code completion, refactoring, or generating code suggestions in integrated development environments (IDEs). The system analyzes candidate code snippets by comparing their labels and content. Labels may represent metadata such as data types, function signatures, or other attributes that describe the code's behavior or purpose. The compatibility measure is derived from these labels and the actual code structure, ensuring that the snippets can logically interact. For example, if one snippet expects a specific data type and another provides it, they are deemed compatible. Conversely, mismatches in labels or conflicting implementations would indicate incompatibility. The method involves extracting labels from each candidate code snippet, then applying a compatibility algorithm that weighs the relevance of these labels against the syntactic and semantic structure of the code. This allows the system to make informed decisions about whether the snippets can be safely combined or used in sequence. The approach improves the reliability of automated code tools by reducing integration errors and enhancing developer productivity.
12. The non-transitory computer readable medium of claim 1 , wherein the process further comprises selecting the first label based at least in part on access control security associated with the second candidate code.
The invention relates to a computer-implemented method for managing code labels in a software development environment, particularly addressing the challenge of securely assigning labels to code segments while respecting access control restrictions. The method involves analyzing candidate code segments to determine their suitability for labeling, with a focus on ensuring that the labeling process adheres to predefined security policies. Specifically, the process includes evaluating access control security associated with a second candidate code segment to inform the selection of a first label. This ensures that labels are applied in a manner that complies with security constraints, preventing unauthorized access or modifications to sensitive code. The system dynamically assesses security attributes of the candidate code, such as permissions, user roles, or encryption requirements, to determine the appropriate label. This approach enhances security by integrating access control checks into the labeling workflow, reducing the risk of mislabeling or exposing restricted code. The invention is particularly useful in collaborative development environments where multiple users with varying access levels interact with shared codebases. By automating label selection based on security context, the method improves efficiency and reduces human error in managing code metadata.
13. The non-transitory computer readable medium of claim 1 , wherein the first candidate code comprises one or more of a first training context-action pair and first candidate executable code.
A system for generating and evaluating candidate code snippets to improve software development efficiency. The system addresses the challenge of selecting optimal code solutions from multiple candidate options by analyzing context-action pairs and executable code. The first candidate code includes either a training context-action pair, which associates a specific programming context with an appropriate action or solution, or executable code that can be directly implemented. The system evaluates these candidates based on relevance, correctness, and performance metrics to determine the best solution for a given programming task. This approach enhances developer productivity by automating the selection of high-quality code snippets, reducing manual effort, and minimizing errors. The system may also integrate with integrated development environments (IDEs) or code repositories to provide real-time suggestions and improvements. By leveraging machine learning or rule-based techniques, the system continuously refines its recommendations based on historical data and user feedback, ensuring ongoing accuracy and relevance. The solution is particularly useful in software development workflows where developers frequently encounter repetitive or complex coding challenges.
14. A method comprising: determining whether first candidate code and second candidate code are compatible for evolution based at least in part on functionality of the first candidate code and the second candidate code; when the first candidate code and the second candidate code are determined to be compatible for evolution, evolving third candidate code, using evolutionary programming techniques, based on the first candidate code and second candidate code, wherein the third candidate code differs from both the first candidate code and second candidate code, and contains no more than a subset of code from each of the first candidate code and the second candidate code; performing a fitness test based at least in part on the third candidate code; determining whether exit criteria are met based at least in part on the fitness test; and when the exit criteria are met, providing the third candidate code as evolved code and causing execution of the evolved code, wherein: the first candidate code comprises a first context-action pair comprising two or more first context elements; the second candidate code comprises a second context-action pair comprising two or more second context elements; and wherein evolving the third candidate code based on the first candidate code and second candidate code comprises: when a first context element of the first one or more context elements is different from a corresponding second context element of the second one or more context elements, evolving a third, evolved context element from the first context element and the second context element: including in the third candidate code the third, evolved context element, wherein the method is performed on one or more computing devices.
This invention relates to evolutionary programming techniques for generating optimized code by combining and evolving multiple candidate code segments. The problem addressed is the need to automatically improve code functionality by leveraging evolutionary algorithms to merge and refine different code variants. The method involves determining compatibility between two candidate code segments based on their functionality. If compatible, the method evolves a new code segment using evolutionary programming, incorporating elements from both original segments while ensuring the new code differs from both. The evolved code is tested for fitness, and if it meets predefined exit criteria, it is executed. The candidate code segments are structured as context-action pairs, each containing multiple context elements. When corresponding context elements differ between the original segments, the method generates an evolved context element from both, integrating it into the new code. This approach automates code optimization by iteratively refining and selecting the most fit variants, improving performance or functionality without manual intervention. The process is performed on computing devices, enabling scalable and automated code evolution.
15. The method of claim 14 , further comprising, determining a resultant program based at least in part on the third candidate code; determining whether the exit criteria are met based at least in part on the resultant program; and when the exit criteria are met, providing the resultant program as an evolved program.
This invention relates to automated program evolution, specifically a method for iteratively refining candidate code to generate an optimized program. The process involves generating multiple candidate code variations, evaluating their performance, and selectively combining or modifying them to produce improved versions. The method addresses the challenge of optimizing software performance, reliability, or other metrics through automated techniques rather than manual coding. The technique begins by generating a set of candidate code variations, which may include modifications, combinations, or mutations of existing code. These candidates are evaluated based on predefined criteria, such as execution speed, memory usage, or correctness. A subset of the highest-performing candidates is then selected for further refinement. This selection process may involve ranking candidates based on their performance metrics or applying other filtering techniques. The selected candidates are used to generate a new set of variations, which are again evaluated and refined. This iterative process continues until exit criteria are met, such as reaching a performance threshold, exceeding a maximum iteration limit, or achieving convergence. Once the exit criteria are satisfied, the final optimized program is provided as the evolved output. The method may also incorporate additional steps, such as determining a resultant program based on the latest candidate code and verifying whether the exit criteria have been met before finalizing the evolved program. This approach enables automated optimization of software without requiring manual intervention at each stage.
16. A system for executing instructions, wherein said instructions are instructions which, when executed by one or more computing devices, cause performance of a process including: determining whether first candidate code and second candidate code are compatible for evolution based at least in part on functionalities of the first candidate code and the second candidate code; when the first candidate code and the second candidate code are determined to be compatible for evolution, evolving third candidate code, using evolutionary programming techniques, based on the first candidate code and second candidate code, wherein the third candidate code differs from both the first candidate code and second candidate code, and contains no more than a subset of code from each of the first candidate code and the second candidate code; performing a fitness test based at least in part on the third candidate code; determining whether exit criteria are met based at least in part on the fitness test; and when the exit criteria are met, providing the third candidate code as evolved code and causing execution of the evolved code, wherein: the first candidate code comprises a first set of one or more actions; the second candidate code comprises a second set of one or more actions; and wherein evolving the third candidate code based on the first candidate code and second candidate code comprises: when a first action of the first set of one or more actions is different from a corresponding second action of the second set of one or more actions, evolving a third, evolved action from the first action and the second action: including in the third candidate code the third, evolved action.
The system operates in the domain of evolutionary programming for code optimization, addressing the challenge of automatically generating improved code variants from existing codebases. It evaluates compatibility between two candidate code segments based on their functionalities to determine if they can be combined. If compatible, the system generates a new code variant (third candidate code) using evolutionary programming techniques, incorporating elements from both original segments. The new code must differ from both inputs and retain only a subset of their code. The system tests the new code's fitness, checks if predefined exit criteria are satisfied, and if so, executes the evolved code. The candidate codes consist of action sets, and when actions differ between inputs, the system evolves a new action by combining the differing actions. This approach enables iterative code refinement through automated selection and recombination of functional components.
17. The system of claim 16 , wherein: the first candidate code comprises a first context-action pair comprising two or more first context elements; the second candidate code comprises a second context-action pair comprising two or more second context elements; wherein evolving the third candidate code based on the first candidate code and second candidate code comprises: when a first context element of the first one or more context elements is different from a corresponding second context element of the second one or more context elements, evolving a third, evolved context element from the first context element and the second context element; and including in the third candidate code the third, evolved context element.
This invention relates to a system for evolving code candidates in a machine learning or artificial intelligence context, particularly for improving decision-making models. The problem addressed is the need to generate optimized code candidates by combining and evolving multiple candidate codes, each representing context-action pairs used in decision-making processes. Each candidate code includes a context-action pair with multiple context elements that define conditions under which an action is taken. The system evolves a new candidate code by comparing corresponding context elements from two input candidate codes. When a context element in the first candidate code differs from the corresponding context element in the second candidate code, the system generates an evolved context element by combining the differing elements. This evolved context element is then incorporated into the new candidate code, allowing the system to iteratively refine and optimize decision-making logic. The approach ensures that the evolved candidate code retains useful features from both input candidates while introducing variations that may improve performance. This method is particularly useful in reinforcement learning, automated programming, or any domain requiring adaptive decision-making based on contextual inputs.
18. The system of claim 16 , wherein the first candidate code is associated with a first set of one or more labels and the second candidate code is associated with a second set of one or more labels, and determining whether the first candidate code and the second candidate code are compatible comprises determining whether the first set of one or more labels is compatible with the second set of one or more labels.
The system relates to software development tools that analyze and validate code compatibility. The problem addressed is ensuring that different code components, such as libraries or modules, can work together without conflicts. When integrating code, developers often need to verify that dependencies, versions, or other attributes are compatible to avoid runtime errors or performance issues. The system evaluates compatibility between a first candidate code and a second candidate code by analyzing their associated labels. Labels represent metadata such as version numbers, dependencies, or compatibility tags. The system checks whether the first set of labels for the first candidate code is compatible with the second set of labels for the second candidate code. For example, if one code requires a specific library version and another code is incompatible with that version, the system identifies the mismatch. This helps developers identify potential conflicts early in the development process, reducing debugging time and improving software reliability. The system may also include additional features, such as generating compatibility reports or suggesting alternative code versions that resolve conflicts.
19. The system of claim 18 , wherein determining whether the first candidate code and the second candidate code are compatible comprises determining a measure of compatibility based on the first set of one or more labels, the second set of one or more labels, the first candidate code, and the second candidate code.
The system evaluates compatibility between two candidate code segments by analyzing their associated labels and the code itself. The system operates in the domain of software development, where integrating or comparing code segments from different sources is common. A key challenge is ensuring that code segments are compatible before integration, which involves checking for conflicts, dependencies, or mismatches in functionality or behavior. The system addresses this by generating a compatibility measure based on both the labels assigned to each code segment and the actual code content. Labels may include metadata such as programming language, version, dependencies, or functional descriptions. The system compares these labels and the code structure, syntax, or logic to determine whether the segments can work together without errors or unintended side effects. This approach helps developers assess compatibility early in the integration process, reducing debugging time and improving software reliability. The system may also prioritize or rank candidate code segments based on their compatibility scores, aiding in selection or modification decisions.
Unknown
July 14, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.