Classical sorting algorithms as a model of morphogenesis

Abstract

A method of modeling cell movement to predict a cellular process, including: providing a cell set including a plurality of cells, in which each cell within the cell set includes an assigned value and an assigned governing behavior; executing a self-sorting process of the plurality of cells within the cell set based on the assigned value and the assigned governing behavior of each of the plurality of cells, in which during the sorting process the cell set includes a plurality of intermediate arrangements of the plurality of cells within the cell set; determining an evolution of the intermediate arrangements of the plurality of cells during the sorting process; and analyzing the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

Description

CLASSICAL SORTING ALGORITHMS AS A MODEL OF MORPHOGENESISCROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This application claims priority benefit from U.S. Application Ser. No. 63 / 609,132, filed December 12, 2023. The entirety of which is incorporated herein by reference.BACKGROUND

[0002] Agent-based minimal models allow emergent behavior in systems, which provides a way to investigate problem-solving and intelligence. This provides avenues to model behaviors in complex systems, including biological processes, robotics, and more.SUMMARY

[0003] Disclosed herein are methods and systems for modeling a process, using agentbased approaches. In various embodiments, the methods and systems may include one or more of the following.

[0004] In some embodiment, methods and systems of modeling a process are described. The process may include providing a cell set made up of a plurality of cells, in which each cell within the cell set includes an assigned value and an assigned governing behavior; executing a self-sorting process of the plurality of cell within the cell set based on the assigned value and the assigned governing behavior of each of the plurality of cells. In some embodiments, during the self-sorting process, the cell set includes a plurality of intermediate arrangements of the cells within the cell set. The method further includes determining an evolution of the intermediate arrangements of the plurality of cells during the self-sorting process. The method further includes analyzing the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

[0005] In some embodiments, the assigned governing behavior includes an assigned sensing behavior, which determines whether each cell in the plurality of cells senses the value of a different cell, and an assigned moving behavior, which determines how each cell in the plurality of cells moves.

[0006] In some embodiments, the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of its direct neighbors. In some embodiments, the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells in one direction. In some embodiments, the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells in the plurality of cells.

[0007] In some embodiments, the assigned moving behavior allows each cell in the plurality of cells to move in any direction. In some embodiments, the assigned moving behavior allows each cell in the plurality of cells to move in only one direction. In some embodiments, the assigned moving behavior allows each cell to move by swapping places with a direct neighbor. In some embodiments, the assigned moving behavior allows each cell to move by moving to a target location.

[0008] In some embodiments, the self-sorting process is parallelized. In some embodiments, the self-sorting process does not rely on external instructions.

[0009] In some embodiments, executing the self-sorting process includes executing for a predetermined number of time steps. In some embodiments, executing the self-sorting process includes executing until the plurality of cells reaches a target final arrangement.

[0010] In some embodiments, wherein the self-sorting process is executed over a series of time steps, and determining the evolution of the intermediate arrangements includes saving the intermediate arrangement at every time step in the series of time steps. In other embodiments, determining the evolution of the intermediate arrangements includes saving the intermediate arrangement every nth step, in which n is more than 1.

[0011] In some embodiments, the cell set is a chimeric cell set, in which the cell set includes cells with different assigned governing behaviors. In some embodiments, a barrier is introduced in the self-sorting process. In some embodiments, the cell set includes at least one frozen cell and at least one non-frozen cell, in which the frozen cell does not regardless of its assigned moving behavior. In some embodiments, the non-frozen cell can move the frozen cell. In some embodiments, the non-frozen cell cannot move the frozen cell.

[0012] In some embodiments, analyzing includes comparing the final arrangement to a predicted target final arrangement. In some embodiments, analyzing include plotting the evolution of the intermediate arrangements in problem space. In some embodiments, plotting the evolution in the problem space further includes displaying a visual representation of the evolution in the problem space.

[0013] In some embodiments, analyzing includes evaluating at least one of monotonicity error, sortedness, or delayed gratification. In some embodiments, delayed gratification awards temporary increases in monotonicity error to achieve gains at a later stage of the evolution. In some embodiments, analyzing includes characterizing a problem-solving ability of the cell set. In some embodiments, analyzing includes detecting emergent behaviors in the self-sorting process.

[0014] In some embodiments, the methods and systems further include designing and applying a new analysis method to determine secondary behaviors of the evolution of the intermediate arrangements and the final arrangement of the plurality of cells.

[0015] In some embodiments, the process modeled is a biological system. The biological system can be selected from a group including physiological, transcriptional, biochemical, developmental, immunological, neurological, metabolic, and molecular processes. In some embodiments, the analysis further includes modeling regeneration or repair of the biological system. In some embodiments, the analysis further includes modeling biomedicine, bioengineering, or synthetic biology systems.

[0016] In some embodiments, the process modeled includes a plurality of swarm robots. In some embodiments, the process modeled includes a molecular circuit. In some embodiments, the process modeled includes a traditional algorithm. In some embodiments, the traditional algorithm is a traditional sorting algorithm.BRIEF DESCRIPTION OF THE DRAWINGS

[0017] Various objects, features, and advantages of the disclosed subject matter can be more fully appreciated with reference to the following detailed description of the disclosed subject matter when considered in connection with the following drawings, in which like reference numerals identify like elements.

[0018] FIG. 1A shows a schematic demonstrating the process of morphogenesis. The process of morphogenesis during development, repair, and metamorphosis includes cells relocating to positions at which movement will cease (as determined for a given species) (125). Here, ‘E’ = cells which will form the eyes; ‘N’ = cells which will form the nose; ‘M’ = mouth cells. We draw here a parallel to a sorting process which is rearranging the elements of a disordered 1-dimensional set of integers to their correct positions with respect to a monotonic sequence (in development, that is analogous to a positional information axis).

[0019] FIG. IB shows a schematic of sorting algorithms. FIG. IB, left, shows a traditional sorting algorithm performing as a top-down controller that makes decisions about the actions of the elements. FIG. IB, right), shows a cell-view version of this algorithm delegating the decision directly to each element, and the elements take action based on their embedded logical and local conditions.

[0020] FIG. 2A shows the traditional Bubble sort method. In the traditional Bubble sort, the top-down controller chooses the first element on the left that is bigger than its right neighbor and keeps swapping it to the right until the right neighbor has larger or similar value, then repeats that process until all elements are in order.

[0021] FIG. 2B shows the cell-view Bubble sort method. For the cell-view Bubble sort, all cells (elements) run in parallel and can compare their value with their neighbors’ and decide to swap to the left or right based on that value comparison. The sort is completed when no cell can move.

[0022] FIG. 2C shows the traditional Insertion sort method. In the traditional Insertion sort, the controller splits the array into two parts: sorted and unsorted. At the beginning, only the first element on the left is considered “sorted” and all remaining elements in the array are considered “unsorted.” For each step, the controller chooses the left-most element from the unsorted part, and then keeps swapping it to the correct place in the sorted part of the array.

[0023] FIG. 2D shows the cell-view Insertion sort method. In the cell-view Insertion sort, each cell knows all cells on its left, and starts to swap with its left neighbor (if its value is smaller) when all cells to its right are sorted.

[0024] FIG. 2E shows the traditional Selection sort method. In the traditional Selection sort, the controller finds the smallest element (for an increase sort) from unvisited elements and puts it into the next position of the sorted part of the array for each step.

[0025] FIG. 2F shows the cell-view Selection sort method. In the cell-view Selection sort, every cell tries to swap to its own current target position. The swap will be denied if the current cell at that position has a smaller value, and then the current target position of the cell shifts the right of the original current target position.

[0026] FIG. 3 shows an illustration of William James’ example of intelligence expressed as the ability to back-track from one’s goals, which is not seen in simple energy-minimizing systems like magnets that will never go around a barrier to get closer (left-most panel). By contrast, temporary movement against their preference gradient is extensively seen in mammalian systems which can do complex planning (such as the Shakespearean story of Romeo and Juliet, who had to navigate complex physical and social barriers and affordances, in pursuit of their goals, right-most panel). This capacity exists to intermediate degrees in cells, tissues, and various autonomous vehicles (middle panel). This has been proposed as a key parameter for defining a generic notion of intelligence (James, 1890), and is seen in our self-sorting cellular agents able to go around Frozen Cells. Artwork in panel (a) is courtesy of Jeremy Guay of Peregrine Creative.

[0027] FIG. 4A shows example code used for traditional Bubble Sort.

[0028] FIG. 4B shows example code used for traditional Insertion Sort.

[0029] FIG. 4C shows example code used for traditional Selection sort.

[0030] FIG. 5A shows example code used for cell-view Bubble Sort.

[0031] FIG. 5B shows example code used for cell-view Insertion Sort.

[0032] FIG. 5C shows example code used for cell-view Selection sort.

[0033] FIG. 6 shows example code for frozen cells.

[0034] FIG. 7A shows the comparison of Sortedness change during the sorting process between traditional Bubble sort and cell-view Bubble sort.

[0035] FIG. 7B shows the comparison of Sortedness change during the sorting process between traditional Insertion sort and cell-view Insertion sort. The difference between the two graphs is relatively small, because the implementation of cell-view Insertion sort always keeps the left side of the array sorted and allows one cell to join the sorted side each time, which is very similar to the traditional Insertion sorting algorithm.

[0036] FIG. 7C shows the comparison of Sortedness change during the sorting process between traditional Selection sort and cell-view Selection sort. The major difference between these two graphs is that the cell-view sorting process needs more swaps to complete the sort, because every cell can move to its current target position and be swapped away when another cell with smaller value has the same current target position.

[0037] FIG. 8A shows an efficiency comparison between traditional and cell-view sort with respect to active moves taken. 100 experimental repeats were performed in three kinds of sort, in traditional and cell-view modes, to compare efficiencies of each method. When only comparing the active moves taken, cell-view sort is almost exactly as efficient as the traditional version for Bubble and Insertion sort (p = .24), but is less efficient for Selection sort (the Z-test statistical value is 120.43, and p-value is 0).

[0038] FIG. 8B shows an efficiency comparison between traditional and cell-view sort with respect to comparisons as well as active moves (corresponding to the biological cost of sensing, as well as acting). The cell-view versions are actually more efficient for Bubble and Insertion Sorts (Z-test statistical values for bubble and insertion sort were -68.96 and -71.19, respectively, p«0.01), while the cell-view version is less efficient (z = 106.55, p«0.01) for Selection sort.

[0039] FIG. 9A shows a schematic of two kinds of “defects.” Top: cells that can be moved by others but cannot initiate any swaps (“lack of initiative”). Bottom: cells that are completely broken and neither initiate nor participate in swaps initiated by others (“lack of motility”).

[0040] FIG. 9B shows that when a Frozen Cell can be moved by others, the cell-view versions of the sorting algorithms have less monotonicity error than the traditional versions that is, the cell-view versions have higher robustness (error tolerance). The same graph also showsthat among cell-view Bubble sort, Insertion sort, and Selection sort, the Bubble sort has the highest error tolerance, with the Insertion sort having next-highest and the Selection sort lowest.

[0041] FIG. 9C shows that when the Frozen Cell is completely fixed, the cell-view versions of the sorting algorithms also have higher error tolerance than the traditional versions. Here, the cell-view Selection sort has the highest error tolerance.

[0042] FIG. 10A shows an example of going around a Frozen Cell (broken cell) using a short array, in which the cell with value 3 wants to swap to third position but it can’t, so it swaps to fourth position, which is the next possible alternative, because all positions before third position should be occupied by smaller values and only positions after third position are possible to put 3 while fourth position is the most left position after third. This move temporarily decreases the Sortedness, until the cells with values 5 and 6 have swapped and caused Sortedness to increase again.

[0043] FIG. 10B shows that in the arrays with more Frozen Cells, there were multiple local reductions of Sortedness during the process.

[0044] FIG. 10C shows that backtracking and the subsequently realized gains can be used to define a Delayed Gratification index during the sorting process, which is calculated by using the total consecutive increasing value (x) of Sortedness after the drop minus the total consecutive decreasing value (y) as the numerator, and the total consecutive decreasing value (y) of Sortedness before the increase as the denominator.

[0045] FIG. 11 A shows that the cell-view Bubble sort gets more Delayed Gratification than the traditional algorithm (Z = 34.04, p«0.01 ). Bubble and Insertion sorts get more Delayed Gratification as the number of Frozen Cells increases.

[0046] FIG. 1 IB shows that the cell-view Insertion sort gets slightly more Delayed Gratification than the traditional algorithm (Z = 0.60, p = .55). Bubble and Insertion sorts get more Delayed Gratification as the number of Frozen Cells increases.

[0047] FIG. 11C shows that the cell-view Selection sort has less Delayed Gratification than the traditional algorithm (Z = -17.21, p«0.01) and has no clear relation between Delayed Gratification and the number of Frozen Cells. Comparing IA, IB, and IC, the Selection sort doesthe best in Delayed Gratification (Z = 40.81, p«0.01), and the Insertion sort does better than the Bubble sort for both traditional and cell-view algorithms (Z = 98.04, p«0.01).

[0048] FIG. 12A shows the results of each possible combination of sort algorithms within an array. The blue lines indicate the progress of the sort itself (the Sortedness value). We also computed aggregation — the tendency of cells with similar Algotypes to cluster together spatially. To study how such chimeric collectives behave, we investigated 100 repeats of scenarios where each combination of the 3 sort algorithms was represented equally; note that the algorithms were not modified in any way and thus do not have any provision for knowing their own Algotype or that of their neighbors. Remarkably, significant aggregation was observed during the sorting process, reaching >60% (with peaks that occur at slightly different times during the sorting process for each of the chimeric combinations). The pink lines indicate the Aggregation Value when two identical sorts (Bubble Algotype) are used — this negative control shows, as expected, that there is no significant deviation from 50% chance. The red line indicates the Aggregation Value of each kind of sort. As expected, at the beginning the Aggregation Value is 50%, since types are assigned to cells randomly. Likewise, at the end, the Aggregation Value is back to 50% since the array is sorted only by each cell’s Value, with no regard for Algotype, and the Algotypes were randomly assigned.

[0049] FIG. 12B shows the quantified efficiencies of chimeric individuals shown in FIG. 12 A.

[0050] FIG. 12C shows an illustration of “aggregation values.” To understand the relative spatial distribution of cells executing each algorithm within the array during the sorting process, we defined aggregation value: the probability that a cell’s neighbor is of the same type as itself. Algotypes were assigned to each cell randomly in each experimental array and did not change during the course of the sort.

[0051] FIG. 12D shows aggregation values for different sorting algorithms as a function of the percent sorting progress accomplished. In this figure, duplicate digits were allowed in the arrays, so that some instances of each number would be of each of the types, in order to see what maximum aggregation could be achieved if the explicit (monotonic numbers) and implicit (aggregation of types) goals were made compatible. We use purple lines, green lines, and teallines to represent for the Sortedness change for Insertion Algotype, Bubble Algotype and Selection Algotype respectively. The red lines represent the aggregation value change. We observed that the final Aggregation Values in FIG. 12D were larger than the final Aggregation Values in FIG. 12A, showing the system is able to reach greater aggregation values when the pressure of having to sort on unique number values (which can conflict with the goal of identical adjacent Algotypes) is released by allowing duplicate valued cells.

[0052] FIG. 12E shows two examples of the cell aggregation after the sorting process when the list contains duplicate values. Different colors represent different Algotypes. For cells with the same value, the first example shows no clustering while the second example shows clear clustering.

[0053] FIG. 13A shows aggregation values and sortedness for a system with chimeric sorts, made up of cells with opposite sorting directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. The horizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Bubble cells sort decreasingly and Selection cells sort increasingly. After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Bubble > Selection. The Aggregation Values rise and also flatten out: the final Aggregation Values were all higher than the starting averages, which were ~0.5. The data shown here are from experiments with arrays of digits 1-100, with no repeated digits.

[0054] FIG. 13B shows aggregation values and sortedness for a system with chimeric sorts, made up of cells with opposite sorting directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. The horizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Bubble cells sort increasingly and Insertion cells sort decreasingly After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Bubble > Insertion. The Aggregation Values rise and also flattenout: the final Aggregation Values were all higher than the starting averages, which were ~0.5.The data shown here are from experiments with arrays of digits 1-100, with no repeated digits.

[0055] FIG. 13C shows aggregation values and sortedness for a system with chimeric sorts, made up of cells with opposite sorting directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. The horizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Insertion cells sort increasingly, and the Selection cells sort decreasingly. After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Selection > Insertion. The Aggregation Values rise and also flatten out: the final Aggregation Values were all higher than the starting averages, which were ~0.5. The data shown here are from experiments with arrays of digits 1-100, with no repeated digits. Comparing FIGS. 13A-13B, algorithms “win” (being more effective than their competitors) in this order: Bubble > Selection > Insertion.

[0056] FIG. 14A shows cell aggregation and sortedness for chimeric sorts when the two types of cells, with duplicates (multiple copies of cells with the same value) allowed, were trying to sort in opposite directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. The horizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Bubble cells sort decreasingly and Selection cells sort increasingly. After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Bubble > Selection. The Aggregation Values rise and also flatten out: the final Aggregation Values were all higher than the starting averages, which were ~0.5. The data shown here are from experiments with arrays of digits 1-10, with 10 repeated copies of each digit.

[0057] FIG. 14B shows cell aggregation and sortedness for chimeric sorts when the two types of cells, with duplicates (multiple copies of cells with the same value) allowed, were trying to sort in opposite directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. Thehorizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Bubble cells sort increasingly and Insertion cells sort decreasingly. After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Bubble > Insertion. The Aggregation Values rise and also flatten out: the final Aggregation Values were all higher than the starting averages, which were ~0.5. The data shown here are from experiments with arrays of digits 1-10, with 10 repeated copies of each digit.

