The implementation of logic-gate OR within the massive-parallel computational environment simulated by John H. Conway's 'Game of Life' cellular automaton. Another similar codes provide implementations of AND and NOT gates; all the gates are implemented using GoL-N24 Python software. It is a well-known fact that AND, OR, and NOT logic gates are capable to design any processing unit and memory, which are two basic components in the construction of any computer. Animations of all logic gate OR inputs are demonstrated along with the input configurations simulating them (TBA along with the next improved software version).
This program, GoL-N24-v1.0.py, is the open-source, advanced, interactive Python implementation of the 'Game of Life' cellular automaton with extended neighborhood, where 8 neighbors are selected prior the simulation from 24 possible within 5 times 5 large neighborhood area. This gives the total of 735 471 possible combinations of eight neighboring cells. *** The main idea behind this software is to invite everyone to explore a rich space of all neighborhoods, and to find out interesting neighbor-combinations of such generalized GoL rule. It is expected that there might be hidden, within all possible combinations, some neighborhoods that are leading to unique complex emergent structures. *** Recently, we got to know from biological experiments that biological systems are undergoing fairly complex internal computations and decisions, which are mostly and to our surprise based on the application of very simple local evolution/decision rules. This program allows us to study an example of such system with a really huge space of possible neighborhood combinations, which requires a cooperation of the team of researchers and computer science enthusiasts. This cellular automaton can help us to yield valuable insights into the behavior of such systems. *** Be aware that the released version is not allowing loading and saving CA worlds and neighborhood selections (this software upgrade is already developed and is being tested now and released in some weeks from now). Hence, it is up to user to make sure that exactly 8 neighbors are selected (as in the original GoL). For now, interesting configurations can be saved only in graphical form using save option available matplotlib window. *** The implementation of this code is done using numpy Python library in back-end and matplotlib Python library and applying event-driven design of the front-end. Please, report any development hints, mistakes, and errors to the author. Cite program as declared in its preamble. Enjoy the program. (A sample video: https://youtu.be/gc42D2sdL8I ).
The current frontiers in the description and simulation of advanced physical and biological phenomena observed within all scientific disciplines are pointing toward the importance of the development of robust mathematical descriptions that are error resilient. Complexity research is lacking deeper knowledge of the design methodology of processes that are capable to recreate the robustness, which is going to be studied on massive-parallel computations (MPCs) implemented by cellular automata (CA). A simple, two-state cellular automaton having an extremely simple updating rule, which was created by John H. Conway called the ’Game of Life’ (GoL) is applied to simulate and logic gate using emergents. This is followed by simulations of a robust, generalized GoL, which works with nine states instead of two, that is called R-GoL (open-source). extra states enable higher intercellular communication. The logic gate is simulated by the GoL. It is destroyed by injection of random faulty evaluations with even the smallest probability. The simulations of the R-GoL are initiated with random values. several types of emergent structures, which are robust to injection of random errors, are observed for different setups of the R-GoL rule. The GoL is not robust. The R-GoL is capable to create and maintain oscillating, emergent structures that are robust under constant injection of random, faulty evaluations with up to 1% of errors. The R-GoL express long-range synchronization, which is together with robustness facilitated by designed intercellular communication. ..... ...... ..... ..... (Software & video links available at the file Software-and-animation-links-to--r-GoL.txt, see below)
>>> Read the improved, published version with links to the Python software and animations here: https://www.researchgate.net/publication/361818826_Robust_massive_parallel_information_processing_environments_in_biology_and_medicine_case_study <<< ...... The current frontiers in the description and simulation of advanced physical and biological phenomena observed within all scientific disciplines are pointing directly toward the importance of development of robust mathematical descriptions that are error resilient. Complexity research is lacking deeper knowledge of the design methodology of processes that are capable to recreate the robustness. The first, introductory part of the paper provides a concise introduction into this difficult research area to non-specialists. This is followed by the second part, which is focusing on a description, that is providing a certain level of the desired robustness. The first part is describing the basic principles of massive-parallel computations (MPC) that are demonstrated on a simple cellular automaton having an extremely simple updating rule, which was created by John H. Conway: the 'Game of Life' (aka the GoL). This allows us to enter the second, research part dealing with a simple CA rule, which is a generalization of the GoL, that is possessing an increased robustness against errors along with a very interesting set of emergent structures that are expressing longrange synchronization.
<<< The code is a part of the paper: https://www.researchgate.net/publication/361818826_Robust_massive_parallel_information_processing_environments_in_biology_and_medicine_case_study >>> The presented emergent structures were discovered during research on modifications of the 'Game of Life' proposed by John Conway, which are aiming towards discovery of robust emergents, that are immune to randomly injected faulty evaluations. See details in the paper, the link is provided below, where those simulations are presented only in figures. Many scientifically and visually appealing simulation had arisen there, where the observed structures might be interesting to researchers working in biology and other disciplines. Animations are always having a great expressive power, see PNG animations below. Make sure that the viewer can display animated PNG figures! In general, it is observed that emergent structures of various types arise within this specific cellular automaton, all of them are having the period of two. What is surprising is the fact that those structures are long-range correlated, and some of them even turn by ninety degrees. From a certain point of view, we can say that the observed emergents posses a very stable binary behavior that deserves a deeper study. Surprisingly, no moving emergents were observed in this type of cellular automaton. ...... ....... Simulated videos of the code runs are shown at the link: https://www.researchgate.net/publication/357285926_Python_program_simulating_cellular_automaton_r-GoL_that_represents_robust_generalization_of_%27Game_of_Life%27_sample_runs ...... ....... The software belongs to the paper that is available here: https://www.researchgate.net/publication/361818826_Robust_massive_parallel_information_processing_environments_in_biology_and_medicine_case_study/
The whole computer can be simulated using the cellular automaton called the 'Game of the Life' that was designed by John Conway in 1970 using emergent structures of the first order. Presented simulations aim to demonstrate that environments utilizing massive parallel computations (MPC) including living organisms can carry on Turing Machine equivalent computations using elementary, localized computations. In other words, MPCs can evaluate all what is computable. The design of AND logic gate is demonstrated using the following emergent structures: three glider guns and a stopper. The two most left glider guns represent the logical input equal to the logical one when they are present. Otherwise, when missing, they are equal to the logical zero. The rightmost glider gun serves as the control. Computations are carried out by collisions of gliders generated by the respective glider gun. The output goes to the bottom right direction only and only when the inputs 1 and 1 are present. Pathologies: An example of incorrectly shifted glider guns that do not lead to the mutual annihilation of colliding gliders. The next level emergent structures are observed appearing from collisions of the first-level emergents called gliders. The emerging structures are called butterflies. *** To view PNG animations is required a software that is capable to display APNG format! *** Software used: https://www.researchgate.net/publication/355043921_The_simplest_Python_program_simulating_a_cellular_automaton_model_of_a_complex_system_the_'Game_of_Life'/stats
This open-source program serves as an introduction into complex systems modeling. The GoL was developed by John Conway in the 70ies, and it gained a huge attention by both researchers and mathematical enthusiasts. In the past, such programs designed in some higher-level programming language can easily exceed thousands of code lines. This program has about one hundred lines within which defines updating rules, visualize the lattice, and even save the animation. Everyone who is starting to model and understand complex systems modeling will benefit from the simplicity and clarity of the program. The code contains many comments in order to enable newcomers to follow in detail all its functions and to modify them according to their own preferences and needs. The chosen approach allows non-specialists along with all those who just want to passively understand the methodology to dive into this non-sequential way of thinking quite easily. The way of cellular automata modeling is very tightly related to massively parallel thinking, which is a bit tricky to newcomers. All what must be understood about those models is that the surrounding world (CA lattice) is observed and interacted with from each cell independently. This means that the rule of thumb of all CA modeling is to update all variables within the updated cell centripetally, and do not change any values outside it. Another important feature of CA modeling is the necessity to work with the old and new layers of the updated lattice, which are periodically switched. This allows us to overcome the unsolvable problem of the sequential updating of all cells within just one lattice, when it would be used instead. In such case, cells would be updated sequentially, one-by-one: cells containing new and old data will become mixed up in the same lattice. This is really something that we do not want to have in any CA model in the first place. Each initial configuration must be inserted into the Python program manually within its beginning: coordinates defines the live cells having the value equal to one. Complicated configurations can be quite difficult to insert because the loading of the initial configuration into the program was sacrificed due to the extra effort to keep it simple and easy to understand. Literature and all necessary programming resources are listed in the README file. This program is designed as the methodical one. When the program is used, it must be cited as stated in the 'README-GoL.txt' file along with one of the recommended optional papers.
Cellular automaton models of complex systems (CSs) are gaining greater popularity; simultaneously, they have proven the capability to solve real scientific and engineering applications. To enable everybody a quick penetration into the core of this type of modeling, three real applications of cellular automaton models, including selected open source software codes, are studied: laser dynamics, dynamic recrystallization (DRX) and surface catalytic reactions. The paper is written in a way that it enables any researcher to reach the cutting edge knowledge of the design principles of cellular automata (CA) models of the observed phenomena in any scientific field. The whole sequence of design steps is demonstrated: definition of the model using topology and local (transition) rule of a cellular automaton, achieved results, comparison to real experiments, calibration, pathological observations, flow diagrams, software, and discussions. Additionally, the whole paper demonstrates the extreme expressiveness and flexibility of massively parallel computational approaches compared to other computational approaches. The paper consists of the introductory parts that are explaining CSs, self-organization and emergence, entropy, and CA. This allows readers to realize that there is a large variability in definitions and solutions of this class of models. >>> <<< (Remark: Open-source software included).
This review aims mainly to all professionals from the fields of clinical medicine, biomedical and experimental research. It targets to deliver a quick starting overview and basic understanding of Complex Systems (CSs) with a citation apparatus enabling to efficiently reach the cutting-edge knowledge and applications. This paper has two main objectives. It builds the core information of CSs that is explained on a carefully selected example called the "Game of Life", which expresses self-organization and emergence. The second and most important objective is to provide a wide list of CSs computational methods enabling everybody to achieve a basic overview of all major methods applied in experimental and clinical medicine. These methods are easy to implement in any field of the interest.
This paper continues in the previous research focussed to two simple ques-tions. The first one reads: "What is the influence of anisotropy of computational lattice on simulations of boundary movement?" where grain boundary movement typically appears in simulations of grain boundary migration and static/dynamic recrystallization. The sec-ond question reads: "How is the computational anisotropy related to natural anisotropy of the material lattice itself?" This study is focussed on the influence of change of the com-putational algorithm and/or lattice on the grain boundary movement. Two algorithms, the majority rule and the simple modification of the Monte Carlo method for two different lattices – namely square and hexagonal one – are used.
It is well known that many of macroscopic properties of materials undergoing dynamic recrystallization are determined by their microstructure. Despite a large experimental and theoretical effort, it is not possible to predict in a satisfactory way the evolution of microstructure with sufficient precision. The reason is that we are dealing with a complex system where the basic components are simple but many of such simple components can act synergetically. Unfortunately, analytical solutions are not available at the present time. Therefore, we look for a method which can fill the gap between macroscopic and atomistic scale. The Cellular Automata Theory used in this work provides such a method. Basically, this method maps microstructure into a discrete space and defines local interactions between elements of this discrete space. The aim of this work is to formulate a cellular automaton model of dynamic recrystallization with special attention to so-called critical experiments. We start by an overview of experiments on static and dynamic recrystallization. Some classic models and most of the cellular automata models of static and dynamic recrystallization are reviewed as well. A new cellular automaton model with probabilistic grain boundary movement is proposed. The influence of the initial mean grain size, evolution laws of dislocation density, and nucleation rate on deformation curves are studied. The attention is focused to the explanation of several critical experiments, e.g. constant strain rate test and strain rate change test. It is recognized that evolution of the mean grain size represents the complementary information to the evolution of stress. A strong dependence of deformation curves on the initial mean grain size and nucleation rate is detected. Such critical experiments as strain rate change test and constant strain rate test are reproduced. The model shows a weak sensitivity of the material on the type of the evolution law of dislocation density. Globular shape of grains was obtained through probabilistic movement of grain boundary segments. This work shows that a deeper study of every particular process can bring substantial insight into the recrystallization behaviour and related processes as, for example, grain growth. A tentative list of the future aims of research in the field of dynamic recrystallization modelled by cellular automata is present at the end of this work.
Properties of the model performing dynamic mesh partitioning into computationally equivalent mesh parts on regular square lattices using the diffusion controlled cellular automaton (DCCA) are studied. Every processor has assigned a domain seed at the beginning of each simulation--seeds grow into competing domains having migrating boundaries. Computations having different number of seeds and/or different boundary topologies are compared. Additionally, it is demonstrated that new seeds could be inserted dynamically during simulation--it mimics dynamic inserting of new processors of a supercomputer operating above given mesh. Solutions are dynamically stable configurations having equal domain sizes.
A model performing mesh partitioning into computationally equivalent mesh parts on regular square lattices using a diffusion controlled cellular automaton (DCCA) is proposed and studied in this article. Every processor has assigned a domain seed at the beginning of a simulation. Algorithm works with growth of seeds and migration of domain borders, the later is triggered when the difference of diffusive agents on both sides of a border exceeds a given threshold. The model is built using self-organization principles ensuring convergence. Solutions are dynamically stable configurations achieved from any initial configuration.
Dear Colleaugues, There was a proposal of a researcher who asked me to write down a paper which will more or less extend the poster (link bellow) published at ICCB 2016 in Prague. This all happened by an accident. I did not like to come at a conference without some presentation. Hence, I did quickly put the ideas that are resonating in my head for years on that poster to allow other researchers to benefit from it. Surprisingly, this poster is getting a great deal of attention. Therefore, I am thinking about to write down a review (prescription) how to design sel-organizing and emergennt systems with a rich example aparatus. If you like the idea then wisit the poster and let there a comment about it (bellow the poster). The whole project is meant as a service to the community of biological and medical researchers who would like to know more but have no time to study mathematics and programming in depth. All the best at your research, Jiri https://www.researchgate.net/publication/305751754_COMPLEX_SYSTEMS_AND_THEIR_USE_IN_BIOMEDICAL_RESEARCH_MATHEMATICAL_CONCEPTS_OF_SELF-ORGANIZATION_AND_EMERGENCE
That is really great that there are new antibiotics that can fight against resistant strains. But there is always but: 1) It is well a known fact that 'bugs' can become resistant within even months, 2) Nature does it differently: it is a constant evolutionary game of weapons, one side attacks with a new weapon and the other develops a modified anti-weapon, 3) The question is how long it take to us, humans, to adopt the same strategy and start to develop adaptive (evolutionary) medicine? 4) Any ideas, hints, and proposals are welcomed. 5) This discussion can promote the strategical point of view on the research of new drugs. PS This structured question was motivated by the post presented in https://plus.google.com/+JiříKrocCS/posts/MBfeR5gqQJk
In cooperation with my student Jakub Tkac, a student from the Czech Technical University, we ported the old code simulating dynamic recrystallization (implemented in Cellular/Cellang) into a new software version (C++ & Qt). Details can be found in the following links: https://www.researchgate.net/publication/317013011_Self-Organization_Video_Sequence_Depicting_Numerical_Experiments_with_Cellular_Automaton_Model_of_Dynamic_Recrystallization_with_code_link https://www.researchgate.net/publication/316989956_Cellular_Automaton_Simulation_of_Dynamic_Recrystallization_Introduction_into_Self-Organization_and_Emergence Our interest is to find out what you find out good and bad on this software and how it can help you understand modeling of complex systems using cellular automata. Your answers will help to develop future examples more adjusted to yours needs. Enjoy the source of the code and video provided above. Jiri Kroc & Jakub Tkac PS For details and other questions and work see the project https://www.researchgate.net/project/Basics-Modeling-and-Understanding-of-Complex-Systems where other question as "New drug development strategy: war of weapons" and information are provided.
This video presents numerical experiments done by the software "Cellular Automaton Simulation of Dynamic Recrystallization: Introduction" (https://www.researchgate.net/publication/316989956_Cellular_Automaton_Simulation_of_Dynamic_Recrystallization_Introduction). This software was developed by Jakub Tkac according to the original software that was programmed in the language Cellular/Cellang (by Jiri Kroc), which is not anymore maintained. This lead to the decision to write down a new version of the software for all who would like to study it. Everybody is welcomed to study provided software, and use it for research and non-commercial purposes. You should cite this software (above) and the original research provided bellow. * The Ph.D. thesis of the original research: https://www.researchgate.net/publication/311733496_Simulation_of_Dynamic_Recrystallization_by_Cellular_Automata * The paper containing the main results from the Ph.D. thesis: https://www.researchgate.net/publication/225670793_Application_of_Cellular_Automata_Simulations_to_Modeling_of_Dynamic_Recrystallization * [Link to the identical video on youtube: https://youtu.be/_v0tQnbLW-4 ] *** Link do the Bachelor Thesis of Jakub Tkac: https://www.researchgate.net/publication/317236033_Design_and_Implementation_of_Cellular_Automaton_Simulating_Dynamic_Recrystallization_in_czech
The purposes of this software are manifold: (i) It serves as an introduction to the modeling of dynamic recrystallization by cellular automata and to complex systems modeling by cellular automata in general. (ii) There is a big demand to have in hands an open-source software that can serve as an example to similar software that might be developed in various scientific fields. (iii) Everybody is welcomed to develop its non-commercial applications in various scientific fields using this template. (iv) The software was originally developed by JK during his Ph.D. studies using software called Cellular/Cellang that is not maintained anymore. (v) JT developed software according to the best software engineering practice. (vi) It and its descendants can be used to study complex systems modeling in various scientific disciplines including biosciences, biology, and medicine. This software was developed during bachelor studies of JT and published as his bachelor thesis project. PS The work when used must be properly cited according to requirements given in the software. >>><<< Remark: Introduction to Complex Systems Modelling by Cellular Automata can be found at https://www.researchgate.net/publication/225413484_Introduction_to_Modeling_of_Complex_Systems_Using_Cellular_Automata (this provides the necessary background for the understanding of the software) >>><<< Link do the Bachelor Thesis of Jakub Tkac: https://www.researchgate.net/publication/317236033_Design_and_Implementation_of_Cellular_Automaton_Simulating_Dynamic_Recrystallization_in_czech >>><<< Link to a video depicting a run of the code https://www.researchgate.net/publication/317013011_Self-Organization_Video_Sequence_Depicting_Numerical_Experiments_with_Cellular_Automaton_Model_of_Dynamic_Recrystallization_with_source-code_link >>><<< Link to a quick physical & computational introduction https://www.researchgate.net/publication/338019707_BUILDING_EFFICIENT_COMPUTATIONAL_CELLULAR_AUTOMATA_MODELS_OF_COMPLEX_SYSTEMS_BACKGROUND_APPLICATIONS_RESULTS_SOFTWARE_AND_PATHOLOGIES
The animation, representing a simulation generated by the Qt front-end, of the program published at the RG-page under name "Design and Implementation of Cellular Automaton Simulating Domain Growth - Source Code" (https://www.researchgate.net/publication/303805779_Design_and_Implementation_of_Cellular_Automaton_Simulating_Domain_Growth_-_Source_Code), which was developed within the Martin Muzak's thesis "Design and Implementation of Cellular Automaton Simulating Domain Growth" (https://www.researchgate.net/publication/303549530_Design_and_Implementation_of_Cellular_Automaton_Simulating_Domain_Growth). The thesis is based on the paper: "Diffusion Controlled Cellular Automaton Performing Mesh Partitioning" (https://www.researchgate.net/publication/220977420_Diffusion_Controlled_Cellular_Automaton_Performing_Mesh_Partitioning?ev=prf_pub).
The bachelor thesis is focused to design and implementation of the Qt graphical user interface of cellular automaton simulating domain decomposition by employing a self-organization principle. The main goal is to enable everybody to achieve a better understanding of complex systems modelling principles, which are explained on an example dealing with domain decomposition, and simultaneously to stimulate their own research motivated by the provided C++ code. The application itself offers a freedom in the configuration of simulation and allows each user to define an arbitrary number of the initial locations of all domains and their respective growth factors. During the run of each simulation, a user can save the image into the file and control the run of the simulation. The application is free to use or modify under given conditions. User’s and programmer’s manual are located in the appendix of the bachelor’s thesis. The application is compatible with Windows and Linux operating systems. The text of the thesis and instruction how to execute the application is available on https://www.researchgate.net/publication/303549530_Design_and_Implementation_of_Cellular_Automaton_Simulating_Domain_Growth
This is a quick introduction to the topic in an animated form. It gives you the impression of a living thing. The original idea of this software arrived when the author was thinking about cell growth. Similar effects are observed in all living organisms. For details, see the paper, book chapter, and software that is open under the GPL license. (To visualize the animated GIF, specialized picture visualizing tools must be used; otherwise, a static picture of eight seeds that do not grow is seen.)
The theory of Complex Systems (CSs) is offering new mathematical concepts of definition, description, and evaluation of biological systems. A number of vital mathematical descriptions that are constantly developing within CSs increasingly assist biomedical research. The main goal of the presentation is to increase awareness of medical researchers about novel CSs computational methods and their applicability in biology. We can say that modern mathematical research is developing novel computational tools that are comparable to classical hardware devices such as are, e.g., microscope, mass & light spectroscopy, and that have no vital alternative to them. The poster got a continuation in the paper "Complex Systems and Their Use in Medicine: Concepts, Methods and Bio-Medical Applications" [https://www.researchgate.net/publication/330546521_Complex_Systems_and_Their_Use_in_Medicine_Concepts_Methods_and_Bio-Medical_Applications ]. >>>>> (Remark: More details on complexity in the projects of the author.) <<<<<
..... The INTRODUCTION into the one of the best selling book in the field (over 30k ebooks sold) ..... Abstract: Since the sixteenth century there have been two main paradigms in the methodology of doing science. The first one is referred to as “the experimental” paradigm. During an experiment we observe, measure, and quantify natural phenomena in order to solve a specific problem, answer a question, or to decide whether a hypothesis is true or false. The second paradigm is known as “the theoretical” paradigm. A theory is generally understood as a fundamental, for instance logical and/or mathematical explanation of an observed natural phenomenon. Theory can be supported or falsified through experimentation. Link to the online version of the book: http://www.springer.com/gp/book/9783642122026
>>> The best seller in the field - over 30k ebooks sold as 2018. <<< From the Back Cover: Deeply rooted in fundamental research in Mathematics and Computer Science, Cellular Automata (CA) are recognized as an intuitive modeling paradigm for Complex Systems. Already very basic CA, with extremely simple micro dynamics such as the Game of Life, show an almost endless display of complex emergent behavior. Conversely, CA can also be designed to produce a desired emergent behavior, using either theoretical methodologies or evolutionary techniques. Meanwhile, beyond the original realm of applications - Physics, Computer Science, and Mathematics – CA have also become work horses in very different disciplines such as epidemiology, immunology, sociology, and finance. In this context of fast and impressive progress, spurred further by the enormous attraction these topics have on students, this book emerges as a welcome overview of the field for its practitioners, as well as a good starting point for detailed study on the graduate and post-graduate level. The book contains three parts, two major parts on theory and applications, and a smaller part on software. The theory part contains fundamental chapters on how to design and/or apply CA for many different areas. In the applications part a number of representative examples of really using CA in a broad range of disciplines is provided - this part will give the reader a good idea of the real strength of this kind of modeling as well as the incentive to apply CA in their own field of study. Download or buy at Springer: http://www.springer.com/gp/book/9783642122026