[0058] FIG. 14C shows cell aggregation and sortedness for chimeric sorts when the two types of cells, with duplicates (multiple copies of cells with the same value) allowed, were trying to sort in opposite directions (monotonic increasing vs. decreasing). For each combination of sort types, there is a consistent but not linear dynamic of conflict between the 2 algorithms. The horizontal gray dotted lines in the middle of the plots indicate the average final Sortedness value of all experiments. Insertion cells sort increasingly and Selection sort decreasingly. After some initial back-and-forth, Sortedness flattens out (reaches a stable point after which nothing will change), with algorithms “winning” (being more effective than their competitors) in this order: Selection > Insertion. The Aggregation Values rise and also flatten out: the final Aggregation Values were all higher than the starting averages, which were ~0.5. The data shown here are from experiments with arrays of digits 1-10, with 10 repeated copies of each digit. Comparing FIGS. 14A-14C, the algorithms “win” (are more effective than their competitors) in this order: Bubble > Selection > Insertion.

[0059] FIG. 15 shows a flow chart of a method to model cell movement to predict a cellular process.

[0060] FIG. 16 shows a schematic diagram of an exemplary computer system.DETAILED DESCRIPTION

[0061] In accordance with some embodiments of the disclosed subject matter, mechanisms (which can include, for example, systems, and methods) for modeling cell movement are provided.

[0062] Simple systems that provide unexpected examples of memory, decision-making, or problem-solving in systems that at first glance do not appear to be complex enough to implement such capabilities are useful for a variety of fields, including but not limited to biological processes / bioengineering, robotics, and problem-solving algorithms. It is critical to develop tools to determine minimal requirements for complex behavior and learning to recognize and predict basal forms of intelligence in unconventional substrates.

[0063] A new approach to investigate and understand algorithms is described herein. The approach is based on visualizing the behavior of an algorithm as a navigation of a problem space, and (1) putting barriers in its place to discover useful and unexpected intelligent competencies to go around barriers, and (2) looking for novel behaviors the algorithm portrays which are not explicitly encoded in the algorithm. This offers many advantages, one of which is the potential of saving computational time and energy. By running a single computation (with a single requirement for energy, time, and cost for computation) for the algorithmic steps, additional work is done that can be harnessed and used for various avenues of discovery. This can lead to inventions where the same computational process (which costs $X to execute at some data center) can be charged to Y customers at the same time (with no extra cost) because they are interested in different emergent behaviors in the algorithm.

[0064] Agent Based Minimal Models

[0065] Many traditional algorithms are based on top-down control of a system. An algorithm defines a set of directions, executes the directions on the data, and receives an output. In general, the computer is in charge and data is passively shuffled around. In contrast, agentbased systems are bottom-up; the data are in charge and make decisions. Agent-based systems provide a unique opportunity to examine emergent behavior and intelligence in a system. Emergent behavior is behavior that arises in a system without explicit instructions to do so. Since top-down algorithms dictate directions data should follow, it is impossible to detect emergent behavior in top-down models. Thus, agent-based models are essential for detecting emergent behavior.

[0066] Intelligence refers to some degree of competency in navigating a problem space to meet a goal. The goal may be adaptive and require the system to meet a goal in the presence ofbarriers, perturbations, and unexpected challenges. For instance, consider a system progressing to reach a goal. If the system encounters a barrier, the system can backtrack in order to move forward and eventually reach the goal. The ability to take temporary losses in order to recoup later gains is a kind of intelligence, which can be referred to as delayed gratification.

[0067] Minimal models are basic models, containing as few components as possible.This minimizes computational energy (e.g., computational memory and time), and removes any potential confounding variables. If a model has too few components, it may be unable to navigate a problem space and overcome challenges. If a model has too many components, it becomes computationally expensive (e.g., requires more memory and time to execute) and it may be difficult to disentangle how the variables interact with one another. It is important to select a minimal model that has enough variable to navigate a problem space, but not so many that it becomes difficult to differentiate the effects of each variable, and how problem-solving emerges.

[0068] Agent-based minimal models can display multiple, unexpected forms of emergent behavior. A single system might exhibit multiple forms of problem-solving, or exhibit useful byproducts of its problem-solving. A single agent-based simulation or experiment can be analyzed with multiple methods, each method uncovering a different emergent behavior. This is a significant benefit in terms of time, cost, and effort of computation; executing one algorithm can yield the discovery of multiple avenues of research.

[0069] Sorting algorithms are used as a model system. However, this work is not limited to sorting algorithms; any algorithm that can be adapted to work bottom-up can be used instead. Distributed algorithms, such as ant-colony optimization, are particular models of interest that would work well.

[0070] Sorting Algorithms as Model System

[0071] Here, sorting algorithms are used as a model system. See FIGS. 1 A-1B for examples of sorting processes. A sorting algorithm is an algorithm that puts initially unordered elements of an array into an order. The terms “array,” “cell set,” and “list” are used interchangeably. An array may be made up of cells (the phrases “cell” and “element” are used interchangeably herein), and each cell may have an assigned value. The term “cell” is used broadly to refer to an item or agent that can move (or be moved) throughout an array; in someembodiments, this may refer to a biological cell whereas in other embodiments a cell may be a numerical or other value while in still other embodiments a cell may be a device such as a swarm robot. An “assigned value” of an element may be a value on which the element can be sorted. For instance, an assigned value can refer to a number, if the array is to be sorted based on ascending or descending values. Alternatively, a goal of a sorting algorithm may be to group like elements into a pattern. An assigned value does not determine the behaviors of an element, but the assigned value does determine a desired position of the element to be in at the end of a sorting process.

[0072] Sorting algorithms are a useful model system for several reasons. First, sorting algorithms are a minimal model. While traditional algorithms use a top-down controller, they can be adapted to be agent based (described in more detail below). Second, sorting algorithms offer useful parallels to a variety of practical applications. For instance, sorting algorithms can be used to model cellular morphogenesis, biomolecular circuits, robotics, or more.

[0073] Traditional sorting algorithms use a top-down controller that makes decisions about the actions of cells in an array. In contrast, an agent-based (here referred to as cell-view) version of the same algorithm assigns a governing behavior to each cell of an array, and the cells take action based on the assigned governing behavior. Thus, a cell-view version of a sorting algorithm is the only way to study emergent behaviors in sorting processes. Cell-view versions of sorting algorithms do not rely on or accept external instructions (e.g., instructions from an algorithm that alter or overrule the assigned governing behavior of individual cells). Critically, cell-view algorithms are self-sorting algorithms; the only instructions come from the cells, not outside controls. Throughout the specification, the term “sorting” is used; when the term “sorting” is used to describe a cell-view model, it should be understood to mean “self-sorting.” FIGS. 2A-2F show examples of traditional and corresponding cell-view sorting processes.

[0074] In order to have cell-view sorting algorithms, two formerly ubiquitous assumptions are broken. First, top-down control is not assumed; instead, elements within an array of numbers can exert minimal agency and implement sorting policies from the bottom up. Second, fully reliable hardware is not required; elements are allowed to be ‘damaged’ and fail to execute the algorithm.

[0075] In exemplary embodiments described herein, a one-dimensional (ID) array is used. However, the same methods can be used for multi-dimensional arrays (e.g., two- dimensional (2D) or three-dimensional (3D) arrays). In the case of a ID array, one can view the array as having a ‘left’ side and a ‘right’ side. It is important to note that this description is purely for ease of understanding; other relational terms such as ‘top and bottom’, ‘east and west’, etc. could also be used. Left and right is merely an easy way to describe an array with two poles on opposite ends.

[0076] When referring to cells in an array, each cell has one or more “direct neighbor,” e g., cells that directly touch a cell in question. In the case of a ID array, this would refer to the cell directly to the left of, and the cell directly to the right of, the cell in question (for example, a cell in position 5’s direct neighbors are the cell in position 4 and the cell in position 6). If a cell is at the end of an array (e.g., the furthest left or the furthest right), it only has one direct neighbor.

[0077] During sorting, cells can move or change positions. For instance, a cell might move by swapping places with its direct neighbor (for example, a cell in position 5 can move to position 4 or position 6). Alternatively, a cell might move by switching to occupy a position that is not a direct neighbor (for example, a cell in position 5 can move to position 2).

[0078] An assigned governing behavior can also be described as an “embedded logical,” “local policy,” or “assigned behavior.” The term “Algotype” also describes the assigned governing behavior of a cell. In general, a cell’s Algotype remains constant for the life of the cell. In some embodiments, a cell’s Algotype can change during the sorting process. In some embodiments, every cell in an array is assigned the same governing behavior. In other embodiments, cells in the same array are assigned different governing behaviors. The assigned governing behavior can be broken down into two related elements: assigned sensing behavior and assigned moving behavior.

[0079] Assigned sensing behavior refers to a logical condition of whether a cell in an array can detect the value of another cell, and, if so, which cells it can sense. The ability to “sense” a neighbor or neighbor’s value can also be referred to as an ability to “view” or “detect.” In some embodiments, an assigned sensing behavior states that a cell can view the value of the cell’s direct neighbors. In some embodiments, an assigned sensing behavior states that a cell canview the value of every cell in one direction (in the case of a ID array, every cell to the left or every cell to the right). In some embodiments, an assigned sensing behavior dictates that a cell has knowledge of its ideal position and can view the cell in that ideal position. The examples of assigned sensing behaviors are not meant to be limiting; other assigned sensing behaviors are possible.

[0080] Assigned moving behavior is a description of how a cell travels during the sorting process. For instance, a cell might be able to swap positions with a direct neighbor. In some embodiments, a cell can swap positions with its left or right neighbor. In some embodiments, a cell can only swap positions with a neighbor in one direction (e.g., can only swap with its left neighbor). In some embodiments, a cell has an ideal target position to which it wants to move. The cell can swap with the cell currently occupying its ideal position. The examples of assigned moving behaviors is not meant to be limiting; other assigned moving behaviors are possible.

[0081] An array made up of cells with assigned values and assigned governing behaviors (e.g., a combination of an assigned sensing behavior and an assigned moving behavior) can undergo a self-sorting process. Executing a traditional sorting process refers to enacting the directions set by the algorithm, and allowing the data to move based on the algorithm’s instructions. Executing a cell-view sorting process is essentially self-sorting; each cell is able to move based on its assigned governing behavior.

[0082] To begin a cell-view sorting process, cells in an array are assigned random values without any particular order (e.g., the values of the cells are not ascending or descending; the order of the values is random). The cells in the array then move based on their assigned governing behavior. In some embodiments, a sorting experiment continues until the cells in the array are in a target final order (e.g., ascending or descending, no cells out of order).

[0083] Cell-view sorting processes can be parallelized, so all cells are moving in tandem. Parallelizing the sorting process decreases the time required to execute the sorting process.Additionally, parallelizing the sorting process better resembles the operation of systems of interest, such as biological processes or swarm robots. In systems such as these, individual elements do not move one at a time, instead they all move in tandem. Parallelizing the algorithm also allows the system to do additional work without any additional computational steps. Forinstance, multiple emergent behaviors may occur because of the parallelizing. Thus, a single experiment can lead to the detection of multiple emergent behaviors, saving on computational memory and time.

[0084] In some embodiments, a sorting experiment continues for a pre-set number of time steps. The phrases “time step” and “step” are used interchangeably. A time step can refer to a movement (e.g., one cell swapping with a neighbor is considered one step). Alternatively, a step can refer to a view and a movement (e g., one cell viewing its neighbors is a step, and swapping with a neighbor is a step). The terms “steps” or “time steps” apply whether a system performs sorting sequentially or in parallel.

[0085] Throughout the process of sorting, cells in an array have intermediate arrangements. The terms “arrangement” and “state” can be used interchangeable; both terms refer to the arrangement of cells in an array at a given time. This refers to an order of cells during the process of sorting, but not the initial or final arrangement. An array has an intermediate arrangement at every time step. An intermediate arrangement can be evaluated and give insights to how the array progresses during the sorting execution. The change in intermediate arrangements throughout the sorting process may be referred to as an evolution of arrangements. In some embodiments, the intermediate arrangement at every time step is saved. In some embodiments, the intermediate arrangement is saved less frequently than every time step. For instance, the intermediate arrangement can be saved every second time step, every third time step, every fourth time step, every fifth time step, every sixth time step, every seventh time step, every eight time step, every ninth time step, every tenth time step, every fifteenth time step, every twentieth time step, every thirtieth time step, every fortieth time step, every fiftieth time step, every sixtieth time step, every seventieth time step, every eightieth time step, every ninetieth time step, or every hundredth time step.

[0086] The final arrangement of an array is the arrangement of cells in the array when the sorting process ends. An array may have a target final arrangement (e.g., in a ID array, ascending or descending values). In some embodiments, an array is able to attain the target final arrangement. In other embodiments, the array is unable to attain the target final arrangement. This may be due to the array being unable to overcome some obstacle. If there is a time limit(e.g., the sorting process is limited by time or number of movements), an array may be unable to reach the target final arrangement in the given time. If an array is unable to attain the target final arrangement, it can be useful to study the differences between the attained final arrangement and the target final arrangement.

[0087] Introducing Challenges to Cell- View Sorting Algorithms

[0088] Introducing challenges to a cell-view, self-sorting process allows better insights to emergent behavior, and potentially the ability to observe problem-solving behaviors or intelligence in the system. A self-sorting process reaching a target final state does not imply any intelligence in the system, it simply proves that the self-sorting process is successful. However, a self-sorting process that succeeds in the presence of obstacles does show emergent, problemsolving behavior. Obstacles can include unexpected challenges, perturbations, and barriers. Multiple obstacles can be introduced into a single system. Here, several exemplary ways to introduce challenges to cell-view sorting algorithms are described.

[0089] In some embodiments, a single array may include cells with different assigned governing behaviors. This is referred to as a chimeric array. A chimeric array may include different portions of cells with different assigned governing behaviors (e.g., 90% of the cells have assigned governing behavior A, 10% of the cells have assigned governing behavior B). In some embodiments, 1% of the cells have assigned governing behavior B, 2% have assigned governing behavior B, 3% have assigned governing behavior B, 4% have assigned governing behavior B, 5% have assigned governing behavior B, 6% have assigned governing behavior B, 7% have assigned governing behavior B, 8% have assigned governing behavior B, 9% have assigned governing behavior B, 10% have assigned governing behavior B, 15% have assigned governing behavior B, 20% have assigned governing behavior B, 25% have assigned governing behavior B, 30% have assigned governing behavior B, 40% have assigned governing behavior B, 45% have assigned governing behavior B, or 50% have assigned governing behavior B. Alternatively, assigned governing behavior A could be in the minority and have a similar range of percentages described above. Chimeric arrays are not limited to two assigned governing behaviors in an array. Three or more assigned governing behaviors could be used. In a chimeric array, a cell cannot sense or know a neighboring cell’s assigned governing behavior. Using achimeric array presents a challenge to the self-sorting process; the cells’ assigned governing behaviors are occasionally at odds, making it harder to reach a target final state. If a chimeric array is able to reach a target final state, the chimeric array has overcome an obstacle, and thus exhibits problem-solving.

[0090] Barriers may refer to elements that cannot move, or elements that follow different movement patterns than the other elements in the array. In some embodiments, one or more cells in an array can be “damaged,” introducing an obstacle for the system to overcome. For instance, a cell may be frozen. A frozen cell refers to a cell that does not always move, even though the sorting algorithm instructs the cell to move. A passive frozen cell cannot initiate a move, but other cells are able to move it. A stuck frozen cell cannot initiate a move, nor can another cell move it. A frozen cell presents an obstacle the functioning cells must overcome in order to become sorted, or to become as sorted as possible given the presence of the frozen cell. In some embodiments, a single cell in an array is frozen. In some embodiments, 1% of cells in an array are frozen, 2% are frozen, 3% are frozen, 4% are frozen, 5% are frozen, 6% are frozen, 7% are frozen, 8% are frozen, 9% are frozen, 10% are frozen, 15% are frozen, 20% are frozen, 25% are frozen, 50% are frozen, or 75% are frozen, 90% are frozen, 95% are frozen, or 99% are frozen.

[0091] A perturbation may be changing something in the array before executing the sorting process (e.g., using a chimeric array). Changing one or more cell’s assigned governing behavior may also be a perturbation. A barrier or defect can refer to a faulty cell in an array (e.g., a frozen cell). An unexpected challenge may refer to something in the array changing during the sorting process (e.g., an element changing its pattern of movement after sorting has begun). Additionally, noise could present a challenge for the algorithm to overcome (e.g., mistakes in the algorithm reading the value of its own cell or that of its neighbors).

[0092] Method of Analysis

[0093] The sorting process may be evaluated with a variety of metrics. Some metrics evaluate the final arrangement of the array. One such metric is the total sorting steps (e.g., how many steps it took for an array to reach a target final arrangement). The total sorting steps can only be determined after a target final arrangement has been reached. If a target finalarrangement is not reached, analysis can focus on how similar or different the achieved final arrangement is from the target final arrangement.

[0094] Some metrics evaluate the evolution of intermediate arrangements of the array. Another metric is monotonicity, which is the measurement of how well the cells follow monotonic order. Monotonicity may be calculated at every time step of the sorting process, and at the final arrangement of the sorting process. Another metric is sortedness, which is the percentage of cells that strictly follow the designated sort order. Sortedness can be calculated at every time step of the sorting process, and at the final arrangement of the array.

[0095] Some metrics can award temporary intermediate arrangements with comparatively lower monotonicity in order to achieve later gains (e.g., an array temporarily becomes more out of order for a number of time steps, but then achieves a better sortedness score at the final arrangement). One such metric is sortedness delayed gratification. Delayed gratification is defined as the improvement in Sortedness made by a temporarily error-increasing action. Higher delayed gratification can indicate a system’s ability to problem solve or act intelligently. FIG. 3 shows examples of intelligence that require back-tracking from one’s goals (e.g., relies on delayed gratification). Delayed gratification is just one example of competency extracted from an algorithm that does not explicitly encode steps on how to accomplish delayed gratification. There are many other metrics, not described herein. The critical point is that delayed gratification is not built into the system; it emerges spontaneously from an algorithm without any instructions to do so.

[0096] One useful approach is to analyze whether a system is capable of problem-solving is to view the system in terms of problem space. In essence, looking at a system in problem space is similar to observing an animal in a landscape and testing on its intelligence and response to problem posed in that environment (e.g., perturbations, barriers, distractions, breakdowns of its parts and its environment, etc.). In some cases, viewing a system in problem space can be looking at a metric of problem solving as a function of time or space. In the case of a sorting algorithm, plotting sortedness as a function of time steps views the sorting process in problem space. In the case of swarm robots, order as a function of time can be a representative problem space. In the case of a complex physiological system, a morphospace can be viewed as arepresentative problem space. A single system can have multiple problem spaces. If a problem space has multiple dimensions (e.g., order in two dimensions), the problem can be viewed as an energy landscape.

[0097] Benefits of Agent-Based Models

[0098] Agent-based minimal models reveal emergent behavior. Critically, one model can reveal multiple emergent behaviors, particularly when navigating a problem space. As described in greater detail in the examples, when sorting a chimeric array, cells are able to backtrack in order to become more sorted later on (e.g., exhibits delayed gratification), and cells with the same assigned governing behavior cluster together. Neither of these behaviors are encoded in the sorting process, but arise naturally in the course of the self-sorting process. The discovery of emergent problem-solving capacities in simple, familiar algorithms contributes a new perspective showing how basal forms of intelligence can emerge in simple systems without being explicitly encoded in their underlying mechanisms.

[0099] This demonstrates several benefits of using agent-based minimal models. First, it functions as a proof of concept that agent-based minimal models are capable of problem solving. Second, it demonstrates that a system with the ability to problem solve can also demonstrate multiple emergent behaviors. This means that a single system can and should be analyzed in with more than one method to determine if the system exhibits multiple emergent behaviors. This offers a significant advantage; a single experiment or simulation can be used in multiple ways. This saves computation memory and time that would be necessary to run multiple simulations.

[0100] Example Systems

[0101] The following is a non-limiting list of exemplary systems to which the disclosed procedures may be applied:

[0102] Biological systems

[0103] Sorting algorithms can be used to model biological systems and cellular processes. A number of parallels between elements of the systems and sorting algorithms described above can be made with biological systems. Examples of these parallels are outlined below.

[0104] An array undergoing a sorting process can be compared to a biological system of a collection of cells undergoing cell movement or morphogenesis. For instance, there are many biological systems that need to establish order through some kind of sorting. This is especially common in developing systems, in which polarity must be established for proper growth and development (e.g., embryos developing an anterior / posterior axis). Possible biological systems include, but are not limited to embryogenesis, tissue development, or cancer cell migration. In these cases, a cell in an array can represent a biological cell. A cell’s assigned governing behavior can be seen as a cell’s fixed genotype or phenotype. Thus, a chimeric array is equivalent to a biological system made up of cells with different genotypes. A frozen cell represents a damaged biological cell that is unable to move.

[0105] In other embodiments, an agent-based minimal model can be used to model a biological process that is not related to morphogenesis or cell movement. The agent-based data paradigm can be used to better control physiological transcriptional, biochemical, and biomechanical properties by visualizing them as the agent and the body as a record of their activities in physical media. In other words, it is the bioelectric / molecular / transcriptional patterns that are the actor, and the rest of the body (e.g., cells, tissues, etc.) as the “tape” in the sense of Turning Machines (e.g., the scratchpad of their behaviors). This is similar to the concepts of ants leaving trails of disrupted sand and pheromones in their wake; the agents are the ants, and the body is the sand.

[0106] This is useful for biomedicine because rather than manipulating molecular pathways and cell properties, it is possible to target the information patterns (e.g., the element in an array, or the data) that operate in the body to make computational models in which those patterns are the agent, and to try to target their behavior with interventions. This could also help find new autonomous competencies (such as delayed gratification) which can be exploited for increasing health states, such as regeneration, repair of damaged tissues, reduction of stress, and improvement of physiological disease conditions. Physiological disease conditions could include immunological, neurological, metabolic, etc., conditions.

[0107] And agent-based minimal model can also help understand how a system will respond to an outside agent such as a toxin or drug. The agent-based minimal model can predicthow a system will respond to barriers (e.g., avoiding the barriers, working around the barriers, or being stopped by barriers). Based on the system response, one could then predict how a biological system would respond to the corresponding drug or toxin. This can be expanded to model drugs or other interventions on any molecular pathway. The drugs act as a barrier in the cells’ (e.g., biological agent) navigation of the space of biochemical, transcriptional, bioelectric, and anatomical state spaces and managing how they get around those barriers.

[0108] Robotics

[0109] Going beyond biological system, agent-based minimal models can be used to model robotic systems. One example of a robotic system is swarm robotic, or groups of robots that are designed to work together. Critically, swarm robotics ideally function without centralized control. Using an agent-based model - in which there is no top-down control, and behavior is generated by the assigned governing behavior of individual cells - is thus a useful comparison. An agent-based minimal model can be used to predict how swarm robots will organize, accomplish goals, and navigate problems. It can also help identify what problems the swarm robots are predicted to be unable to navigate. A single simulation or experiment can provide multiple insights to a system. For instance, a single simulation could show clustering behavior and problem-solving behavior.

[0110] Traditional Algorithms[oni] The method of modeling a process is not limited to sorting algorithms, but can be adapted to many traditional algorithms. The methods are not limited to distributed algorithms; they can be used to adapt top-down algorithms and discover unexpected behaviors. Some potential algorithms include brute force algorithms, recursive algorithms (e.g., divide and conquer, greedy, or dynamic), randomized algorithms, searching algorithms, or hashing algorithms. Modeling the algorithms as agent-based minimal models, it is possible to determine if the algorithms exhibit emergent behaviors. For example, a searching algorithm may also organize data during the searching process. Additionally, the method can be adapted to data in databases. Each piece of data has an assigned governing behavior that dictates how it interacts with a data structure and other data. Thus, it is possible to model and learn how data move within a data structure, or how data flows through networks (e.g., the internet). Modeling the data as acell with an assigned governing behavior could reveal new ways to process, organize, or act on data in a database. The methods described herein could further help uncover new competencies in algorithms.

[0112] One of the key advantages of this method is the ability to use chimeric cases, where cells have different assigned behavior. For instance, it would be possible to use chimeric systems, wherein some data is assigned behavior based on a recursive approach and some data is assigned behavior based on a brute force approach. Or, in the case of a database, selections of data are assigned different governing behaviors. One could then test if the systems are able to complete a task. Additionally, one could see if one or more emergent behavior or problem solving ability are shown.

[0113] The agent-based minimal models and focus on emergent behavior can be used in artificial intelligence (Al). Al includes but is not limited to machine learning, neural networks, deep learning, unsupervised learning, clustering algorithms, classifiers, decision trees, random forest, dimensionality reduction, or support vector machine approaches. The Al can be non- neurom orphic or have architectures that incorporate or are based on the principles of biology. The Al could be trained on the output of a modeled process (e.g., train the algorithm based on the results of a simulation). Or, the Al could be trained to replicate the emergent behavior observed in a modeled process. For example, Al could be trained to replicate the emergent behavior of a sorting algorithm (as explained in the examples, emergent behavior could include delayed gratification and clustering behavior). Or, the Al could be trained based on the output of a sorting algorithm to detect new emergent behavior (e.g., patterns of motion, different forms of problem solving, etc.).

[0114] EXAMPLES

[0115] Introduction

[0116] On their respective time scales, evolutionary and developmental biology require that cognitive capabilities such as memory and goal-directed activity in the face of perturbations originate in proto-cognitive functions that existed long before complex brains came onto the scene. The gradual history of intermediate forms with different levels of competency undermines a view in which discrete natural kinds have, or do not have, binary properties such asintelligence. Moreover, a rich continuum of intermediate forms can be created by chimerizing biological and technological material in many different combinations, further eroding the notion of a binary, categorical separation between engineered and biological capabilities. The nascent field of Diverse Intelligence seeks invariants across evolved, engineered, and hybrid systems to determine what all agents have in common, regardless of their composition or provenance, and thus better to understand the origin and scaling of embodied minds. Beyond fundamental knowledge, this is also an essential step toward being able to recognize, repair, create, communicate with, and ethically relate to an enormous space of extant and forthcoming beings ranging from human cyborgs to synthetic life forms, Artificial Intelligences (AIs), and possible exobiological beings.

[0117] For the purposes of this study, “intelligence” refers to some degree of competency in navigating a problem space so as to meet adaptive goals despite barriers, perturbations, and unexpected challenges. It focuses on problem-solving as an observable behavioral competency, not on the affect, first-person perspective, or playful exploration aspects which can occur in advanced cognitive beings. The goal of using such a definition is aligned with cybernetic approaches that seek frameworks in which degrees of intelligence, from passive and random behavior to high-level metacognition, can be empirically studied in a broad range of unconventional forms. Human beings have much practice and skill in recognizing conventional intelligence implemented as classic “behavior”; we easily detect it in the behavior of mediumsized objects moving at medium speeds in the 3 -dimensional world. However, our evolutionary history, our outward-pointing sense organs, and our cognitive structure all make it difficult to detect unconventional intelligences that operate in novel embodiments, exist at different spatiotemporal scales, or live in unusual problem spaces such as physiological or anatomical morphospaces. In particular, while we have neuroscience and folk theory-of-mind for predicting the competencies of the collective intelligence of neural systems (e.g., animals with brains), we have no mature science that enables us to predict either the goals, or the degree of competency in pursuing those goals, of other kinds of systems.

[0118] Great strides have been made in understanding how complexity can emerge from simple local rules. However, most of the emphasis to date has been on the emergence of phenomena at the lower end of degrees of the ladder of agency. Beyond simple emergentcomplexity, such as that seen in static structures like fractals, lie second-order behaviors that serve as the origins of goals, preferences, valence, memory, and other phenomena that scale up to familiar cognitive systems. Here, in keeping with an emphasis on basal (minimal) cognition, “goal” is used not to refer to a high-order, metacognitive “known purpose” as seen in human behavior, but rather in its minimal cybernetic definition of a target state that a system has some ability to reach, despite a range of challenges. Learning to predict and control the goals of collective systems — especially newly engineered systems — is likely to be of existential importance to human flourishing over the coming decades in areas ranging from swarm robotics to Al systems to bioengineered tissues.

[0119] Diverse Intelligence research includes the use of very minimal models to understand how problem-solving capacities can arise from the interaction of components at various levels. These include synthetic droplets, molecular chemotaxis, and other simple systems in addition to the study of biological pathway models and whole cells and tissues.

[0120] One such system involves the collective behavior of cells during morphogenesis, such as embryonic development, regeneration, metamorphic remodeling, and cancer suppression. What all of these phenomena have in common is the ability of cells (themselves composite, agential materials) to work collectively to achieve specific anatomical endpoints, such as regrowing a limb and then stopping once the correct structure is complete, or remodeling a tail transplanted to the flank into a limb — the structure more appropriate to its new global location. Crucially, this is not just open-loop emergence, but closed-loop control and error-minimization: cellular collective behavior in anatomical morphospace exhibits numerous abilities to solve problems (that is, to meet goals despite perturbations) in ways seen in other collective intelligences. For example, tadpoles which have the position of their facial features scrambled spontaneously re-arrange to the correct positions as they metamorphose into frogs. Examples abound of cells taking actions via molecular, cellular, and tissue-level actuators in order to reach a specific target state despite perturbations or changing circumstances. Thus, it has been proposed that morphogenesis is the behavior of a collective intelligence of cells in anatomical morphospace, and that understanding and learning to exploit the problem-solving competencies of living tissues offers the opportunity for significant advances in regenerative medicine of cancer, traumatic injury, and birth defects.

[0121] A large body of existing work explores the complex behavioral responses and capacities of tissues, cells, and even of molecular pathways. However, all of these systems and their internal subsystems are quite complex, exhibiting a likely endless variety of new details which could be responsible for the observed behaviors. To understand the necessary and sufficient dynamics for competencies to emerge requires insights from even more minimal systems — ones in which all of the components and their interactions are known and precisely trackable. Especially useful models for this research agenda leave no room to posit additional explicit mechanisms, or substrates encoding behavioral policies or goals, that have simply not been discovered yet. Thus, we are interested in toy models of collective decision-making that are entirely transparent, to gain insight into the lower bound at which unexpected behavior and problem-solving competencies can arise which may be relevant to cellular swarms.

[0122] Here, we abstract one key property of regulative morphogenesis: the ability to produce an anatomical structure with a precise order of components along one axis. For example, development or metamorphosis results in a tadpole or frog in which all of the organs are placed in a specific order along the anterior-posterior axis (FIG. 1 A). For the purpose of modeling, we are agnostic as to whether this behavior occurs from scratch, such as during embryogenesis, or by unscrambling existing components (such as during metamorphosis and regenerative remodeling).

[0123] We abstract this task, undertaken by cells which can re-arrange the organs as needed even when starting from highly abnormal initial configurations, as a sorting algorithm. We use traditional sorting algorithms, as studied by countless computer science students, as a minimal system, and we study which unexpected, novel competencies these familiar algorithms might have in order to explore the idea that novel capabilities may lie in systems that we think we fully understand because we designed them.

[0124] The use of a linear array of objects which can determine the overall direction of the collective matches the well-known ability of cells to organize and polarize a primary developmental axis (e.g., anterior-posterior, or left-right), via mechanisms such as morphogen gradients and planar polarization. To improve the fit between this model and the abilities of regulative development, we break two critical assumptions normally used with sortingalgorithms. First, instead of a central algorithm operating on an array of numbers it can see and control in its entirety, we implement a distributed algorithm that is executed, in parallel, by each number (e g., cell) with local knowledge of its environment. In lieu of a central controller, cells have individual preferences about the ordering between them and their neighbors. Second, we do not assume that each operation succeeds — that is, we (like biology) implement an unreliable substrate, in which some cells are defective and may not obey when the rules tell them to move. We then quantitatively investigate the ability of these algorithms to sort an array of integers.

[0125] Our goals here are: (1) to establish a proof of concept for taking a system which seems simple and well -understood, and for using empirical experiments to identify that system’s novel capabilities, goals, behaviors, and failure modes; (2) to gain insight into the dynamical process of establishing a linear axis, so that the relevant dynamics could be better understood by developmental biologists and synthetic bioengineers; (3) to understand how decentralized, agentbased systems can solve morphogenetic control tasks; (4) to determine how noise and unreliability in the medium is handled by such algorithms (robustness); and (5) to identify new behaviors and competencies that are not encoded overtly in the algorithm. Although ours is a very simple system, especially compared to any real biology, the benefit of these sorting algorithms is precisely that they are simple, easy to understand, and offer no place for additional complexity to hide (unlike in real cells). Here we show that even familiar, simple algorithms have the surprising ability to deal with perturbations in order to meet the algorithmically specified goals, and also exhibit novel behaviors that are not directly encoded in the algorithm.Table 1 : Definition of Terms

[0126] Methods

[0127] We developed a sorting algorithm evaluation system and implemented the cellview sorting algorithms in python 3. The following sections provide more details about the model of the sorting platform, the structure of the sorting cells, the process of the evaluation, and the experimental test methods. Example code can be found at: github.com / Zhangtaining / cell_research

[0128] Sorting evaluation system

[0129] We designed the sorting evaluation system to consist of 2 parts: the sorting algorithm execution (which performs the sorting on a given array) and the sorting process evaluation (which oversees and analyzes the sorting across trials).

[0130] Sorting algorithm execution: We use three variables (Position, Value, and Algotype) to describe each cell’s status. Initially, all cells are assigned values for these variables. Each cell has a unique Position (i = 0, 1, 2.. ,L-1), while Value and Algotype may be the same asothers. During sorting, Value and Algotype remain constant, and only the Position changes due to movement. The sorting execution part chooses the specified sorting algorithm to perform the sorting experiments based on the given number of experiments and the Frozen Cells. The execution subsystem passes a Probe object to each experiment run, and the Probe is designed to record each step of the sorting process. After the sorting process ends, the information collected by the Probe is stored as a .npy file.

[0131] Sorting process evaluation: The input for the evaluation is configurable including the algorithms to evaluate, the number of Frozen Cells, and the evaluation types. The evaluation process fetches the files based on the specified inputs. The evaluation subsystem picks up the corresponding files based on the inputs that contain the sorting process info. Then the given evaluation is performed for the data in those files.

[0132] Traditional Sorting Algorithms

[0133] In conventional sorting algorithms, a single top-down controller implements a set of rules to move cells around. The traditional algorithms we used as our baseline were bubble sort (see FIG. 2A), insertion sort (see FIG. 2C), and selection sort (see FIG. 2E). The cell-view versions of the algorithms are shown in FIG. 2B, FIG. 2D, and FIG. 2F.

[0134] Bubble sort begins at the start of the list, and compares the first two elements. If the first element is larger than the second element, the elements are swapped. The next pair of elements (second and third elements) and perform the same comparison and swap if needed.Continue this process, comparing and swapping adjacent elements, while moving through the list of elements. Each past through the list will “bubble up” the largest unsorted element to its correct position at the end of the list. Repeat these steps for the remaining unsorted portion of the list until no more swaps are needed, indicating that the entire list is now sorted. An overview of example code used for Bubble sort is shown in FIG. 4A.

[0135] Insertion sort begins with the first element as the sorted portion (since a single element is always considered sorted). Take the first element from the unsorted portion and compare it with the element(s) in the sorted portion, moving from right to left. Insert the selected element into its correct position within the sorted portion by shifting larger elements to the right. Move to the next element in the unsorted portion. Continue selecting unsorted elements,comparing the unsorted element to the sorted portion, and inserting the unsorted element into its correct position until the entire list is sorted. An overview of example code used for Insertion sort is shown in FIG. 5B.

[0136] Selection sort starts with the entire list as the unsorted portion. The smallest (or largest) element in the unsorted portion is identified. The identified element is swapped with the first element in the unsorted portion, effectively moving the smallest (or largest) element to its correct position in the sorted portion. The boundary between the sorted and unsorted portion is moved one element to the right. Identifying, swapping, and moving is repeated until the entire list is sorted. An overview of example code used for Selection sort is shown in FIG. 5C.

[0137] Implementation of cell-view sorting algorithms

[0138] We sought to study the sorting process in a more biologically grounded (distributed) architecture, where each cell is a competent agent implementing local policies. We thus defined three bottom-up versions of common sort algorithms, where actions take place based on the cells’ perspective (view) of their environment within the array. We used multithread programming to implement the cell-view sorting algorithms. Two types of threads were involved during the sorting process: cell threads are used to represent all cells, with each cell represented by a single thread; a main thread is used to activate all the threads and monitor the sorting process. The cell threads were multiple instances of the same sorting class (i.e., each cell had the same Algotype, which determined which of the sorting algorithms that cell used to guide its behavior). To ensure each cell acquires the lock randomly, regardless of the python scheduler, we ask each cell thread to generate their own random number (0-1) every time before it tries to acquire the lock. Only when the random number is smaller than 0.5 can the cell get the lock. This ensures that each cell gets the lock and performs its behavior randomly. Inspired by the 3 traditional sorting algorithms described above, we designed 3 kinds of cell-view sorting algorithms (FIGS. 2A-2F). Traditional sorting algorithms implemented as bottom-up drivers for cell behavior. In conventional sorting algorithms, a single top-down controller implements a set of rules to move cells around. We sought to study the sorting process in a more biologically inspired architecture, where each cell is a competent agent implementing local policies. We thus defined three bottom-up versions of common sort algorithms, where actions take place due tocells’ perspective (view) of their environment within the array. Shown in FIGS. 2A-2F are examples of how cells are moved (traditional sort) or move themselves (cell-view sort) in each case. All cells have a chance to move at each time step (parallel).

[0139] In Cell-view Bubble sort, each cell is able to view and swap with either its left or right neighbor. The active cell moves to the left if its value is smaller than that of its left neighbor, or the active cell moves to the right if its value is bigger than that or its right neighbor. Example code is shown in FIG. 5A.

[0140] In Cell-view Insertion sort, each cell is able to view all cells to its left, and can swap only with its left neighbor. The active cell moves to the left if cells to the left have been sorted, and if the value of the active cell is smaller than that of its left neighbor. Example code is shown in FIG. 5B.

[0141] In Cell-view Selection sort, each cell has an ideal target position to which it wants to move. Each cell can view and swap with the cell that currently occupies its ideal position. If the value of the active cell is smaller than the value of the cell occupying the active cell’s ideal target position, the active cell swaps places with that occupying cell. Example code is shown in FIG. 5C.

[0142] The sorting process was set up in the main thread. All cells’ threats were activated and killed from there.

[0143] We also introduced the Frozen Cell concept in the following study. The implementation of this concept is in the swap functions, shown in FIG. 6.

[0144] Evaluation metrics

[0145] To quantify the comparison between traditional sorting algorithms and their cellview versions, we utilized the following metrics to evaluate the performance of those algorithms.

[0146] Total Sorting Steps, Average, and Standard Deviation: We defined each swap as a sorting step, and we used the Probe to record the total number of sorting steps for each experiment. Depending on the experiment (as stated in Results), we counted movement, or movement + comparison, as individual Steps. By comparing the average and standard deviation of the total steps, we derive the efficiency of sorting performance. We use d to represent for thecount of the sorting steps for Experiment z, and N for the total number of sorting experiments.Then we get the equation for average sorting steps C and standard deviation s

[0147] Eq. 1

[0148] Eq. 2

[0149] Monotonicity and Monotonicity Error: Monotonicity is the measurement of how well the cells followed monotonic order (either increasing or decreasing). The monotonicity error is the number of cells that violate the monotonic order and break the monotonicity of the cell array. Unlike the total sorting steps, the monotonicity error can be measured at each time step. The following formula shows the calculation for the monotonicity error for increasing order sequence. E stands for the value of cell at position z, and n represents the total cells number. The maximum error is n - 1 when the list is in reverse order:

[0151] Sortedness Value: Sortedness Value is defined as the percentage of cells that strictly follow the designated sort order (either increasing or decreasing). For example, if the array were completely sorted, the Sortedness Value would be 100%. E stands for the value of cell at position z, and n represents for the total cells number:

[0153] Sortedness Delayed Gratification: Delayed Gratification is used to evaluate the ability of each algorithm to undertake actions that temporarily increase Monotonicity Error to achieve gains later on. Delayed Gratification is defined as the improvement in Sortedness made by a temporarily error-increasing action. After measuring the Sortedness for each time step of the sorting process, we can get a Sortedness array. For any Sortedness mono-increasing subarray, we use Sii to represent for the first Sortedness value in the subarray and use Sij to represent for the last Sortedness value in the subarray. The total Sortedness change after a consecutive Sortedness value’s increasing is ^Sincreasing= S - Sa. We use Sdi to represent for the first Sortedness value in the decreasing subarray after the increasing and use Sdj to represent for the lastSortedness value in the decreasing subarray. The Sortedness value decreasing starting from last

[0155] Aggregation Value: In sorting experiments with mixed Algotypes, we measured the extent to which cells of the same Algotype aggregated together (spatially) within an array at any given time. We defined Aggregation Value as the percentage of cells in the array having a directly adjacent left neighbor cell that were all the same Algotype. 71 stands for the algorithm type of cell at position i and n represents for the total number of cells:

[0157] Statistical Hypothesis Test Methods

[0158] We applied standard statistical hypothesis methods, z-test, to evaluate the significance of the differences we report.

[0159] Results

[0160] We first analyzed the results both from our Cell-View Sorting Algorithms and from the traditional versions of those sorting algorithms, with the goal of determining whether the cell-view versions worked (FIGS. 7A-7C), and comparing measures of efficiency, error tolerance, and Delayed Gratification with those of their canonical counterparts. We also examined additional aspects of these algorithms’ traversal of the sorting space, by characterizing their morphological structure during the process.

[0161] FIGS. 7A-7C visualize the sorting process as movement through sequence space. Much as biological morphogenesis can be described as a trajectory through anatomical morphospace, here we view the progressive sorting process as the ability of traditional or cellview sorting algorithms to navigate the state space of sequences toward the eventual goal of monotonicity. We define the degree of sequential order in the array of data, at any given time, as its Sortedness, here plotted on the Y axis. Each plot indicates the trajectory of 100 repeated experiments (sorting process on a random input number sequence, with no repeat digits). Just astheir traditional counterparts do, cell-view sorts successfully completed the sorting process, navigating from a random state to the 100% fully sorted state.

[0162] Efficiency Comparison

[0163] We found that our self-sorting arrays could indeed complete the task and proceeded to characterize their efficiency at doing so. We used the total sorting steps that each algorithm needed to complete the sorting process for 100 elements (n = 100) in each experiment and repeated the experiments 100 times (N = 100) independently for each sorting algorithm. The initial values of the elements are random permutation from 1 to 100 without duplication. Then we used the average sorting steps (C) of the 100 pairs of experiments for traditional algorithms against Cell-View algorithms with same initial values. The value of average sorting steps (Eq. 1) indicated the efficiency of the algorithm (FIGS. 8A-8B).

[0164] We used two different ways to count the sorting steps: one counts only swaps as sorting steps; the other counts both swaps and comparisons. When we counted only swapping steps, the statistical values comparing the efficiencies of Bubble and Insertion sort were 0.73 and 1.26 (p-values were 0.47 and 0.24, respectively), revealing no significant difference between their performance. This indicates that the efficiency is very similar between traditional and cellview versions of Bubble and Insertion sorting algorithms. However, cell-view Selection sort takes more swaps to complete sorting process than its traditional version by 11 times (z = 120.43, p«0.01 ). Thus, we conclude that the cell-view Selection sort is less efficient than the traditional Selection sort.

[0165] The situation changed when we considered both reading (comparison) and writing (swapping) as costly steps, simulating the metabolic cost of both measurements and actions. In this comparison, the total steps taken to complete the sorting process of bottom-up versus traditional sorting algorithms were fewer by 1.5 and 2.03 times for Bubble and Insertion sort, respectively (z = -68.96, -71.19, p«0.01 in both cases). For Selection sort, the total steps of the bottom-up version were greater by 1.17 (z = 106.55, p«0.01). These results indicate that the cell-view Bubble and Insertion sorting algorithms are more efficient than the traditional versions. This is likely because traditional algorithms are using each element to compare with other elements, while cell-view algorithms will stop proactively comparing with other cells when theyare on the target position. In contrast, the cell-view Selection sorting algorithm is less efficient than the traditional Selection sorting algorithm.

[0166] Error Tolerance

[0167] To compare the error tolerance of the cell-view sorting algorithms with that of the traditional sorting algorithms, we introduced Frozen Cells into the sorting process. We ran the sorting Experiment 100 times (N = 100) for 100 cells (n = 100) using different numbers (f = 1, 2, 3) of Frozen Cells and then checked the average final monotonicity errors for the experiments with a given number of Frozen Cells. A higher monotonicity error indicates lower error tolerance (FIGS. 9A-9C). We found that all the cell-view sorting algorithms exhibited less monotonicity error than the traditional versions, from which we conclude that cell-view algorithms have higher error tolerance than the traditional versions.

[0168] By comparing the different cell-view algorithms, we saw that with passive Frozen Cells, the cell-view Bubble sort has the least monotonicity error (average value of 100 experiments was zero with 1 Frozen Cell, 0.8 with 2 Frozen Cells, and 2.64 with 3 Frozen Cells); and the cell-view Selection sort has the highest monotonicity error (average value of 100 experiments was 2.24 with 1 Frozen Cell, 4.36 with 2 Frozen Cells, and 13.24 with 3 Frozen Cells). With stuck Frozen Cells, the cell-view Bubble sort has the highest monotonicity error (average value of 100 experiments was 1.91 with 1 Frozen Cell, 3.72 with 2 Frozen Cells, and 5.37 with 3 Frozen Cells); and the cell-view Selection sort has the lowest monotonicity error (average value of 100 experiments was 1.0 with 1 Frozen Cell, 1.96 with 2 Frozen Cells, and 2.91 with 3 Frozen Cells). In conclusion, we can see that both Cell-view and Traditional algorithms have performed with high error tolerance. The cell-view Selection sort had the highest Error Tolerance with stuck Frozen Cells, and that the cell-view Bubble sort had higher Error Tolerance with passive Frozen Cells.

[0169] Characterization of Delayed Gratification

[0170] Delayed Gratification (DG) is the ability to temporarily go further away from a goal to achieve gains later in the process (FIGS. 10A-10C). To compare the Delayed Gratification (DG) of cell-view algorithms and traditional algorithms, we calculated the Delayed Gratification based on the results of the error tolerance experiments mentioned above (FIGS.11A-11C). FIGS. 11A-11C show Delayed Gratification Comparison between Traditional and Cell-View Sort. Delayed Gratification is a characteristic shown in all the sorting algorithms for both traditional and cell-view, because all the experiments show some degree of Delayed Gratification. However, the Delayed Gratification is not merely evaluating the inefficient movements that occasionally go backwards, because the figures reflect the increasing trend of Delayed Gratification as the number of Frozen Cells increases. All the algorithms showed the ability of Delayed Gratification. It is important to note that traditional sorting algorithms encounter difficulties when encountering frozen cells. The DG metric effectively demonstrates how the level of Sortedness changes as the sorting processes encounters these frozen cells. We use the results from the experiments we have done for the error tolerance to do the analysis. The average Delayed Gratification difference between the Cell-view and Traditional Bubble sort was found to be 0.16 (z = 34.04, p«0.01). The difference between the Cell-view and Traditional Insertion sort was very small - 0.03 (z = 0.60, p = .55). The average DG difference between the Cell-view and Traditional Selection sort was 2.77 (z = 17.21, p«0.01). From these results, we conclude that cell-view Bubble sort performs more DG than the traditional version, cell-view Insertion sort performs very similar amounts of DG as the traditional version, and cell-view Selection sort performs less DG than the traditional version.

[0171] A random walker will also sometimes move further from its goal and thus exhibit what may at first look like Delayed Gratification; in general, perturbative experiments are needed to distinguish these cases and understand what any behavioral system is really doing. To demonstrate DG as a problem-solving strategy, it must be shown to be performed specifically in the context of barriers, not just part of a stochastic strategy without feedback or context. Thus, we next compared the amount of DG observed for each algorithm in the context of different numbers of Frozen Cells: would the algorithm tend to temporarily back-track in Sortedness more often when there are more broken cells in its environment? We observed a clear trend of increasing average Delayed Gratification for the Bubble and Insertion sort experiments for both Traditional and Cell-view, and the Cell-view algorithms performed more Delayed Gratification during the sorting process. The average Delayed Gratification for cell-view Bubble sort was 0.24 with zero Frozen Cell, 0.29 with 1 Frozen Cell, 0.32 with 2 Frozen Cells, and 0.37 with 3 Frozen Cells (all average values are based on 100 repetitions). For Insertion sort, we saw that theaverage DG value was 1.1 with no Frozen Cell, 1.13 with 1 Frozen Cell, 1.15 with 2 Frozen Cells, and 1.19 with 3 Frozen Cells. However, we did not see a clear trend for either cell-view or traditional Selection sort. This reveals that Bubble and Insertion sort deploy Delayed Gratification in a context-sensitive manner; they do more backtracking specifically when faced with defective cells.

[0172] Mixed Algotype Sorting: Analyzing Chimeric Arrays

[0173] We next introduce the notion of an “Algotype”: this refers to one of several discrete algorithms that a cell may be using to control its behavior. Algotype is meant to be distinct from data quantities like a cell’s numerical value (its genotype) or its current position (its phenotype); rather, Algotype reflects a cell’s behavioral tendencies. Our use of bottom-up (distributed) control in the sorting process allowed a new kind of experiment: a chimeric array in which different cells use different policies to achieve their objectives, analogous to biological experiments in which cells with different genetics or cell types were mixed in the same body. We wondered: would chimeric arrays still self-sort, and what would be the behaviors of individual cells when their neighbors were using different algorithms? Note that cells had no explicit provision for detecting their own or their neighbor’s Algotype explicitly. Because the Algotype is a meta-property not addressed in any way in the algorithm itself, its consequences only become evident through the cells’ behavior over time.

[0174] At the beginning of these experiments, we randomly assigned one of the three different Algotypes to each of the cells, and began the sort as previously, allowing all the cells to move based on their Algotype (e.g., their individual sorting algorithm). The process was considered to be completed when all the cells are sorted, or no cell can find a better position to move. When all the cells stop moving, it means that the sorting process stopped. From the programming point of view, the main thread needs to check the array status twice to decide the array is not changing and kill all the process. In control experiments, we used precisely the same code but set both of the Algotypes to the same type (Bubble sort), to rule out any spurious effects due to the implementation and ensure that whatever differences we saw could be attributed to differences in the algorithm’s behavioral policies.

[0175] FIGS. 12A-12E show unexpected aggregation of Algotypes occurs in chimeric arrays. A cell-view (local) implementation of sorting policies enables an experiment that cannot be done in traditional top-down sorting: chimeric arrays in which individual cells follow their own distinct policies (“Algotype”, which can be different among the cells of the array) for how to move (corresponding to chimeric embryos consisting of cells of 2 different lineages). The first observation from these experiments was that all of the Algotype combinations can completely sort the array (FIG. 12A, blue lines), demonstrating that components with different policies but the same goal can be mixed in the same collective without abrogating the ability to complete the system-level task.

[0176] We next checked the efficiency: do chimeric arrays function as efficiently as homogenous ones? We compared the number of swapping steps in mixed-Algotype experiments with those required to reach sorted state in experiments with a single Algotype. The average steps to complete a pure cell-view Bubble sort was 2448.8 (N = 100 replicates). The average steps to complete a pure cell-view Insertion sort was around 2482.8 (N = 100 replicates). The average steps to complete a pure cell-view Selection sort was around 1095.5 (N = 100 replicates). For sorting with mixed Algotypes, the Bubble-Insertion mix took an average of 2476.02 steps to complete the sort (N = 100 replicates). The Bubble-Selection mix took an average of 1740.9 steps to complete the sort (N = 100 replicates). The Insertion-Selection mix took an average of 1534.77 steps to complete the sort (N = 100 replicates). This revealed (FIG. 12B) that the total number of steps used by mixed Algotypes sorts falls between the pure Algotype sort that takes the most steps and the pure Algotype sort that takes the fewest steps. Therefore, we conclude that the efficiency of a chimeric array is roughly the average of the efficiencies of its two component Algotypes (the efficiencies combine linearly).

[0177] We next looked for unexpected behaviors at the level of individual cells and groups of cells (corresponding to chimeric tissues within an organism) by examining the spatial location of cells with different Algotypes. Specifically, we computed the tendency of individual Algotypes to cluster together within the array as a way to determine if the Algotype has any influence on how those cells travel throughout the morphological space making up the array structure, during the array’s travel through its sorting space. To check whether the same Algotypes tended to gather closely together during the sorting process (FIG. 12C), we trackedthe position of different Algotypes and repeated the experiment multiple times to check the average Aggregation Value during the sorting process. It is important to note that this is not something that we could have predicted a priori since none of the algorithms access the Algotype information of their own or neighboring cells - there are no explicit steps implementing clustering or any other kind of distribution.

[0178] As a negative control, we first ran the experiments using Algotypes that were in fact identical algorithms, as a sanity check to exclude the presence of irrelevant factors in the code (FIG. 12A, light pink line). We found that the peak mean Aggregation Value of the Bubble- Insertion mix was 0.61 (std dev 0.04, N = 100), the peak mean Aggregation Value of the Bubble- Selection mix was 0.65 (std dev 0.05, N = 100), and the peak mean Aggregation Value of the Insertion-Selection mix was 0.57 (std dev 0.04, N = 100) (FIG. 12A, revealing the baseline that corresponds to significant aggregation (p«0.01) among arbitrary elements following precisely the same algorithm.

[0179] However, when we analyzed the aggregation values in arrays with chimeric Algotypes (consisting of cells using distinct algorithms to guide their behavior), we observed a remarkable and unexpected effect (dark red lines in FIG. 12A). At the beginning, the aggregation was 0.5 in all cases, as befits the random assignment of Algotypes to cells. At the end, they were also 0.5 because the final state is a fully-ordered array, and the random assignment of Algotypes to initial values means that is impossible to maintain non-random Algotype assortment when sorting on the cells’ values (which are randomly related to their Algotype). However, during the sorting process itself, we observed a significant (p«0.01) difference of the aggregation values from the negative control: distinct Algotypes cluster together, to aggregated peak means of 0.72, 0.65, 0.69, and 0.62 in experiments mixing Bubble and Selection; Bubble and Insertion;Selection and Insertion; and all three, respectively. The maximum segregation occurs at 42, 21, 19 and 22% of the way through the process for Bubble and Selection; Bubble and Insertion; Selection and Insertion; and all three, respectively. We conclude that the different Algotypes exhibit aggregation (spatial clustering) during the sorting process even though the cells have no way to directly read each other’s type and none of the algorithms refer to that property explicitly.

[0180] Based on the above data on algorithm efficiencies, we first hypothesized that cells with a more efficient Algotype would move to the desired positions first, and as the sort continues, the cells with less efficient Algotypes would “catch up” and move the aggregated cells to their final position, splitting up the initial clusters. This hypothesis predicted that the aggregation would be entirely due to differences in the Algotypes’ efficiency (as defined in FIG. 9A). On the other hand, there could be a more general phenomenon at play. To analyze this, we performed similar experiments as above but allowed assignment of duplicated values to cells (100 cells each individually given a value from 1 to 10 and guaranteed each value has 10 cells). Thus, there was no explicit reason for one cell of value “5” (for example) to appear before or after another cell of value “5” by the time the whole array was sorted. In other words, this version of the experiment allows any clustering to be maintained through to the end of the sorting process because a set of numbers could now be at the correct position in terms of their value and yet be arranged in any degree of clustering according to Algotype within that region (FIG. 12E).

[0181] In the duplicate-value case, we observed that the Aggregation Values rose and did not decrease for the Bubble-Selection mix and the Insertion-Selection chimeric arrays. The average final Aggregation Values for Bubble-Selection and Insertion-Selection mixes were 0.65 and 0.7 (repeated 100 times), which is higher than the highest Aggregation Values of Bubble- Selection and Insertion-Selection mixes with non-duplicate values. This suggests that the efficiency hypothesis can be the explanation for the segregation, because the Selection algorithm is more efficient than Bubble and Insertion while the efficiency is similar between Bubble and Insertion based on our previous analysis.

[0182] The experiments in which repeated cell values were allowed also enabled us to ask another question. If we release the pressure of needing to be numerically sorted at the end, how high would the aggregation go9In the unique-value experiments, cells clustered with their same Algotype would eventually get pulled apart at the end to establish the correct final sort order. But, if there were multiple versions of each value with different Algotypes, they could remain next to each other while the whole cluster was in its numerically proper position. Thus, we could see how high the natural tendency for emergent aggregation is, when not artificially limited by the explicit algorithm’s need to sort the values. We performed these experiments (FIG.12D) and observed maximal levels of 0.69, 0.63, and 0.71 in experiments mixing Bubble and Selection, Bubble and Insertion, Selection and Insertion, respectively. The maximum segregation occurred at 100, 13, and 100% of the way through the process for Bubble and Selection, Bubble and Insertion, Selection. This illustrates how the explicit goals of a mechanism, and its emergent behaviors, can be tested separately, and shows the ability for these emergent behaviors to aim for a specific parameter value (e.g., a segregation value of 0.69, not simply “maximize segregation”).

[0183] The availability of chimeric arrays gave us one more interesting opportunity: what happens when the two different Algotypes are at cross-purposes in their traversal of sorting space — that is, when elements in the same array do not have the same goal? This corresponds to biological problems such as chimeras made of animals with different target morphologies: what will the cells end up building? To test this in our model, we performed experiments using two mixed Algotypes, where one was made to sort in decreasing order while the other sorted in increasing order. We ensured that all 3 combinations started from random configurations of similar Sortedness, -50%. At the end of the sorting process, none of them reached 100% sorted; instead, they ended with Sortedness values of 42.5, 73.73, and 38.31 in experiments mixing (a) Bubble sorting decreasingly and Selection sorting increasingly, (b) Bubble sorting increasingly and Insertion sorting decreasingly, and (c) Selection sorting decreasingly and Insertion sorting increasingly, respectively. We observed (FIGS. 13A-13C) that the sorting trajectories of these 3 combinations were very different. For Bubble and Selection, the Sortedness dropped sharply at the beginning of the sorting process, then increased for a short period. After the Sortedness value reached around 48, it dropped again and stopped at the value below 44. For Bubble and Insertion, the Sortedness value monotonically increased and stopped above 50, while for Selection and Insertion, the Sortedness value almost monotonically decreased during the sorting process and stopped below 50. Thus, the different Algotypes battle each other for some time but eventually reach a global equilibrium. This reveals how competition among chimeric subunits with different emergent local goals can be studied in the context of a collective system with explicit algorithmic goals, and the overall stable states that can be achieved. The same experiment using repeated numbers (10 copies each of 1 ... 10) gave similar results (FIGS. 14A- 14C).

[0184] Discussion

[0185] Morphogenesis — the self-assembly of complex anatomies during development or regeneration — can be understood as collective behavior of cells traversing morphospace. We constructed a simplified model of how cells or organs sort themselves along an axis during regulative development and regeneration as being functionally similar to the task of sorting numbers along a number line. Organisms perturbed during development (for example, by moving cells out-of-place), or dissociated cells allowed to re-aggregate, often find their way to the specific target morphology. We used conventional sorting algorithms as a very minimal component of this repair process, and looked for behaviors from those algorithms that might be new to students of computer science who routinely utilize those algorithms. This strategy is part of the field of Diverse Intelligence in that it helps to recalibrate our intuitions about the complexity of underlying mechanisms that may be sufficient for basal competencies normally expected of advanced or even neuronally based systems, and also helps us see navigation of diverse kinds of problem spaces as bona fide behavior that can be probed via interventional strategies. This approach is relevant to other efforts addressing optimization problems in collectives of in silico agents or in morphological computation by materials.

[0186] We analyzed three such algorithms in their classical form, as well as in a new implementation where we discarded two ubiquitous assumptions in favor of more bio-realistic scenarios. First, instead of top-down algorithms that control an entire process as a single agent with a single algorithm (behavioral policy), we implemented the same algorithms from the cell’s- eye view, as a local, distributed system in which each cell has preferences for what neighbors it will have, and has some capacity to move around in order to implement those preferences. While biology does have important examples of global control and top-down signaling, many biological outcomes result from the activities of distributed, local agents. This perspective is implemented in many examples of using agent-based modeling in biology (although the actual agency possessed by those components is typically assumed to be low).

[0187] There exist conventional parallel sorting algorithms, such as multi-threaded merge sort and multi -threaded bubble sort (FIGS. 2A-2F). However, these sorting algorithms closely resemble traditional single-perspective sorting algorithms. They distribute the sorting tasksamong multiple threads to enhance performance, but still fundamentally operate in a top-down manner, in the sense that individual entries in the list have no algorithm of their own. By contrast, our approach gives each entry in the list the ability to “sort itself’ according to its particular algorithm. Random sorting networks use a stochastic process to determine the order in which elements are compared and swapped. The implementation of our Cell-View sorting algorithms could be considered part of the random sorting algorithm class, because random threads can gain the lock to perform their own logic during the sorting process.

[0188] Second, we introduced the notion of damaged or malfunctioning cells that cannot move even when the algorithm says they should. While unreliable computing is an existing field, the standard study of sorting algorithms assumes that the steps are followed correctly. By contrast, biology excels at managing a highly noisy, unreliable media at every scale, utilizing this condition as an important aspect of evolving problem-solving machines (not unique solutions). In biology, the noisiness of the microenvironment is a feature, not a bug, because it forces evolved architectures to be highly competent at pattern completion and repair, in physiological, anatomical, and behavioral contexts. The ability to overcome novelty and error, within the developmental layer between the genome and behavioral / functional phenotypes, hides structural information from selection and encourages evolution of multi-scale competency mechanisms that can do their jobs despite errors in the genome. This fascinating ratchet of continuously increasing problem-solving capacities, and the resulting de-coupling between selection and the genomic hardware specifications, could likely be exploited in future bio-inspired computational platforms.

[0189] We evaluated the Sortedness of the input array as a measure of the traversal of the algorithm through its problem space, and performed experiments which illustrate how even minimal, deterministic systems can be tested for novel behavioral competencies. First, we found that a cell-level version of algorithm does, in fact, work: it completes the task.

[0190] We also assayed an important aspect of intelligence: the ability to, when faced with a Frozen Cell, go around it in a manner that temporarily takes one further from the goal (Delayed Gratification). Pure strategies that seek to minimize error (like the magnets separated by a small piece of wood in William James’ example (James, 1890)) cannot do this, and different creatures have different tolerances for this way of navigating the problem landscape. Thepossibility of this behavior in sorting algorithms has not to our knowledge been considered, possibly because in their traditional implementation, there are no Frozen Cells for them to go around. Here, we included “damaged cells,” which were in effect a Frozen Cell in sorting space — the algorithm simply could not move a cell when it needed to, to continue its trajectory. We found that when their path in sort space is analyzed, it is seen that cell-view sorting algorithms do indeed exhibit this rerouting behavior, temporarily allowing Sortedness to decrease (moving away from their goal) in order to find a new set of steps that would solve the problem and ultimately improve monotonicity. This was shown to be context-dependent; that is, Delayed Gratification was a function of the number of Frozen Cells.

[0191] This is especially significant because our cell-view algorithms contained no explicit steps for what to do in case of a disobeying cell, or even any steps for assaying whether any of their actions have had the desired effect in the first place. In other words, our cells’ explicit algorithms were purely open-loop with no feedback. The fact that our systems nonetheless exhibited implicit goal-seeking with Delayed Gratification highlights two paths to robust biological goal-seeking: stochasticity or distributed components with fault-tolerance. While our simulations here only studied the latter, in future work, we plan to investigate how behavior changes when both techniques can be utilized simultaneously.

[0192] We find it notable and surprising that these simple algorithms solve unexpected problems in their space, given that the algorithm itself has no “metacognitive” steps that monitor the sorting progress. We believe these results, like the maze navigation exhibited by microbial cells and even simple chemical droplets, imply the need for experimental exploration even of systems whose simple, transparent nature can lull us into a false sense that we understand their capabilities just because we understand (or even created) their parts. This goes beyond first-order (static) emergent complexity (e.g., fractals or cellular automata) and draws attention to a next level: emergent behavioral competencies and the beginnings of minimal agency.

[0193] Lastly, we note that the use of bottom-up distributed algorithms allows the testing of something that is impossible in the classic version: a chimeric scenario in which some cells utilize a different sort algorithm than other cells. Chimerism at different scales is often used in biology to address the role of the genome in the collective decision-making that determineslarge-scale form and function. Yet despite much progress on the molecular genetics guiding individual cell properties, the field generally has no models that make predictions on morphological outcomes from chimeric experiments in development or regeneration. That is, while we have a good understanding of the molecular hardware, we do not have good frameworks for understanding the collective decision-making of cells with different policies (“biological algorithms” for systems with multi-scale competency) with respect to how they will navigate anatomical space. Simple models like ours which map the behavioral competencies of chimeric systems onto large-scale problem-solving are important for developing an understanding of the principles involved.

[0194] We define the notion of the Algotype, referring to the behaviors of a given cell under various circumstances. We intend this concept to be significantly different from genotype (specification of the explicitly observable hardware) and from phenotype (outcomes that can be detected in a single observation, such as geometric or physiological states and properties). Note that in denoting the time-extended “personality” of cells, the Algotype consists of two components: the expected behavior overtly encoded in the algorithm (the sorting), and possible emergent tendencies not obvious from the mechanics and not explicitly assigned (e g., the clustering). Thus, Algotypes include behavioral tendencies (such as preferring to associate with their “kin” during their journey through morphospace) that may not be explicitly encoded anywhere in the algorithm and can only be observed as a holistic dataset encompassing many scenarios and situations. In biology, multiple Algotypes can be instantiated by the same genetics, and multiple different genomes can result in hardware with similar Algotypes. We believe this notion will be useful to understand plasticity and scaling of competencies in biology far beyond the toy model of multi-scale problem-solving explored here.

[0195] We found that chimeric arrays consisting of distinct Algotypes still manage to get sorted; there is no need for each cell to be following the same algorithm as long as they have the same goal. However, if they are set to cross-purposes (one sorts for increasing, and the other sorts for decreasing), they reach a dynamic equilibrium at a mixed, intermediate state in which the large-scale demographics of the array (with respect to Algotype) no longer changes, but the individual cells can still move (akin to extensive biological turnover at the molecular and cellular scale while the large-scale anatomy is maintained over years).

[0196] This is, as far as we know, the only model that implies a prediction of what will happen when, for example, different species’ stem cells (neoblasts) are mixed within one flatworm body. Given that each set of stem cells knows how to undergo division and metamorphosis until a specific head shape is completed, it is entirely unclear what will happen in a chimeric worm: will one type be dominant over the other, or will an intermediate shape result, or will there be endless remodeling because neither set of cells ever reaches its stop condition with respect to the morphology? Our model showed that despite no explicit affordance made for this scenario in the algorithm, the sorting process included many islands within each array where cells of similar Algotypes clustered together within the space of the overall array. This suggests the testable hypothesis that what will occur in a chimeric biological body is the establishment of a set of tissue-level islands, each of which has the identity of one of the parent species (a patchwork of local neighborhoods that possess a tissue-wide but not organism-wide identity). Because our model did not include explicit mechanisms for cells to behave differently with neighbors of different Algotypes, we suggest that this biological clustering should occur even in the absence of, for example, distinct adhesion molecules present on the cells of different genomes or any other hardware-encoded mechanisms for cell sorting.

[0197] Finally, we found a most unexpected behavior in these chimeras. During the sorting process, cells with similar Algotypes (and thus the same sorting behaviors) tended to aggregate together spatially within the array. Eventually they are pulled apart by the necessity to sort themselves according to their positional (numerical) value (rather than by algorithm type), but before that happens, they act as though they have a strong affinity for each other despite the fact that the algorithm says nothing about aggregating, and has no explicit provision for a cell determining the Algotype of any given neighbor (or itself). We suggest that this simple model can be used to ask basic questions about large-scale outcomes in chimeric systems in which components have different explicit and implicit Algotypes. These kinds of analyses can begin to provide principled answers to currently open questions in biology, such as how to predict the morphogenetic outcomes in cellular chimeras consisting of different species’ cells or engineered components that extend functional reach outside the standard body envelope. This may also be usable as a way to increase the utility of computation per unit cost, as the aggregation happens “for free” as part of the sorting process (requires no additional computational steps). It may bepossible to harness this type of byproduct effect for useful functionality that requires no extra execution steps.

[0198] By allowing repeated digits, we were able to partially dissociate the pressures of the explicit algorithm (to sort elements based on numerical value) from the tendencies of the emergent aspect of the Algotype (to cluster with like-minded elements within the string). Existing real-world biological examples of releasing sub-agents from explicit control, to ask what they would do if allowed, include the engineering of biobots. It has recently been shown that un-modified, genetically normal cells self-assemble into constructs with novel behaviors when freed from the instructive influence of their neighbors, revealing baseline competencies not apparent from their standard role within default developmental algorithms. The minimal model shown here represents a first step toward the development of more general strategies to study emergent goals in collective systems and ways in which those goals cooperate with, compete with, and alter the performance of explicit goals we (or evolution) instantiate via hardware or software mechanisms.

[0199] There is no magic here, of course: everything that happens is, in some way, a consequence of the rules being followed. In the same way, truly cognitive behavior of living systems must be consistent with the physics of their smallest components. However, while such behaviors do not contradict the laws of physics of their world and can be explained after they are observed, they often require a different set of conceptual tools to effectively predict and exploit them than physics and chemistry. We believe advances in our understanding will result from when we will be able to identify and predict in advance the preferences and behavioral competencies of novel collective systems we engineer. Note also that we observed not only capabilities related to the solving of the problem which the algorithm explicitly addressed (sorting numbers) but new behaviors (clustering) that do not seem related to the intended purpose for which their algorithm was written. This aspect goes beyond the well-known realization that simple rules can give rise to unexpected emergent behaviors, emphasizing the need to be able to predict and control the properties that such novel behaviors actively seek to maximize.

[0200] This model can be expanded in numerous ways. For example, what happens with cells that are not permanently broken, but have the ability to unfreeze given specific (or merelyrepeated) nudges by their neighbors? Also, we plan to investigate how general these findings are to algorithms for 2-dimensional ordering problems and others. Another interesting direction would be to mix distributed and top-down controls — to monitor the behavior of a classical algorithm working on an agential material that also moves in ways that it was not instructed to. This is the situation in biology, and the evolutionary and cognitive impacts of an agential medium are just beginning to be understood. Understanding what changes should be made to a top-down algorithm to facilitate and exploit the competencies of its medium would, for example, assist the design of multi-scale robotics.

[0201] One limitation of the current analysis is that we looked at only one emergent behavior (aggregation); other interesting things could be happening that we do not yet know to test for, even in this system. More broadly, we believe it is necessary to develop frameworks for looking for novel competencies in systems, with an increased emphasis on broad, unbiased analyses to help human scientists find those goal-directed behaviors which our cognitive biases do not readily facilitate.

[0202] We suggest that the study of these kinds of dynamics is potentially of broad significance. In both science and everyday life, we deal with a wide range of systems along the spectrum stretching from passive matter (and mechanisms made thereof) to the complex metacognitive capacities of adult human beings. Especially interesting are the intermediate cases, such as cells, organs, swarms, artificial intelligences, autonomous vehicles, synthetic organisms, constructs made of active matter, and other increasingly prevalent systems that have never existed in the evolutionary stream, all of which display a diverse range of capacities. It is not enough to aim for minimizing estimates of agency, because sub-optimal efficacy of prediction and control can result when we treat advanced reprogrammable systems as dumb machines and fail to appreciate their unexpected competencies. There are, of course, also downsides to overestimating agency. The latter (false positives) result in low efficiency, while the former (false negatives) are associated with opportunity cost in engineering and regenerative medicine, not to mention serious ethical lapses; it is therefore both practically and ethically valuable to get our estimates of agency correct, not just low.

[0203] Indeed, this problem has only gotten thornier with time. During the early days of computers, we could accurately treat machines as passive (non-agentic) and humans as smart. However, with improvements in bioengineering and Al, it is becoming harder and harder to rely on such simple heuristics. The field of Diverse Intelligence seeks principled frameworks for being able to recognize, predict, control, create, and ethically relate to a wide range of unconventional systems across the intelligence spectrum. Algorithms are increasingly seen as open dynamical systems interacting with other algorithms, physical systems, and agents; as such, they are good candidates, alongside genes, thermodynamic cycles, and passive information, for an abstraction of the minimal unit of agency in the biotic and abiotic world.

[0204] Classical thinkers such as William James were prescient enough to define intelligence in a cybernetic way, not tied to specific hardware (e.g., brains) or evolutionary origins. Definitions such as “competency to reach the same goal by different means” provide a sufficiently general, but empirically testable, way to define a spectrum of cognitive capacities. This drives hopes of being able to infer the design principles by which cognitive systems of different levels can be built, by creating novel active agents and studying the rich examples provided for us across the web of life. We strongly support a definition of basal intelligence as problem-solving, utilizing an objectively observable, third person perspective to distinguish these highly tractable and empirically testable questions from the thorny debates around first-person consciousness.

[0205] Minimal chemical systems such as active matter are being explored. Here, we sought to produce an even more minimal, digital version of a system in which baseline expectation would not normally suggest any degree of intelligence. One advantage over biology, even at its lowest scales, is simplicity and transparency that guarantees that observed competencies of these algorithms are not due to an as-yet undiscovered explicit mechanism. Our goal is to show how an empirical stance, in which we use experimental tools of behavioral science and other disciplines to determine (rather than to make assumptions about) the level of cognition in a system, leads to interesting novel findings and discovery of capabilities we did not expect in a small, well-defined, deterministic, fully transparent system created entirely by us. Prior examples of this approach include dynamical systems such as models of gene-regulatory networks, which exhibit not only complexity but several types of unexpected learning capacity.We suggest that the discovery of unexpected problem-solving competencies (such as Delayed Gratification and segregation) that are not apparent from the component policies and algorithms themselves is a critical research program. The impacts of this effort, a central component of the emerging field of Diverse Intelligence, will have implications ranging across evolutionary developmental biology, philosophy of mind, Al alignment, and human flourishing via the safety of engineered composite systems.

[0206] Illustrative Embodiments of Methods and Systems Described Herein

[0207] FIG. 15 shows an example process 1500 to model cell movement to predict a cellular process. At step 1502, a cell set is provided. The cell set may be an array including more than one cell. Each cell in the cell set may have an assigned value and an assigned governing behavior. At step 1504, the more than one cells may be sorted within the cell set. The cells may be sorted based on their assigned value and their assigned governing behavior. During the sorting process, the set of cells may undergo at least one intermediate arrangement of the cells within the cell set. At step 1506, the evolution of the arrangements of the cells within the cell set cand be determined. Determining the evolution may be based on the at least one intermediate arrangement. At 1508, the evolution and a final arrangement of cells within the cell set can be analyzed.

[0208] In FIG. 16, an example 1600 of a system (e.g., a data processing system) for characterizing a protein in accordance with some embodiments of the disclosed subject matter is shown.

[0209] In some embodiments, computing device 1604 and / or server 1616 can be any suitable computing device or combination of devices, such as a desktop computer, a laptop computer, a smartphone, a tablet computer, a wearable computer, a server computer, a virtual machine being executed by a physical computing device, etc. As described herein, system 1600 can present information about the characterized protein to a user (e.g., a researcher and / or a physician).

[0210] In some embodiments, communication network 1602 can be any suitable communication network or combination of communication networks. In some embodiments, communication network 1602 can be any suitable communication network or combination ofcommunication networks. For example, communication network 1602 can include a Wi-Fi network (which can include one or more wireless routers, one or more switches, etc.), a peer-to- peer network (e.g., a Bluetooth network), a cellular network (e.g., a 4G network, a 5G network, etc., complying with any suitable standard, such as CDMA, GSM, LTE, LTE Advanced, WiMAX, etc.), a wired network, etc. In some embodiments, communication network 1602 can be a local area network, a wide area network, a public network (e.g., the Internet), a private or semi-private network (e.g., a corporate or university intranet), any other suitable type of network, or any suitable combination of networks. Communications links shown in FIG. 16 can each be any suitable communications link or combination of communications links, such as wired links, fiber optic links, Wi-Fi links, Bluetooth links, cellular links, etc.

[0211] FIG. 16 additionally shows an example of hardware that can be used to implement computing device 1604 and server 1616 in accordance with some embodiments of the disclosed subject matter. In some embodiments, computing device 1604 can be used to execute one or more set of instructions to identify a behavioral catalog. In other embodiments, computing device 1604 can be used to identify therapeutic interventions. In still other embodiments, computing device 1604 can be used to identify a configuration of parameter of a gene regulatory network to perform a desired function.

[0212] As shown in FIG. 16, computing device 1604 can include one or more hardware processor 1606, one or more displays 1608, one or more inputs 1610, one or more communications 1612, and / or memory 1614. In some embodiments, processor 1606 can be any suitable hardware processor or combination of processors, such as central processing unit, a graphics processing unit, etc. In some embodiments, display 1608 can include any suitable display devices, such as a computer monitor, a touch screen, a television, etc. In some embodiments, inputs 1610 can include any suitable input device and / or sensors that can be used to receive user input, such as a keyboard, a mouse, a touchscreen, a microphone, etc.

[0213] In some embodiments, communication systems 1612 can include any suitable hardware, firmware, and / or software for communicating information over communication network 1602 and / or any other suitable communication networks. For example, communications systems 1612 can include one or more transceivers, one or more communication chips and / orchip sets, etc. In a more particular example, communications systems 1612 can include hardware, firmware and / or software that can be used to establish a Wi-Fi connection, a Bluetooth connection, a cellular connection, an Ethernet connection, etc.

[0214] In some embodiments, memory 1614 can include any suitable storage device or devices that can be used to store instructions, values, etc., that can be used, for example, by processor 1606 to present content using display 1608, to communicate with server 1616 via communications system(s) 1612, etc.

[0215] Memory 1614 can include any suitable volatile memory, non-volatile memory, storage, or any suitable combination thereof. For example, memory 1614 can include RAM, ROM, EEPROM, one or more flash drives, one or more hard disks, one or more solid state drives, one or more optical drives, etc. In some embodiments, memory 1614 can have encoded thereon a computer program for controlling operation of computing device 1604. In such embodiments, processor 1606 can execute at least a portion of the computer program to present content (e.g., images, user interfaces, graphics, tables, etc ), receive content from server 1616, transmit information to server 1616, etc.

[0216] In some embodiments, server 1616 can include a processor 1618, a display 1620, one or more inputs 1622, one or more communications systems 1624, and / or memory 1626. In some embodiments, processor 1618 can be any suitable hardware processor or combination of processors, such as a central processing unit, a graphics processing unit, etc. In some embodiments, display 1620 can include any suitable display devices, such as a computer monitor, a touchscreen, a television, etc. In some embodiments, inputs 1622 can include any suitable input devices and / or sensors that can be used to receive user input, such as a keyboard, a mouse, a touchscreen, a microphone, etc.

[0217] In some embodiments, communications systems 1624 can include any suitable hardware, firmware, and / or software for communicating information over communication network 1602 and / or any other suitable communication networks. For example, communications systems 1624 can include one or more transceivers, one or more communication chips and / or chip sets, etc. In a more particular example, communications systems 1624 can includehardware, firmware and / or software that can be used to establish a Wi-Fi connection, a Bluetooth connection, a cellular connection, an Ethernet connection, etc.

[0218] In some embodiments, memory 1626 can include any suitable storage device or devices that can be used to store instructions, values, etc., that can be used, for example, by processor 1618 to present content using display 1620, to communicate with one or more computing devices 1604, etc. Memory 1626 can include any suitable volatile memory, nonvolatile memory, storage, or any suitable combination thereof. For example, memory 1626 can include RAM, ROM, EEPROM, one or more flash drives, one or more hard disks, one or more solid state drives, one or more optical drives, etc. In some embodiments, memory 1626 can have encoded thereon a server program for controlling operation of server 1616. In such embodiments, processor 1618 can execute at least a portion of the server program to transmit information and / or content (e.g., results of a tissue identification and / or classification, a user interface, etc.) to one or more computing devices 1604, receive information and / or content from one or more computing devices 1604, receive instructions from one or more devices (e.g., a personal computer, a laptop computer, a tablet computer, a smartphone, etc.), etc.

[0219] In some embodiments, any suitable computer readable media can be used for storing instructions for performing the functions and / or processes described herein. For example, in some embodiments, computer readable media can be transitory or non-transitory. For example, non-transitory computer readable media can include media such as magnetic media (such as hard disks, floppy disks, etc.), optical media (such as compact discs, digital video discs, Blu-ray discs, etc ), semiconductor media (such as RAM, Flash memory, electrically programmable read only memory (EPROM), electrically erasable programmable read only memory (EEPROM), etc.), any suitable media that is not fleeting or devoid of any semblance of permanence during transmission, and / or any suitable tangible media. As another example, transitory computer readable media can include signals on networks, in wires, conductors, optical fibers, circuits, or any suitable media that is fleeting and devoid of any semblance of permanence during transmission, and / or any suitable intangible media.

[0220] References

[0221] The following references are herein incorporated by reference in their entirety.

[0222] Abramson C. I., Levin M. (2021). Behaviorist approaches to investigating memory and learning: A primer for synthetic biology and bioengineering. Communicative & Integrative Biology, 14(1), 230-247.

[0223] Adamatzky A. (2012, Jun). Slime mold solves maze in one pass, assisted by gradient of chemo-attractants. IEEE Transactions on NanoBioscience, 11(2), 131-134.Adamatzky A., Chiolerio A., Szacilowski K. (2020, Feb 12). Liquid metal droplet solves maze. Soft Matter, 16(6), 1455-1462.

[0224] Agmon E., Gates A. J., Beer R. D. (2016, Fall). The structure of ontogenies in a model protocell. Artificial Life, 22(4), 499-517.

[0225] Anderson P. W. (1972, Aug 4). More is different. Science, 177(4047), 393-396.

[0226] Arias Del Angel J. A., Nanjundiah V, Benitez M., Newman S. A. (2020, 2020 / 10 / 12). Interplay of mesoscale physics and agent-like behaviors in the parallel evolution of aggregative multicellularity. EvoDevo, 11(1), 21.

[0227] Armstrong J. (2003). Making reliable distributed systems in the presence of software errors: The Royal Institute of Technology.

[0228] Arnellos A., Moreno A. (2015, May). Multicellular agency: An organizational view. Biology and Philosophy, 30(3), 333-357.

[0229] Baluska F., Levin M. (2016). On having No head: Cognition throughout biological systems. Frontiers in Psychology, 7, 902.

[0230] Baluska F., Reber A. S. (2021, Dec). Cellular and organismal agency - not based on genes: A comment on Baverstock. Progress in Biophysics and Molecular Biology, 167, 161— 162.

[0231] Barandiaran X. E., Di Paolo E., Rohde M. (2009, Oct). Defining agency: Individuality, normativity, asymmetry, and spatio-temporality in action. Adaptive Behavior, 17(5), 367-386.

[0232] Beer R. D. (1995, Jan). A dynamical-systems perspective on agent environment interaction. Artificial Intelligence, 72(1-2), 173-215.

[0233] Beer R. D. (2004). Autopoiesis and cognition in the game of life. Artificial Life, 10(3), 309-326.

[0234] Beer R. D. (2014, Spring). The cognitive domain of a glider in the game of life. Artificial Life, 20(2), 183-206.

[0235] Beer R. D. (2015, Winter). Characterizing autopoiesis in the game of life. Artificial Life, 21(1), 1-19.

[0236] Beer R. D., Williams P. L. (2015, Jan). Information processing and dynamics in minimally cognitive agents. Cognitive Science, 39(1), 1-38.

[0237] Bessonov N., Levin M., Morozova N., Reinberg N., Tosenberger A., Volpert V. (2015, Dec). Target morphology and cell memory: A model of regenerative pattern formation. Neural regeneration research, 10(12), 1901-1905.

[0238] Birnbaum K. D., Sanchez Alvarado A. (2008, Feb 22). Slicing across kingdoms: Regeneration in plants and animals. Cell, 132(4), 697-710.

[0239] Biswas S., Clawson W, Levin M. (2022, Dec 23). Learning in transcriptional network models: Computational discovery of pathway-level memory and effective interventions. International Journal of Molecular Sciences, 24(1), 285.

[0240] Biswas S., Manicka S., Hoel E., Levin M. (2021, 2021 / 02 / 01 / ). Gene regulatory networks exhibit several kinds of memory: Quantification of memory in biological and random transcriptional networks. iScience, 24(3), 102131.

[0241] Blackiston D., Kriegman S., Bongard J., Levin M. (2023, Aug). Biological robots: Perspectives on an emerging interdisciplinary field. Soft Robotics, 10(4), 674-686.

[0242] Boisseau R. P, Vogel D., Dussutour A. (2016, Apr 27). Habituation in non-neural organisms: Evidence from slime moulds. Proceedings. Biological sciences, 283(1829), 20160446.

[0243] Bongard J., Levin M. (2021, 2021 -March- 16). Living things are not (20th century) machines: Updating mechanism metaphors in light of the modern science of machine behavior. Frontiers in Ecology and Evolution, 9, 650726.

[0244] Bongard J., Levin M. (2023, Mar 8). There’s plenty of room right here: Biological systems as evolved, overloaded, multi-scale machines. Biomimetics, 8(1), 110.

[0245] Boussard A., Delescluse J., Perez-Escudero A., Dussutour A. (2019, Jun 10). Memory inception and preservation in slime moulds: The quest for a common mechanism. Philosophical Transactions of the Royal Society of London - Series B: Biological Sciences, 374(1774), 20180368.

[0246] Brancazio N., Segundo-Ortin M., McGivem P. (2019, Dec). Approaching minimal cognition: Introduction to the special issue. Adaptive Behavior, 28(6), 401-405.

[0247] Brown A. D., Mills R., Dugan K. J., Reeve J. S., Furber S. B. (2015, 2015 / 07 / 01). Reliable computation with unreliable computers. IET Computers & Digital Techniques, 9(4), 230-237.

[0248] Bugaj L. J., O’Donoghue G. P, Lim W. A. (2017, Jan 2). Interrogating cellular perception and decision making with optogenetic tools. The Journal of Cell Biology, 216(1), 25- 28.

[0249] Cejkova J., Banno T., Hanczyc M. M., Stepanek F. (2017). Droplets as liquid robots. Artificial Life, 23(4), 528-549.

[0250] Clawson W. P, Levin M. (2023). Endless forms most beautiful 2.0: Teleonomy and the bioengineering of chimaeric and synthetic organisms. Biological Journal of the Linnean Society, 139(4), 457-486.

[0251] Csermely P, Kunsic N., Mendik P, Kerestely M., Farago T., Veres D. V, Tompa P. (2020, Apr). Learning of signaling networks: Molecular mechanisms. Trends in Biochemical Sciences, 45(4), 284-294.

[0252] Dalle Nogare D., Chitnis A. B. (2020, Apr). NetLogo agent-based models as tools for understanding the self-organization of cell fate, morphogenesis and collective migration of the zebrafish posterior Lateral Line primordium. Seminars in Cell & Developmental Biology, 100, 186-198.

[0253] Daly J., Casper D., Farooq M., James A., Khan A., Mulgrew P, Tyebkhan D., Vo B., Rieffel J. (2023). Robustness for free: Quality-diversity driven discovery of agile soft robotic gaits. arXiv:2311.01245.

[0254] Davies J., Levin M. (2023). Synthetic morphology with agential materials. Nature Reviews Bioengineering, 1(1), 46-59.

[0255] Davies J. A., Glykofrydis F. (2020, Jun 30). Engineering pattern formation and morphogenesis. Biochemical Society Transactions, 48(3), 1177-1185.

[0256] De Robertis E. M., Oliver G., Wright C. V. (1989, Apr 21). Determination of axial polarity in the vertebrate embryo: Homeodomain proteins and homeogenetic induction. Cell, 57(2), 189-191.

[0257] Dine E., Gil A. A., Uribe G., Brangwynne C. P, Toettcher J. E. (2018, Jun 27). Protein phase separation provides long-term memory of transient spatial stimuli. Cell systems, 6(6), 655-663. e5.

[0258] Dorfler F., He Z., Belgioioso G., Bolognani S., Lygeros J., Muehlebach M. (2024). Towards a systems theory of algorithms. arXiv: 2401.14029.

[0259] Doursat R., Sanchez C. (2014, Jun). Growing fine-grained multicellular robots. Soft Robotics, 1(2), 110-121.

[0260] Doursat R., Sayama H., Michel O. (2013, Dec). Areview of morphogenetic engineering. Natural Computing, 12(4), 517-535.

[0261] Dussutour A., Latty T., Beekman M., Simpson S. J. (2010, Mar 9). Amoeboid organism solves complex nutritional challenges. Proceedings of the National Academy of Sciences of the United States of America, 107(10), 4607-4611.

[0262] Ebrahimkhani M. R., Levin M. (2021, May 21). Synthetic living machines: A new window on life. iScience, 24(5), 102505.

[0263] Eldar A., Shilo B. Z., Barkai N. (2004, Aug). Elucidating mechanisms underlying robustness of morphogen gradients. Current Opinion in Genetics & Development, 14(4), 435- 439.

[0264] Ellis G. F. R., Noble D., O’Connor T. (2011, Feb 6). Top-down causation: An integrating theme within and across the sciences? Interface Focus, 2(1), 1-3.

[0265] Fan X. J., Sun M. M., Sun L. N., Xie H. (2020, Jun). Ferrofluid droplets as liquid microrobots with multiple deformabilities. Advanced Functional Materials, 30(24), 2000138.

[0266] Farinella-Ferruzza N. (1956). The transformation of a tail into a limb after xenoplastic transformation. Experientia, 12, 304-305.

[0267] Fields C. (2014). Motion, identity and the bias toward agency. Frontiers in Human Neuroscience, 8, 597.

[0268] Fields C., Bischof J., Levin M. (2020, Jan 1). Morphological coordination: A common ancestral function unifying neural and non-neural signaling. Physiology, 35(1), 16-30.

[0269] Fields C., Levin M. (2019, 2019 / 01 / 01). Somatic multicellularity as a satisficing solution to the prediction-error minimization problem. Communicative & Integrative Biology, 12(1), 119-132.

[0270] Fields C., Levin M. (2020, Aug). Scale-free biology: Integrating evolutionary and developmental thinking. BioEssays: News and Reviews in Molecular, Cellular and Developmental Biology, 42(8), Article el 900228.

[0271] Fields C., Levin M. (2022, Jun 12). Competency in navigating arbitrary spaces as an invariant for analyzing cognition in diverse embodiments. Entropy, 24(6), 819.

[0272] Fields C., Levin M. (2023, Jul). Regulative development as a model for origin of life and artificial life studies. Biosystems, 229, 104927.

[0273] Frank S. A. (2013). Evolution of robustness and cellular stochasticity of gene expression. PLoS Biology, 11(6), Article e 1001578.

[0274] Frank S. A. (2018, Sep 25). Measurement invariance explains the universal law of generalization for psychological perception. Proceedings of the National Academy of Sciences of the United States of America, 115(39), 9803-9806.

[0275] Frank S. A. (2019, May 7). Evolutionary design of regulatory control. II. Robust error-correcting feedback increases genetic and phenotypic variability. Journal of Theoretical Biology, 468, 72-81.

[0276] Friston K., Levin M., Sengupta B., Pezzulo G. (2015, Apr 6). Knowing one’s place: Afree-energy approach to pattern regulation. Journal of the Royal Society, Interface, 12(105), 20141383.

[0277] Friston K. J., Wiese W, Hobson J. A. (2020, Apr 30). Sentience and the origins of consciousness: From cartesian duality to Markovian monism. Entropy, 22(5), 516.

[0278] Frith C. D., Metzingher T. (2016). What’s the use of consciousness? How the stab of conscience made us really conscious. In Engel A. K., Friston K., Kragic D. (Eds.), Where’s the action? The pragmatic turn in cognitive science (pp. 193-214). MIT Press.

[0279] Glen C. M., Kemp M. L., Voit E. O. (2019, Mar). Agent-based modeling of morphogenetic systems: Advantages and challenges. PLoS Computational Biology, 15(3), Article el006577.

[0280] Goldstein A. (2021). Algorithms are the matter.

[0281] Gumuskaya G., Srivastava P, Cooper B. G., Lesser H., Semegran B , Garnier S., Levin M. (2024). Motile living biobots self-construct from adult human somatic progenitor seed cells. Advanced Science, 11(4), Article e2303575.

[0282] Hanczyc M. M. (2014, Dec 17). Droplets: Unconventional protocell model with life-like dynamics and room to grow. Life, 4(4), 1038-1049.

[0283] Ho C., Morsut L. (2021, May 11). Novel synthetic biology approaches for developmental systems. Stem Cell Reports, 16(5), 1051-1064.

[0284] Izquierdo E. J., Williams P. L., Beer R. D. (2015). Information flow through a model of the C. Elegans Klinotaxis circuit. PLoS One, 10(10), Article e0140397.

[0285] James S., Jennings G., Kwon Y. M., Stammnitz M., Fraik A., Storfer A., Comte S., Pemberton D., Fox S., Brown B., Pye R., Woods G., Lyons B., Hohenlohe P. A., McCallum H., Siddle H., Thomas F., Ujvari B., Murchison E. P., Jones M., Hamede R. (2019, Oct). Tracingthe rise of malignant cell lines: Distribution, epidemiology and evolutionary interactions of two transmissible cancers in Tasmanian devils. Evolutionary applications, 12(9), 1772-1780.

[0286] James W. (1890). The principles of psychology. H. Holt and Company.

[0287] Jennings H. S. (1906). Behavior of the lower organisms. The Columbia UniversityPress, The Macmillan Company, Agents; etc.

[0288] Kamm R. D., Bashir R., Arora N., Dar R. D., Gillette M. U., Griffith L. G., Kemp M. L., Kinlaw K., Levin M., Martin A. C , McDevitt T. C., Nerem R. M., Powers M. J., Saif T.A., Sharpe J., Takayama S., Takeuchi S., Weiss R., Ye K., Yevick H. G., Zaman M. H. (2018, Dec). Perspective: The promise of multi-cellular engineered living systems. APL Bioengineering, 2(4), 040901.

[0289] Katz Y, Fontana W. (2022, Apr 29). Probabilistic inference with polymerizing biochemical circuits. Entropy, 24(5), 629.

[0290] Katz Y, Goodman N. D., Kersting K., Kemp C., Tenenbaum J. B. (2008).Modeling semantic cognition as logical dimensionality reduction. Proceedings of the Annual Meeting of the Cognitive Science Society, 30. Retrieved from

[0291] Katz Y, Springer M. (2016). Probabilistic adaptation in changing microbial environments. PeerJ, 4, Article e2716.

[0292] Katz Y, Springer M., Fontana W. (2018). Embodying probabilistic inference in biochemical circuits. arXiv: 1806.10161.

[0293] Kauffman S., Clayton P. (2006, Sep). On emergence, agency, and organization.Biology and Philosophy, 21(4), 501-521.

[0294] Kauffman S. A. (1993). The origins of order : Self organization and selection in evolution. Oxford University Press.

[0295] Keijzer F., van Duijn M., Lyon P. (2013, Apr). What nervous systems do: Early evolution, input-output, and the skin brain thesis. Adaptive Behavior, 21(2), 67-85.

[0296] Kelty-Stephen D., Dixon J. A. (2012). When physics is not “just physics”: Complexity science invites new measurement frames for exploring the physics of cognitive and biological development. Critical Reviews in Biomedical Engineering, 40(6), 471-483.

[0297] Khademi M., Taghizadeh Ghavamabadi R., Taghavi M. M., Shabanizadeh A., Shariati-Kohbanani M., Hassanipour M., Taghipour Z. (2019, Jun). The effects of fluoxetine on the human adipose-derived stem cell proliferation and differentiation. Fundamental & Clinical Pharmacology, 33(3), 286-295.

[0298] Koseska A., Bastiaens P. I. (2017, Mar 1). Cell signaling as a cognitive process. The EMBO Journal, 36(5), 568-582.

[0299] Krist K. T, Sen A., Noid W. G. (2021, Oct 28). A simple theory for molecular chemotaxis driven by specific binding interactions. The Journal of Chemical Physics, 155(16), 164902.

[0300] Kuchling F., Fields C., Levin M. (2022, May). Metacognition as a consequence of competing evolutionary time scales. Entropy, 24(5), 601.

[0301] Lagasse E., Levin M. (2023, Sep). Future medicine: From molecular pathways to the collective intelligence of the body. Trends in Molecular Medicine, 29(9), 687-710.

[0302] Lamport L., Shostak R., Pease M. (1982). The byzantine generals problem. ACM Transactions on Programming Languages and Systems, 4(3), 382-401.

[0303] Levin M. (2019, 2019-December-13). The computational boundary of a “self’: Developmental bioelectricity drives multicellularity and scale-free cognition. Frontiers in Psychology, 10(2688), 2688.

[0304] Levin M. (2021). Life, death, and self: Fundamental questions of primitive cognition viewed through the lens of body plasticity and synthetic organisms. Biochemical and Biophysical Research Communications, 564, 114-133.

[0305] Levin M. (2022). Technological approach to mind everywhere: An experimentally-grounded framework for understanding diverse bodies and minds. Frontiers in Systems Neuroscience, 16, 768201.

[0306] Levin M. (2023a, May 19). Bioelectric networks: The cognitive glue enabling evolutionary scaling from physiology to mind. Animal Cognition, 26(6), 1865-1891.

[0307] Levin M. (2023b). Collective intelligence of morphogenesis as a teleonomic process. In Corning P. A., Kauffman S. A., Noble D., Shapiro J. A., Vane-Wright R. I, Pross A. (Eds.), Evolution “on purpose”: Teleonomy in living systems (pp. 175-198). MIT Press.

[0308] Levin M. (2023c, May 8). Darwin’s agential materials: Evolutionary implications of multiscale competency in developmental biology. Cellular and Molecular Life Sciences: CMLS, 80(6), 142.

[0309] Levin M., Pietak A. M., Bischof J. (2019, Mar). Planarian regeneration as a model of anatomical homeostasis: Recent progress in biophysical and computational approaches. Seminars in Cell & Developmental Biology, 87, 125-144.

[0310] Lobo D., Beane W. S., Levin M. (2012, Apr). Modeling planarian regeneration: A primer for reverse-engineering the worm. PLoS Computational Biology, 8(4), Article el 002481.

[0311] Lyon P. (2006, Mar). The biogenic approach to cognition. Cognitive Processing, 7(1), 11-29.

[0312] Lyon P. (2015). The cognitive cell: Bacterial behavior reconsidered. Frontiers in Microbiology, 6, 264.

[0313] Lyon P., Kuchling F. (2021, Mar 15). Valuing what happens: Abiogenic approach to valence and (potentially) affect. Philosophical Transactions of the Royal Society of London - Series B: Biological Sciences, 376(1820), 20190752.

[0314] Manicka S., Harvey I. (2008). ‘Psychoanalysis’ of a minimal agent. Artificial Life XL

[0315] Mathews I., Chang A. L, Devlin L., Levin M. (2023, May 12). Cellular signaling pathways as plastic, proto-cognitive systems: Implications for biomedicine. Patterns (N Y), 4(5), 100737.

[0316] McGivern P (2019, Dec 27). Active materials: Minimal models of cognition? Adaptive Behavior, 28(6), 441-451.

[0317] McMillen P, Oudin M. J., Levin M., Payne S. L. (2021). Beyond neurons: Long distance communication in development and cancer. Frontiers in Cell and Developmental Biology, 9, 739024.

[0318] McShea D. W. (2012, Sep). Upper-directed systems: Anew approach to teleology in biology. Biology and Philosophy, 27(5), 663-684.

[0319] McShea D. W. (2013, Dec). Machine wanting. Studies in History and Philosophy of Biological and Biomedical Sciences, 44(4 Pt B), 679-687.

[0320] McShea D. W. (2016, Aug). Freedom and purpose in biology. Studies in History and Philosophy of Biological and Biomedical Sciences, 58, 64-72.

[0321] McShea D. W., Hordijk W. (2013, Dec). Complexity by subtraction. Evolutionary Biology, 40(4), 504-520.

[0322] Meredith C. H., Moerman P. G., Groenewold J., Chiu Y. J., Kegel W. K., van Blaaderen A., Zarzar L. D. (2020, Dec). Predator-prey interactions between droplets driven by non-reciprocal oil exchange. Nature Chemistry, 12(12), 1136-1142.

[0323] Morgan C. L. (1894). Other minds than ours. In An introduction to comparative psychology (pp. 36-59). Walter Scott, Ltd.

[0324] Nakagaki T. (2001). Smart behavior of true slime mold in a labyrinth. Research in Microbiology, 152(9), 767-770.

[0325] Nakagaki T, Guy R. D. (2007, Dec 11). Intelligent behaviors of amoeboid movement based on complex dynamics of soft matter. Soft Matter, 4(1), 57-67.

[0326] Nanos V., Levin M. (2022, Mar). Multi-scale Chimerism: An experimental window on the algorithms of anatomical control. Cells & Development, 169, 203764.

[0327] Newgreen D. F., Dufour S., Howard M. J., Landman K. A. (2013, Oct 1). Simple rules for a “simple” nervous system? Molecular and biomathematical approaches to enteric nervous system formation and malformation. Developmental Biology, 382(1), 305-319.

[0328] Newman S. A. (2019a, Aug). Inherency and homomorphy in the evolution of development. Current Opinion in Genetics & Development, 57, 1-8.

[0329] Newman S. A. (2019b). Inherency of form and function in animal development and evolution. Frontiers in Physiology, 10, 702.

[0330] Newman S. A. (2023). Form, function, agency: Sources of natural purpose in animal evolution. In Corning P, Kauffman S. A., Noble D., Shapiro J., Vane-Wright R. (Eds ), Evolution ‘on purpose’: Teleonomy in living systems (pp. 199-220). MIT Press.

[0331] Niklas K. J., Wayne R., Benitez M., Newman S. A. (2019, May). Polarity, planes of cell division, and the evolution of plant multicellularity. Protoplasma, 256(3), 585-599.

[0332] Noble D. (2008a, Jan). Claude Bernard, the first systems biologist, and the future of physiology. Experimental Physiology, 93(1), 16-26.

[0333] Noble D. (2008b, Sep 13). Genes and causation. Philosophical Transactions. Series A, Mathematical, Physical, and Engineering Sciences, 366(1878), 3001-3015.

[0334] Noble D. (2009, May). Systems biology, the physiome project and oriental medicine. The Journal of Physiological Sciences: JPS, 59(3), 249-251.

[0335] Noble D. (2010, Mar 13). Biophysics and systems biology. Philosophical Transactions. Series A, Mathematical, Physical, and Engineering Sciences, 368(1914), 1125— 1139.

[0336] Noble D. (2011, May). The aims of systems biology: Between molecules and organisms. Pharmacopsychiatry, 44(Suppl 1), S9-S14.

[0337] Noble D. (2012, Feb 6). Atheory of biological relativity: No privileged level of causation. Interface Focus, 2(1), 55-64.

[0338] Noble D. (2021, Jul). The role of stochasticity in biological communication processes. Progress in Biophysics and Molecular Biology, 162, 122-128.

[0339] Noble R., Noble D. (2018, Oct). Harnessing stochasticity: How do organisms make choices? Chaos, 28(10), 106309.

[0340] Oakey J., Gatlin J. C. (2018, Aug 1). Microfluidic encapsulation of demembranated sperm nuclei in Xenopus egg extracts. Cold Spring Harbour Protocols, 2018(8), 601-606.

[0341] Pascalie J., Potier M., Kowaliw T, Giavitto J. L., Michel 0., Spicher A., Doursat R. (2016, Aug 19). Developmental design of synthetic bacterial architectures by morphogenetic engineering. ACS Synthetic Biology, 5(8), 842-861.

[0342] Pezzulo G., Levin M. (2015, Dec). Re-Membering the body: Applications of computational neuroscience to the top-down control of regeneration of limbs and other complex organs. Integrative Biology: Quantitative Biosciences from Nano to Macro, 7(12), 1487-1517.

[0343] Pezzulo G., Levin M. (2016, Nov). Top-down models in biology: Explanation and control of complex living systems above the molecular level. Journal of the Royal Society, Interface, 13(124), 20160555.

[0344] Pinet K., Deolankar M., Leung B., McLaughlin K. A. (2019, Jul 22). Adaptive correction of craniofacial defects in pre-metamorphic Xenopus laevis tadpoles involves thyroid hormone-independent tissue remodeling. Development, 146(14), devl75893.

[0345] Pinet K., McLaughlin K. A. (2019, Jul 15). Mechanisms of physiological tissue remodeling in animals: Manipulating tissue, organ, and organism morphology. Developmental Biology, 451(2), 134-145.

[0346] Points L. J., Taylor J. W., Grizou J., Donkers K., Cronin L. (2018, Jan 30). Artificial intelligence exploration of unstable protocells leads to predictable properties and discovery of collective behavior. Proceedings of the National Academy of Sciences of the United States of America, 115(5), 885-890.

[0347] Prokopenko M., Boschetti F., Ryan A. J. (2009, Sep-Oct). An information- theoretic primer on complexity, self-organization, and emergence. Complexity, 15(1), 11-28.

[0348] Qiao Y, Li M., Booth R., Mann S. (2017, Feb). Predatory behaviour in synthetic protocell communities. Nature Chemistry, 9(2), 110-119.

[0349] Rahwan I., Cebrian M., Obradovich N., Bongard J., Bonnefon J. F., Breazeal C., Crandall J. W., Christakis N. A., Couzin I. D., Jackson M. O., Jennings N. R., Kamar E., Kloumann I. M., Larochelle H., Lazer D., McElreath R., Mislove A., Parkes D. C., Pentland A., Wellman M. (2019, Apr). Machine behaviour. Nature, 568(7753), 477-486.

[0350] Rankin H. (2015). Transgenic Xenopus Laevis (African clawed toad) tadpole head expressing green neurons. Nikonsmallworld.

[0351] Raup D. M., Michelson A. (1965, Mar 12). Theoretical morphology of the coiled shell. Science, 147(3663), 1294-1295.

[0352] Reid C. R., Beekman M., Latty T., Dussutour A. (2013, Jul-Aug). Amoeboid organism uses extracellular secretions to make smart foraging decisions. Behavioral Ecology, 24(4), 812-818.

[0353] Reid C. R., Latty T., Dussutour A., Beekman M. (2012, Oct 23). Slime mold uses an externalized spatial “memory” to navigate in complex environments. Proceedings of the National Academy of Sciences of the United States of America, 109(43), 17490-17494.

[0354] Repp B. H., Knoblich G. (2007, Apr). Toward a psychophysics of agency: Detecting gain and loss of control over auditory action effects. Journal of Experimental Psychology: Human Perception and Performance, 33(2), 469-482.

[0355] Rosenblueth A., Wiener N., Bigelow J. (1943). Behavior, purpose, and teleology. Philosophy of Science, 10(1), 18-24.

[0356] Rouleau N., Levin M. (2023, Nov). The multiple realizability of sentience in living systems and beyond. eNeuro, 10(11).

[0357] Santorelli M., Lam C., Morsut L. (2019, Oct). Synthetic development: Building mammalian multicellular structures with artificial genetic programs. Current Opinion in Biotechnology, 59, 130-140.

[0358] Serwane F., Mongera A., Rowghanian P, Kealhofer D. A., Lucio A. A., Hockenbery Z. M., Campas O. (2017, Feb). In vivo quantification of spatially varying mechanical properties in developing tissues. Nature Methods, 14(2), 181-186.

[0359] Shin Y, Berry J., Pannucci N., Haataja M. P, Toettcher J. E., Brangwynne C. P. (2017, Jan 12). Spatiotemporal control of intracellular phase transitions using light-activated optoDroplets. Cell, 168(1-2), 159-171. el4.

[0360] Shreesha L., Levin M. (2023, Jan 9). Cellular competency during development alters evolutionary dynamics in an artificial embryogeny model. Entropy, 25(1), 131.

[0361] Stone J. R. (1997, May). The spirit of D’arcy Thompson dwells in empirical morphospace. Mathematical Biosciences, 142(1), 13-30.

[0362] Sultan S. E., Moczek A. P, Walsh D. (2022, Jan). Bridging the explanatory gaps: What can we learn from a biological agency perspective? BioEssays: News and Reviews in Molecular, Cellular and Developmental Biology, 44(1), Article e2100185.

[0363] Suzuki K., Miyazaki M., Takagi J., Itabashi T., Ishiwata S. (2017, Mar 14). Spatial confinement of active microtubule networks induces large-scale rotational cytoplasmic flow.Proceedings of the National Academy of Sciences of the United States of America, 114(11), 2922-2927.

[0364] Teague B. P, Guye P, Weiss R. (2016, Sep 1). Synthetic morphogenesis. Cold Spring Harbor Perspectives in Biology, 8(9). a023929.

[0365] Tero A., Kobayashi R., Nakagaki T. (2007, Feb 21). A mathematical model for adaptive transport network in path finding by true slime mold. Journal of Theoretical Biology, 244(4), 553-564.

[0366] Thome B. C., Bailey A. M., DeSimone D. W, Peirce S. M. (2007, Dec). Agentbased modeling of multicell morphogenic processes during development. Birth Defects Research, Part C: Embryo Today-Reviews, 81(4), 344-353.

[0367] Toda S., Blauch L. R., Tang S. K. Y, Morsut L., Lim W. A. (2018, Jul 13). Programming self-organizing multicellular structures with synthetic cell-cell signaling. Science, 361(6398), 156-162.

[0368] Tononi G., Koch C. (2015, May 19). Consciousness: Here, there and everywhere? [Review], Philosophical Transactions of the Royal Society of London - Series B: Biological Sciences, 370(1668). 20140167.

[0369] Ulanowicz R. E. (2007). Emergence, naturally. Zygon, 42(4), 945-960.

[0370] Vallverdu J., Castro 0., Mayne R., Talanov M., Levin M., Baluska F., Gunji Y, Dussutour A., Zenil H., Adamatzky A. (2018, Mar). Slime mould: The fundamental mechanisms of biological cognition. Biosystems, 165, 57-70.

[0371] Vandenberg L. N., Adams D. S., Levin M. (2012, May). Normalized shape and location of perturbed craniofacial structures in the Xenopus tadpole reveal an innate ability to achieve correct morphology. Developmental Dynamics: An Official Publication of the American Association of Anatomists, 241(5), 863-878.

[0372] Vogel D., Dussutour A. (2016, Dec 28). Direct transfer of learned behaviour via cell fusion in non-neural organisms. Proceedings. Biological sciences, 283(1845). 20162382,

[0373] Vogel D., Dussutour A., Deneubourg J. L. (2018, Dec 21). Symmetry breaking and inter-clonal behavioural variability in a slime mould. Biology Letters, 14(12), 20180504.

[0374] Vogel D., Nicolis S. C., Perez-Escudero A., Nanjundiah V, Sumpter D. J., Dussutour A. (2015, Nov 22). Phenotypic variability in unicellular organisms: From calcium signalling to social behaviour. Proceedings. Biological Sciences, 282(1819). 20152322.

[0375] von Neumann J. (1952). Probabilistic logics and the synthesis of reliable organisms from unreliable components. In Shannon C. E., McCarthy J. (Eds.), Automata Studies (pp. 43-98). Princeton University Press.

[0376] Wang D. (2014). Computing with unreliable resources: Design, analysis and algorithms. Massachusetts Institute of Technology.

[0377] Watson R. A., Buckley C. L , Mills R., Davies A. (2010). Associative memory in gene regulation networks. Artificial Life Conference XII.

[0378] Zabzina N., Dussutour A., Mann R. P., Sumpter D. J., Nicolis S. C. (2014, Dec). Symmetry restoring bifurcation in collective decision-making. PLoS Computational Biology, 10(12), Article el003960.

[0379] Zampetaki A. V, Liebchen B., Ivlev A. V, Lowen H. (2021, Dec 7). Collective self-optimization of communicating active particles. Proceedings of the National Academy of Sciences of the United States of America, 118(49).

[0380] Thus, while the invention has been described above in connection with particular embodiments and examples, the invention is not necessarily so limited, and that numerous other embodiments, examples, uses, modifications and departures from the embodiments, examples and uses are intended to be encompassed by the claims attached hereto.

Claims

CLAIMSWhat is claimed is:

1. A method of modeling a process, comprising: providing a cell set comprising a plurality of cells, wherein each cell within the cell set includes an assigned value and an assigned governing behavior; executing a self-sorting process of the plurality of cells within the cell set based on the assigned value and the assigned governing behavior of each of the plurality of cells, wherein during the self-sorting process the cell set comprises a plurality of intermediate arrangements of the plurality of cells within the cell set; determining an evolution of the intermediate arrangements of the plurality of cells during the self-sorting process; and analyzing the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

2. The method of claim 1, wherein the assigned governing behavior comprises an assigned sensing behavior and an assigned moving behavior, wherein the assigned sensing behavior determines whether each cell in the plurality of cells senses the value of a different cell, and wherein the assigned moving behavior determines how each cell in the plurality of cells moves.

3. The method of claim 2, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of its direct neighbors.

4. The method of claim 2, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells in one direction.

5. The method of claim 2, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells of the plurality of cells.

6. The method of claim 2, wherein the assigned moving behavior allows each cell in the plurality of cells to move in any direction.

7. The method of claim 2, wherein the assigned moving behavior allows each cell in the plurality of cells to move in only one direction.

8. The method of claim 2, wherein the assigned moving behavior allows each cell to move by swapping places with a direct neighbor.

9. The method of claim 2, wherein the assigned moving behavior allows each cell to move by moving to a target location.

10. The method of claim 1, wherein the self-sorting process is parallelized.

11. The method of claim 1 , wherein the self-sorting process does not rely on external instructions.

12. The method of claim 1, wherein executing the self-sorting process comprises executing for a predetermined number of time steps.

13. The method of claim 1, wherein executing the self-sorting process comprises executing until the plurality of cells reaches a target final arrangement.

14. The method of claim 1, wherein the self-sorting process is executed over a series of time steps, and wherein determining the evolution of the intermediate arrangements comprises saving the intermediate arrangement at every time step in the series of time steps.

15. The method of claim 1, wherein the self-sorting process is executed over a series of time steps, and wherein determining the evolution of the intermediate arrangements comprises saving the intermediate arrangement at every nth time step, wherein n is more than 1.

16. The method of claim 1, wherein the cell set comprises a chimeric cell set, comprising cells with different assigned governing behavior.

17. The method of claim 1, wherein a barrier is introduced in the self-sorting process.

18. The method of claim 1, wherein the cell set comprises at least one frozen cell and at least one non-frozen cell, and wherein the frozen cell does not move regardless of its assigned moving behavior.

19. The method of claim 18, wherein the non-frozen cell can move the at least one frozen cell.

20. The method of claim 18, wherein the non-frozen cell cannot move the at least one frozen cell.

21. The method of claim 1, wherein analyzing comprises comparing the final arrangement to a predicted target final arrangement.

22. The method of claim 1, wherein analyzing comprises plotting the evolution of the intermediate arrangements in problem space.

23. The method of claim 22, wherein plotting the evolution in the problem space further comprises displaying a visual representation of the evolution in the problem space.

24. The method of claim 1, wherein analyzing comprises evaluating at least one of monotonicity error, sortedness, or delayed gratification.

25. The method of claim 24, wherein evaluating delayed gratification comprises awarding temporary increases in monotonicity error to achieve gains at a later stage of the evolution.

26. The method of claim 1, wherein analyzing comprises characterizing a problem-solving ability of the cell set.

27. The method of claim 1, wherein analyzing comprises detecting emergent behaviors in the self-sorting process.

28. The method of claim 1, further comprising: designing and applying a new analysis method to determine secondary behaviors of the evolution of the intermediate arrangements and the final arrangement of the plurality of cells.

29. The method of claim 1, wherein the process modeled comprises a biological system.

30. The method of claim 29, wherein the biological system is selected from the group consisting of: physiological, transcriptional, biochemical, developmental, immunological, neurological, metabolic, and molecular processes.

31. The method of claim 29, wherein the analysis further comprises modeling at least one of regeneration or repair of the biological system.

32. The method of claim 29, wherein the analysis further comprises modeling at least one of biomedicine, bioengineering, or synthetic biology systems.

33. The method of claim 1, wherein the process modeled comprises a plurality of swarm robots.

34. The method of claim 1, wherein the process modeled comprises a molecular circuit.

35. The method of claim 1, wherein the process modeled comprises a traditional algorithm.

36. The method of claim 35, wherein the traditional algorithm comprises a traditional sorting algorithm.

37. A method of modeling a process, comprising: providing a cell set comprising a plurality of cells, wherein each cell within the cell set includes an assigned value and an assigned governing behavior; executing a simulation based on the assigned governing behavior of each of the plurality of cells, wherein during the process the cell set comprises a plurality of intermediate arrangements of the plurality of cells within the cell set; determining an evolution of the intermediate arrangement of the plurality of cells during the process; and analyzing the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

38. The method of claim 37, wherein the process does not rely on external instruction.

39. The method of claim 37, wherein the process is executed over a series of time steps.

40. The method of claim 39, wherein the process is executed for a predetermined number of time steps.

41. The method of claim 37, wherein the process comprises executing until the plurality of cells reaches a target final arrangement.

42. The method of claim 37, wherein the process is parallelized.

43. The method of claim 37, wherein analyzing comprises characterizing a problem-solving ability of the cell set.

44. The method of claim 37, wherein analyzing comprises detecting emergent behaviors in the process.

45. The method of claim 37, further comprising: designing and applying a new analysis method to determine secondary behaviors of the evolution of the intermediate arrangements and the final arrangement of the plurality of cells.

46. A system for modeling a process, comprising: a processor in communication with a memory, the memory having stored thereon a set of instructions which, when executed by the processor, cause the processor to: provide a cell set comprising a plurality of cells, wherein each cell within the cell set includes an assigned value and an assigned governing behavior; execute a self-sorting process of the plurality of cells within the cell set based on the assigned value and the assigned governing behavior of each of the plurality of cells, wherein during the self-sorting process the cell set comprises a plurality of intermediate arrangements of the plurality of cells within the cell set; determine an evolution of the intermediate arrangements of the plurality of cells during the sorting process; and analyze the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

47. The system of claim 46, wherein the assigned governing behavior comprises an assigned sensing behavior and an assigned moving behavior, wherein the assigned sensing behavior determines whether each cell in the plurality of cells senses the value of a different cell, and wherein the assigned moving behavior determines how each cell in the plurality of cells moves.

48. The system of claim 46, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of its direct neighbors.

49. The system of claim 47, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells in one direction.

50. The system of claim 47, wherein the assigned sensing behavior allows each cell in the plurality of cells to sense the assigned value of all cells of the plurality of cells.

51. The system of claim 47, wherein the assigned moving behavior allows each cell in the plurality of cells to move in any direction.

52. The system of claim 47, wherein the assigned moving behavior allows each cell in the plurality of cells to move in only one direction.

53. The system of claim 47, wherein the assigned moving behavior allows each cell to move by swapping places with a direct neighbor.

54. The system of claim 47, wherein the assigned moving behavior allows each cell to move by moving to a target location.

55. The system of claim 47, wherein the self-sorting process is parallelized.

56. The system of claim 46, wherein the self-sorting process does not rely on external instructions.

57. The system of claim 46, wherein the processor, when executing the self-sorting process, is further caused by the instructions to execute the self-sorting process for a predetermined number of time steps.

58. The system of claim 46, wherein the processor, when executing the self-sorting process, is further caused by the instructions to execute the self-sorting process until the plurality of cells reaches a target final arrangement.

59. The system of claim 46, wherein the processor, when determining the evolution of the intermediate arrangements, is further caused by the instructions to: execute the self-sorting process is executed over a series of time steps, and save the intermediate arrangement at every time step in the series of time steps.

60. The system of claim 46, wherein the processor, when determining the evolution of the intermediate arrangements, is further caused by the instructions to: execute the self-sorting process is executed over a series of time steps, and save the intermediate arrangement at every nth time step, wherein n is more than 1.

61. The system of claim 46, wherein the cell set comprises a chimeric cell set, comprising cells with different assigned governing behavior.

62. The system of claim 46, wherein a barrier is introduced in the self-sorting process.

63. The system of claim 46, wherein the cell set comprises at least one frozen cell and at least one non-frozen cell, and wherein the frozen cell does not move regardless of its assigned moving behavior.

64. The system of claim 63, wherein the non-frozen cell can move the at least one frozen cell.

65. The system of claim 63, wherein the non-frozen cell cannot move the at least one frozen cell.

66. The system of claim 46, wherein the processor, when analyzing the evolution of the intermediate arrangements, is further caused by the instructions to: compare the final arrangement to a predicted target final arrangement.

67. The system of claim 46, wherein the processor, when analyzing the evolution of intermediate arrangements, is further caused by the instructions to: plot the evolution of the intermediate arrangements in problem space.

68. The system of claim 67, wherein the processor, when plotting the evolution of the intermediate arrangements, is further caused by the instructions to: display a visual representation of the volution in the problem space.

69. The system of claim 46, wherein the processor, when analyzing the evolution of the intermediate arrangements, is further caused by the instructions to: evaluate at least one of monotonicity error, sortedness, or delayed gratification.

70. The system of claim 69, wherein the processor, when evaluating delayed gratification, is further caused by the instructions to: award temporary increases in monotonicity error to achieve gains at a later stage of the evolution.

71. The system of 46, wherein the processor, when analyzing the evolution of the intermediate arrangements, is further caused by the instructions to: characterize a problem-solving ability of the cell set.

72. The system of claim 46, wherein the processor, when analyzing the evolution of intermediate arrangements, is further caused by the instructions to: detect emergent behaviors in the self-sorting process.

73. The system of claim 46, wherein the processor is further caused by the instructions to: design and apply a new analysis method to determine secondary behaviors of the evolution of the intermediate arrangements and the final arrangement of the plurality of cells.

74. The system of claim 46, wherein the process modeled comprises a biological system.

75. The system of claim 74, wherein the biological system is selected from the group consisting of: physiological, transcriptional, biochemical, developmental, immunological, neurological, metabolic, and molecular processes.

76. The system of claim 74, wherein the processor, when analyzing the evolution of intermediate arrangements, is further caused by the instructions to: model at least one of regeneration or repair of the biological system.

77. The system of claim 74, wherein the processor, when analyzing the evolution of intermediate arrangements, is further caused by the instructions to: model at least one of biomedicine, bioengineering, or synthetic biology systems.

78. The system of claim 46, wherein the process modeled comprises a plurality of swarm robots.

79. The system of claim 46, wherein the process modeled comprises a molecular circuit.

80. The system of claim 46, wherein the process modeled comprises a traditional algorithm.

81. The system of claim 80, wherein the traditional algorithm comprises a traditional sorting algorithm.

82. A system for modeling a process, comprising: a processor in communication with a memory, the memory having stored thereon a set of instructions which, when executed by the processor, cause the processor to:provide a cell set comprising a plurality of cells, wherein each cell within the cell set includes an assigned value and an assigned governing behavior; execute a simulation based on the assigned governing behavior of each of the plurality of cells, wherein during the process the cell set comprises a plurality of intermediate arrangements of the plurality of cells within the cell set; determine an evolution of the intermediate arrangement of the plurality of cells during the process; and analyze the evolution of the intermediate arrangements and a final arrangement of the plurality of cells.

83. The system of claim 82, wherein the processor, when executing the simulation, is further caused by the instructions to: execute over a series of time steps.

84. The system of claim 83, wherein the processor, when executing the simulation, is further caused by the instructions to: execute for a predetermined number of time steps.

85. The system of claim 82, wherein the processor, when executing the simulation, is further caused by the instructions to: execute until the plurality of cells reaches a target final arrangement.

86. The system of claim 82, wherein the process is parallelized.

87. The system of claim 82, wherein the processor, when analyzing the evolution of the intermediate arrangements, is further caused by the instructions to: characterize a problem-solving ability of the cell set.

88. The system of claim 82, where the processor, when analyzing the evolution of the intermediate arrangements, is further caused by the instructions to: detect emergent behaviors in the process.

89. The system of claim 82, wherein the processor is further caused by the instructions to: design and apply a new analysis method to determine secondary behaviors of the evolution of the intermediate arrangements and the final arrangement of the plurality of cells.

90. A method of training a machine learning algorithm, comprising: initializing an architecture of the machine learning model; providing training data comprising the output of a modeled process, wherein the modeled process is an agent-based process displaying one or more emergent behaviors; training the architecture of the machine learning model using the training data; storing the trained architecture of the machine learning model.

91. The method of claim 90, wherein the modeled agent-based process is a sorting algorithm.

92. The method of claim 90, wherein the architecture is a non-neuromorphic architecture.

93. The method of claim 90, wherein the architecture incorporates or is based on principles of biology.

94. A method comprising: providing a cell set comprising a plurality of cells, wherein each cell within the cell set includes an assigned value and an assigned governing behavior; executing a process of the plurality of cells within the cell set based on the assigned value and the assigned governing behavior of each of the plurality of cells; determining an evolution of the intermediate arrangements of the plurality of cells during the sorting process; and using a trained algorithm to identify emergent behaviors in the evolution of the intermediate arrangements.

95. The method of claim 94, wherein the process is a self-sorting process.

96. The method of claim 94, wherein the trained algorithm is a machine learning algorithm with a non-neuromorphic architecture.

97. The method of claim 94, wherein the trained algorithm is a machine learning algorithm with an architecture that incorporates or is based on the principles of biology.

Images