system

Abstract

We provide the system. [Solution] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem, A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate, A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms, A system including means for performing a simulation at predetermined time intervals to mimic the passage of time.

Description

Technical Field

[0001] The technology of the present disclosure relates to a system.

Background Art

[0002] Patent Document 1 discloses a persona chatbot control method performed by at least one processor, comprising steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In conventional ecosystem simulation systems, it has been difficult to accurately mimic fluctuations in the population of organisms in real time. In particular, dynamic simulations that take into account fluctuations in birth and death rates are technically complex, and there are also many problems associated with the display and management thereof. Furthermore, while realistically mimicking the passage of time, it is required to represent interactions between organisms of different species on the system. A solution to this problem is sought.

Means for Solving the Problems

[0005] To solve the above problems, the present invention provides a system having a computer program that manages multiple organisms to mimic an ecosystem and simulates changes in the population of each organism. Specifically, it includes means for calculating fluctuations in the population of each organism based on birth rate and mortality rate, means for displaying the year-to-year changes in the population of each organism, and means for running simulations at predetermined time intervals to mimic the passage of time. Furthermore, by providing means for randomly setting birth rate and mortality rate to more realistically mimic year-to-year changes, and means for each organism to include different species and separately track changes in the population between species, the present invention realizes dynamic and realistic ecosystem modeling. In this way, the present invention can effectively solve the problems of the prior art.

[0006] An "ecosystem" refers to a complex and interdependent system formed by different species of organisms and the natural environment in which they interact.

[0007] A "living organism" refers to an individual that possesses life, each belonging to a specific species, and carrying out life activities such as reproduction, growth, and death.

[0008] "Population size" refers to the number of organisms of the same species present within a given area or group.

[0009] "Simulation" refers to a method of replicating real-world systems and processes and reproducing their behavior through calculations and modeling.

[0010] A "computer program" refers to software that includes a series of instructions or procedures executed on an electronic computer.

[0011] "Birth rate" refers to the proportion of new births within a particular population during a specific period.

[0012] "Mortality rate" refers to the proportion of individuals that die within a particular population during a specific period.

[0013] A "fiscal year" refers to a period of time that spans one year, and usually refers to a calendar year or a fiscal year.

[0014] "Time interval" refers to a fixed unit of time set to simulate the passage of time in a simulation.

[0015] "Random" refers to the property of being selected randomly without any specific rules or predictions.

[0016] "Different species" refers to groups of organisms that belong to different taxonomic groups in biological classification.

[0017] "Interaction" refers to the relationship in which multiple organisms or elements influence each other.

[0018] "Tracking" refers to the act of continuously observing and recording the state or changes of a specific object. [Brief explanation of the drawing]

[0019] [Figure 1] This is a conceptual diagram showing an example of the configuration of a data processing system according to the first embodiment. [Figure 2] This is a conceptual diagram showing an example of the essential functions of a data processing device and a smart device according to the first embodiment. [Figure 3] This is a conceptual diagram showing an example of the configuration of a data processing system according to the second embodiment. [Figure 4] This is a conceptual diagram showing an example of the main functions of a data processing device and smart glasses according to the second embodiment. [Figure 5] This is a conceptual diagram showing an example of the configuration of a data processing system according to the third embodiment. [Figure 6] This is a conceptual diagram showing an example of the main functions of a data processing device and a headset-type terminal according to the third embodiment. [Figure 7] This is a conceptual diagram showing an example of the configuration of a data processing system according to the fourth embodiment. [Figure 8]It is a conceptual diagram showing an example of the main functions of a data processing device and a robot according to the fourth embodiment. [Figure 9] It shows an emotion map to which a plurality of emotions are mapped. [Figure 10] It shows an emotion map to which a plurality of emotions are mapped. [Figure 11] It is a sequence diagram showing the processing flow of the data processing system in Example 1. [Figure 12] It is a sequence diagram showing the processing flow of the data processing system in Application Example 1. [Figure 13] It is a sequence diagram showing the processing flow of the data processing system in Example 2 when an emotion engine is combined. [Figure 14] It is a sequence diagram showing the processing flow of the data processing system in Application Example 2 when an emotion engine is combined.

Mode for Carrying Out the Invention

[0020] Hereinafter, an example of an embodiment of a system according to the technology of the present disclosure will be described according to the accompanying drawings.

[0021] First, the language used in the following description will be explained.

[0022] In the following embodiments, a processor with a reference number (hereinafter simply referred to as "processor") may be a single arithmetic unit or a combination of a plurality of arithmetic units. Further, the processor may be a single type of arithmetic unit or a combination of a plurality of types of arithmetic units. Examples of arithmetic units include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), and the like.

[0023] In the following embodiments, signed RAM (Random Access Memory) is a memory that temporarily stores information and is used as work memory by the processor.

[0024] In the following embodiments, the signed storage is one or more non-volatile storage devices that store various programs and various parameters. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), or magnetic tapes.

[0025] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0026] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0027] [First Embodiment]

[0028] Figure 1 shows an example of the configuration of the data processing system 10 according to the first embodiment.

[0029] As shown in Figure 1, the data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0030] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0031] The smart device 14 comprises a computer 36, a reception device 38, an output device 40, a camera 42, and a communication interface 44. The computer 36 comprises a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The reception device 38, output device 40, and camera 42 are also connected to the bus 52.

[0032] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0033] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0034] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

[0035] Figure 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0036] As shown in Figure 2, in the data processing device 12, a specific processing is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" related to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0037] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0038] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0039] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0040] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0041] The following describes specific embodiments of the system of the present invention.

[0042] System initialization

[0043] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0044] Adding organisms

[0045] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0046] Start of simulation

[0047] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0048] Specific example

[0049] For example, when running a 10-year simulation, it would look like this:

[0050] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0051] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0052] display

[0053] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0054] System shutdown

[0055] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0056] The above describes specific embodiments of the present invention. This system allows users to perform realistic simulations of ecosystem fluctuations and is useful for academic research and educational purposes.

[0057] The following describes the processing flow.

[0058] Step 1:

[0059] The server executes the program and calls the main function to begin program initialization.

[0060] Step 2:

[0061] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0062] Step 3:

[0063] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0064] Step 4:

[0065] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0066] Step 5:

[0067] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0068] Step 6:

[0069] The server starts a loop and sequentially executes the following processes for each year.

[0070] Step 7:

[0071] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0072] Step 8:

[0073] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0074] Step 9:

[0075] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0076] Step 10:

[0077] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0078] Step 11:

[0079] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0080] Step 12:

[0081] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0082] (Example 1)

[0083] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0084] In ecosystem simulations, accurately replicating the population fluctuations of individual organisms in a way that closely resembles real-world environments is a challenging task. Furthermore, it is necessary to visually observe in real-time how specific organisms interact within different ecosystems and how their populations fluctuate. Additionally, reproducing year-to-year fluctuations through more realistic simulations is crucial. Conventional systems lack the means to randomly set birth and death rate fluctuations and to graphically display the results; therefore, effective methods to address these challenges are needed.

[0085] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0086] In this invention, the server includes means for initializing classes for calculating fluctuations in the population of organisms, means for calculating fluctuations in population based on birth and death rates, and means for displaying changes in population year by year. This allows users to visually check fluctuations in the population of animals in an ecosystem in real time, and furthermore, to more realistically simulate year by year changes in the ecosystem based on randomly set birth and death rates.

[0087] An "ecosystem" is a system that includes multiple organisms that survive and interact with each other within a specific environment.

[0088] "Simulation" is the process of recreating a real environment or situation on a computer, mimicking it.

[0089] "Living organisms" refer to entities that possess life, including populations of animals, plants, and microorganisms managed within the simulation.

[0090] "Population size" refers to the total number of individuals belonging to a particular group of organisms.

[0091] "Population fluctuation" refers to the phenomenon in which the number of individuals of an organism increases or decreases over time.

[0092] "Birth rate" refers to the rate at which new individuals are added to an organism through reproduction within a given period.

[0093] "Mortality rate" refers to the rate at which the number of individuals decreases due to death within a certain period of time.

[0094] A "fiscal year" refers to a unit of time used to observe and record fluctuations in the population size of organisms.

[0095] "Graphical display" refers to methods of visually representing data and results, such as expressing them in the form of graphs and charts.

[0096] In computer programs, a "class" refers to a blueprint for creating a specific object and defining the data and methods related to that object.

[0097] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system includes a computer program for calculating population fluctuations based on the birth and death rates of organisms and displaying these fluctuations year by year. Furthermore, it includes means for performing the simulation at predetermined time intervals to mimic the passage of time.

[0098] System initialization

[0099] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0100] Adding organisms

[0101] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0102] Start of simulation

[0103] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0104] display

[0105] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0106] System shutdown

[0107] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally.

[0108] Specific example

[0109] For example, when running a 10-year simulation, it would look like this:

[0110] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0111] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0112] Example of a prompt

[0113] The following is an example of an input prompt using a generative AI model.

[0114] "I would like to run a simulation of rabbit and fox population fluctuations. In the first year, the rabbit population is 100 and the fox population is 20. Randomly set the birth and death rates for each species and display the simulation results for 10 years."

[0115] This system allows users to simulate realistic ecosystem fluctuations and utilize them for academic research and educational purposes. Specific implementations of this system enable users to efficiently advance their ecosystem research.

[0116] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0117] Step 1: System Initialization

[0118] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. In this step, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. Inputs include initial setup information from the user (e.g., the types of organisms to include in the simulation and their initial populations). Outputs include instances of the initialized Ecosystem and Animal classes.

[0119] Step 2: Adding organisms

[0120] The user specifies the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they provide the species name and initial population as input. The server creates an instance of the Animal class based on this information and adds it to the organism list of the Ecosystem class. Specifically, the user inputs the type of organism and initial population through the terminal interface, and the server receives this information and saves it to the database. The output is an updated list of organisms in the ecosystem.

[0121] Step 3: Start the simulation

[0122] The user specifies the simulation period (number of years) and starts the simulation. The input is the number of years for the simulation. The terminal sends this information to the server. The server performs the following calculations for each year:

[0123] For each year, randomly set birth and death rates are generated for each organism.

[0124] The new population size is calculated by applying the birth rate and death rate to the current population size.

[0125] Specifically, the formula is "New population = Old population + (Old population × Birth rate) - (Old population × Death rate)". The output is the calculated new population, which is set as the initial state for the next year.

[0126] Step 4: Saving the calculation results for each fiscal year

[0127] At the end of each fiscal year, the server records the calculation results. The input is the new population count for that fiscal year. The server saves this data and carries it over to the next fiscal year. Specifically, the population count data for each fiscal year is saved to the database. The output is the initial data used to start the simulation for the next fiscal year.

[0128] Step 5: Displaying the results

[0129] The server sends the results to the terminal once it has finished calculating the population size of organisms for each year. The input is the population size data for each year. The terminal receives this data and displays it visually. Specifically, it uses a graph generation library (e.g., Matplotlib) to plot the changes in the organism population as a graph. The output is a graph or text format that the user can visually review.

[0130] Step 6: Shut down the system

[0131] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally. The input is a signal indicating simulation completion. The server saves the final results to a text file or database and shuts down the system. The output is the saved simulation result data.

[0132] (Application Example 1)

[0133] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0134] Traditional inventory management systems struggled to accurately predict the replenishment timing for each product, leading to a high likelihood of stockouts and excess inventory. Furthermore, they had difficulty reflecting real-time fluctuations in inventory levels over time, resulting in reduced operational efficiency.

[0135] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0136] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for performing simulations at predetermined time intervals to mimic the passage of time, means for simulating fluctuations in the inventory of each product based on product replenishment and consumption rates, and means for displaying changes in inventory at physical stores and issuing replenishment instructions. This makes it possible to predict inventory levels in a way that closely resembles reality, allows for timely replenishment instructions, and improves the efficiency of inventory management.

[0137] "Mimicking ecosystems" means using computer programs to reproduce the interrelationships and population fluctuations of biological groups that exist in natural environments.

[0138] "Managing multiple organisms" means maintaining data such as population size, birth rates, and mortality rates for different species or types of organisms, and processing and managing this data appropriately.

[0139] "Simulating population changes" means calculating and virtually reproducing how the population size of an organism fluctuates over time.

[0140] "Birth rate" refers to the proportion of newborns within a specific period of time.

[0141] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0142] "Displaying year-by-year changes" means outputting the fluctuations in the number of organisms or products, or the inventory levels, for each year in a way that can be visually confirmed.

[0143] "Replenishment rate" refers to the percentage of products added within a certain period.

[0144] "Consumption rate" refers to the percentage of products that are consumed or reduced within a certain period of time.

[0145] "Simulating inventory fluctuations" means calculating and virtually reproducing how the inventory levels of products in a physical store change over time.

[0146] "Issuing a replenishment order" means that when the inventory level falls below a certain threshold, the system outputs an instruction to secure additional inventory.

[0147] This invention is a system that combines inventory management in physical stores with ecosystem simulation, and aims to predict and manage the inventory levels of physical stores in real time. Specific embodiments of this system are described below.

[0148] Hardware and software to be used

[0149] Hardware: General-purpose computers and servers (Windows, macOS®, Linux®)

[0150] Software: Python 3.x, database management system

[0151] System initialization

[0152] The server first initializes classes for ecosystem management and inventory management. The "Ecosystem" class manages organisms within the ecosystem, and the "Inventory" class manages the inventory of goods. The "Animal" class corresponds to each organism and item, and maintains the number of individuals and inventory levels.

[0153] Add product

[0154] Users add products to the system. For example, to manage the inventory of "apples" and "oranges," users create instances of the "Product" class for each and add them to the "Inventory" class.

[0155] Start of simulation

[0156] The terminal starts a simulation over a specified period (for example, 10 years, year by year). The server calculates the inventory level of each product using randomly set replenishment and consumption rates for each year. As a result, the inventory levels of the products increase or decrease year by year and are displayed in real time.

[0157] Data processing and data calculation

[0158] The server maintains data such as the initial stock quantity, replenishment rate, and consumption rate for each product, and calculates the stock quantity annually. By using randomly set replenishment and consumption rates for each year, it realistically simulates fluctuations in inventory levels in physical stores. These inventory fluctuations are also displayed through a console and a graphical user interface.

[0159] Examples of prompt statements

[0160] When adding a new product to the system using a generative AI model, use the following prompt message.

[0161] "Please enter the name of the new product and the initial stock quantity."

[0162] For example, if "Bananas, 200" is returned, the system will add the product based on that information.

[0163] Examples

[0164] For example, here is a specific example of a 10-year simulation:

[0165] 1. First year: The initial stock of apples is assumed to be 100. Assuming a server replenishment rate of 15% and a consumption rate of 10%, the stock will increase to 115.

[0166] 2. Year 2: The server randomly sets a new replenishment rate of 20% and a consumption rate of 5%, increasing the inventory to 138 units. Continue the simulation by applying different replenishment and consumption rates each year.

[0167] This allows for realistic inventory management simulations in physical stores, enabling timely replenishment instructions.

[0168] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0169] Step 1:

[0170] The server initializes classes for ecosystem management and inventory management. Specifically, it creates the "Ecosystem" and "Inventory" classes and generates instances of the corresponding "Animal" and "Product" classes. At this stage, the initial data specified by the user is entered, and the system is configured based on that initial data. The output is a message indicating that the system's initial state is complete.

[0171] Step 2:

[0172] Users add products to the system. Specifically, users input product information (name and initial stock quantity), and an instance of the "Product" class is generated based on that data and added to the "Inventory" class. The input is the product name and initial stock quantity, and the output is the newly added product object.

[0173] Step 3:

[0174] The terminal sends a command to the server to start the simulation. The server starts simulating inventory levels over a specified period (e.g., 10 years). The input is information about the simulation period, and the output is a message indicating the progress of the simulation.

[0175] Step 4:

[0176] The server calculates the inventory quantity for each product using randomly set replenishment and depletion rates for each year. Specifically, it generates random replenishment and depletion rates for each product and updates the inventory quantity based on them. The inputs are the initial inventory quantity, replenishment rate, and depletion rate for each product, and the output is the updated inventory quantity for each product.

[0177] Step 5:

[0178] The server displays year-to-year inventory changes in real time. Specifically, it displays the simulation results for each year on a graphical user interface (GUI) or console. The input is updated inventory data, and the output is a visual display of inventory fluctuations.

[0179] Step 6:

[0180] Users can perform appropriate inventory replenishment and adjustments based on the real-time displayed inventory levels. During this process, they can input prompts into the system using a generative AI model to add new products. The input is new product information based on the prompt, and the output is inventory data for the added products.

[0181] Step 7:

[0182] Once the simulation for the specified number of years is complete, the server will shut down the system normally. The input is the simulation termination command, and the output is a message indicating system termination.

[0183] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0184] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0185] Furthermore, by incorporating an emotion engine that recognizes user emotions, dynamic adjustments to the simulation are made in response to the user's feelings. This makes the simulation experience more interactive and personalized.

[0186] The following describes specific embodiments of the system of the present invention.

[0187] System initialization

[0188] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0189] Adding organisms

[0190] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0191] Using an Emotion Engine

[0192] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. For example, if the user is stressed, the system will slow down the simulation speed or make adjustments to moderate the fluctuations of the displayed organisms.

[0193] Start of simulation

[0194] The terminal instructs the server to start a simulation spanning a specified number of years. The server then calls the `simulate` method to begin the simulation.

[0195] Specific example

[0196] For example, when running a 10-year simulation, it would look like this:

[0197] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0198] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0199] 3. Adjustments based on user state: If the emotion engine detects that the user is under stress, the server will slow down the rate of population change. If the user is relaxed, the system will return the simulation to normal or run a more active simulation.

[0200] display

[0201] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0202] System shutdown

[0203] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0204] The above describes specific embodiments of the present invention. This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, and is also useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by personalizing the user experience through an emotion engine.

[0205] The following describes the processing flow.

[0206] Step 1:

[0207] The server executes the program and calls the main function to begin program initialization.

[0208] Step 2:

[0209] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0210] Step 3:

[0211] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0212] Step 4:

[0213] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0214] Step 5:

[0215] The server starts the emotion engine and waits for input from the sensor device.

[0216] Step 6:

[0217] The user sends emotional data obtained from sensor devices to a server via an emotion engine. This emotional data is transmitted in various formats, such as heart rate and facial recognition data.

[0218] Step 7:

[0219] The emotion engine analyzes the user's emotions and returns the results to the server. For example, it identifies whether the user is relaxed or stressed.

[0220] Step 8:

[0221] The server adjusts simulation parameters (birth rate, death rate, simulation speed, etc.) based on sentiment data.

[0222] Step 9:

[0223] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0224] Step 10:

[0225] The server starts a loop and sequentially executes the following processes for each year.

[0226] Step 11:

[0227] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0228] Step 12:

[0229] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0230] Step 13:

[0231] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0232] Step 14:

[0233] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0234] Step 15:

[0235] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0236] Step 16:

[0237] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0238] (Example 2)

[0239] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0240] Conventional ecosystem simulation systems often use fixed birth and death rates to predict population fluctuations, making it difficult to obtain results that accurately reflect real ecosystems. Furthermore, they lacked the ability to dynamically adjust simulations based on user emotional states, resulting in a lack of interactive experiences. Additionally, they lacked sufficient means to simulate detailed interactions between different species. This led to a decline in the quality of the user experience and made them unsuitable for educational and research purposes.

[0241] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0242] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, and means for an emotion engine that analyzes input from sensor devices to recognize the user's emotional state and dynamically adjusts the simulation according to the user's emotional state. This improves the accuracy and realism of the simulation and makes it possible to provide an interactive experience that responds to the user's emotional state. Furthermore, it enables detailed simulations that take into account interactions between different species of organisms.

[0243] An "ecosystem simulation system" is a system that uses computer programs to mimic and simulate fluctuations in the populations and interactions of organisms.

[0244] "Organisms" refer to plants and animals whose population fluctuations within an ecosystem are tracked for simulation.

[0245] "Population fluctuation" refers to the phenomenon in which the number of a particular organism increases or decreases over time.

[0246] "Birth rate" refers to the proportion of new births within a specific period of time.

[0247] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0248] A "sensor device" is an input device used to measure a user's emotional state, and includes, for example, cameras and heart rate sensors.

[0249] An "emotion engine" is software or an algorithm that analyzes data received from sensor devices to identify the user's emotional state.

[0250] "Emotional state" refers to the psychological state a user is experiencing, such as stress or relaxation.

[0251] An "interactive experience" is an experience in which a user can directly interact with a system, and includes the system dynamically responding to the user's input and state.

[0252] This invention relates to a system for mimicking ecosystems and simulating fluctuations in the population of organisms. The system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running the simulation at predetermined time intervals to mimic the passage of time. Furthermore, by incorporating an emotion engine that recognizes the user's emotions, the system achieves dynamic adjustment of the simulation in response to the user's emotions.

[0253] Specifically, the server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. During this process, the classes are defined using a programming language such as Python, and instances are created at the start of the simulation. The Ecosystem class manages the list of organisms within the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0254] Next, the user creates instances of the Animal class and adds them to the Ecosystem class to specify the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they create instances of each organism as Animal class and add them to the Ecosystem class. Specifically, this involves setting the initial number of rabbits to 100 and the initial number of foxes to 10.

[0255] Next, the server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. Sensor devices such as cameras and heart rate sensors are used. For example, if the user is feeling stressed, the system will make adjustments such as slowing down the simulation speed.

[0256] The terminal then instructs the server to start a simulation over the specified number of years. The server calls the `simulate` method to begin the simulation. The server randomly sets birth and death rates for each year and calculates the population fluctuations. For example, if a 10-year simulation is run, it will show fluctuations such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0257] Furthermore, the server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in animal populations within the ecosystem. Libraries such as Matplotlib are used for the display.

[0258] Once the simulation for the specified number of years is complete, the server will shut down the system gracefully and release its resources.

[0259] Examples of prompt messages include the following:

[0260] "How are you feeling right now?"

[0261] "How do you feel about the speed of the simulation?"

[0262] This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, making it useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by the personalization of the user experience through an emotion engine.

[0263] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0264] Step 1:

[0265] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. Specifically, it defines the classes using a programming language such as Python and creates instances of them when the simulation starts. The input to this step is the initial conditions set when the program starts, and the output is instances of the Ecosystem and Animal classes. For example, class definition and initialization processes are performed, and the foundation of the system is built.

[0266] Step 2:

[0267] The user specifies the organisms to include in the ecosystem. Specifically, they create instances of the Animal class and add them to the Ecosystem class. The input for this step is the type of organism and its initial population specified by the user, and the output is the Animal instances added to the Ecosystem class. For example, you might set the initial population of rabbits to 100 and the initial population of foxes to 10.

[0268] Step 3:

[0269] The server receives input from the user's sensor device, and the emotion engine analyzes this input to recognize the user's emotional state. Specifically, data obtained from the sensor device (e.g., image data and heart rate data) is input to the emotion engine, and the user's emotional state (e.g., stressed or relaxed) is output. In this step, the input is data from the sensor device, and the output is the user's emotional state analyzed by the emotion engine. For example, based on the user's facial expression data acquired by the sensor device, it is determined whether the user is feeling stressed.

[0270] Step 4:

[0271] The terminal instructs the server to start a simulation over a specified number of years. Specifically, it calls the server's `simulate` method. The input for this step is the number of years to run the simulation (e.g., 10 years), and the output is the year-by-year population change data obtained as a result of the simulation. For example, after a 10-year setting is made, the `simulate` method is called.

[0272] Step 5:

[0273] The server runs the simulation and calculates population fluctuations for each year. Specifically, it sets birth and death rates randomly and calculates the population fluctuations for each year. The inputs to this step are the initial population size for each organism and the birth and death rates that are randomly generated each year, and the output is the population fluctuation data for each year. For example, calculations might be made such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0274] Step 6:

[0275] The server visually displays the population size of organisms for each year. Specifically, it displays the data using a console or a graphical user interface (GUI). In terms of operation, it uses libraries such as Matplotlib to create graphs. The input for this step is population size data for each year, and the output is visualized graphs and numerical data. For example, by displaying the annual population fluctuations in a graph, users can see those fluctuations.

[0276] Step 7:

[0277] Once the simulation for the specified number of years is complete, the server will shut down the system normally. Specifically, it will perform program termination processing and release resources. The input for this step is an instruction to terminate the simulation, and the output is the system's normal termination state. For example, it might notify the user that the simulation is complete and then shut down the system.

[0278] (Application Example 2)

[0279] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0280] In the simulation of an ecosystem, it is required to provide a realistic and interactive experience. However, conventional simulation systems can only simply mimic fluctuations in population numbers and interactions between species, and cannot make dynamic adjustments based on the emotional state of the user. In addition, the visual display of simulation results is also limited, and there is a problem that it is difficult to sustain the user's interest.

[0281] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following respective means.

[0282] In this invention, the server includes means for calculating fluctuations in the population numbers of organisms based on birth rates and death rates, means for displaying changes in the population numbers of each organism annually, means for executing simulations at predetermined time intervals to mimic the passage of time, means for analyzing the emotional state of the user and dynamically adjusting the speed and content of the simulations, and means for visually displaying the simulation results. Thereby, an interactive and real-time ecosystem simulation based on the emotional state of the user becomes possible.

[0283] An "ecosystem" is a system formed by a biological community and its environment, in which multiple species of organisms coexist while influencing each other.

[0284] A "simulation" is a process of mimicking real situations and phenomena and reproducing them on a computer.

[0285] "Fluctuations in population numbers" refers to the increase or decrease in the population numbers of each year in a biological group, which is affected by birth rates and death rates.

[0286] The "birth rate" indicates the incidence rate of new individuals in a specific biological group during a specific period.

[0287] The "death rate" indicates the mortality rate of individuals in a specific biological group during a specific period.

[0288] "Emotional state" refers to the psychological and emotional state that the user is currently experiencing, and includes things like stress and relaxation.

[0289] "Means of visual display" refers to technologies that display simulation results in a graphical format, providing information to users visually.

[0290] "Means of dynamic adjustment" refers to a function in which the system changes variables in real time, altering the content and speed according to the user's emotional state and the progress of the simulation.

[0291] "Year-to-year changes" refers to fluctuations in the population size and other related data of a biological group from year to year.

[0292] The present invention provides a system for managing multiple organisms and simulating changes in the population size of each organism in order to conduct ecosystem simulations. Specific embodiments of the present invention will be described step by step below.

[0293] System initialization

[0294] The server first initializes classes for ecosystem management and organism management. This system is implemented using the Python programming language. For example, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and manages birth and death data.

[0295] Adding organisms

[0296] Users can specify which organisms to include in the ecosystem. For example, to include rabbits and foxes in the simulation, you would create instances of each organism as classes and add them to the Ecosystem class.

[0297] Using an Emotion Engine

[0298] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. This emotion engine uses the EmotionEngine library. For example, if the user is stressed, the system will adjust the simulation speed or moderate the fluctuations of the displayed organisms.

[0299] Start of simulation

[0300] The terminal instructs the server to start a simulation spanning a specified number of years. The server runs the simulation year by year, visualizing the changes from year to year. Specifically, it randomly sets birth and death rates and calculates the fluctuations in the population of the organism.

[0301] Display and Interaction

[0302] The server displays the population size of organisms for each year through a graphical user interface, providing users with visual information. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0303] Specific example

[0304] For example, if running a 10-year simulation, the initial rabbit population is set at 100 in the first year. The server assumes a birth rate of 15% and a death rate of 10% in the first year, increasing the population to 115. Next, in the second year, a new birth rate of 20% and a death rate of 5% are set, increasing the population to 138. If the emotion engine detects that the user is in a stressed state, the server slows down the rate of population change.

[0305] Example of a prompt

[0306] The following prompt messages are used to explain the simulation status to the user.

[0307] Start the simulation. The initial number of rabbits is 100, and the initial number of foxes is 30. Since the changes for each year will be displayed, make sure not to miss the changes in emotions as you move on to the next year.

[0308] Thus, the system of the present invention provides an interactive and real-time ecosystem simulation based on the emotional state of the user.

[0309] The flow of the specific process in Application Example 2 will be described using FIG. 14.

[0310] Step 1: Addition of organisms by the user

[0311] The user specifies the organisms to be included in the ecosystem. For example, by selecting rabbits and foxes, each organism is created as an instance of the Animal class and added to the Ecosystem class. As input, the species name and initial number of each organism are required, and as output, the organisms are added to the Ecosystem class.

[0312] Step 2: Initialization of the emotion engine

[0313] The server initializes the emotion engine. This emotion engine uses the EmotionEngine library and analyzes and recognizes the user's emotional state in real time. The input is raw data from the sensor device, and the output is the analyzed emotional state of the user.

[0314] Step 3: Start of the simulation

[0315] The terminal instructs the server to start the simulation for the specified number of years. At this point, the server sets the initial parameters of the simulation. The input is the number of years of the simulation period, and the output is the trigger to start the simulation.

[0316] Step 4: Setting of birth rate and death rate

[0317] The server randomly sets the birth and death rates for each organism each year. The input is randomly generated values ​​for each year, and the output is the birth and death rates for each organism for each year.

[0318] Step 5: Annual fluctuations in population size

[0319] The server calculates the annual population fluctuations of each organism based on the set birth and death rates. The inputs are the initial population size and the birth and death rates for each organism, and the output is the updated population size.

[0320] Step 6: Adjustments based on user sentiment

[0321] The server analyzes the user's emotional state and dynamically adjusts the simulation speed and content. If the user is stressed, the simulation speed is slowed down; if relaxed, it is sped up. The input is the analyzed user's emotional state, and the output is the adjusted simulation speed.

[0322] Step 7: Displaying the simulation results

[0323] The server visually displays the annual fluctuations in the population size of organisms. A graphical user interface is used for this. The input is population data for each year, and the output is the visual simulation result.

[0324] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0325] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0326] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0327] [Second Embodiment]

[0328] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0329] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0330] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0331] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication interface 44. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, and camera 42 are also connected to the bus 52.

[0332] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0333] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0334] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0335] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0336] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0337] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0338] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0339] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0340] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0341] The following describes specific embodiments of the system of the present invention.

[0342] System initialization

[0343] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0344] Adding organisms

[0345] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0346] Start of simulation

[0347] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0348] Specific example

[0349] For example, when running a 10-year simulation, it would look like this:

[0350] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0351] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0352] display

[0353] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0354] System shutdown

[0355] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0356] The above describes specific embodiments of the present invention. This system allows users to perform realistic simulations of ecosystem fluctuations and is useful for academic research and educational purposes.

[0357] The following describes the processing flow.

[0358] Step 1:

[0359] The server executes the program and calls the main function to begin program initialization.

[0360] Step 2:

[0361] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0362] Step 3:

[0363] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0364] Step 4:

[0365] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0366] Step 5:

[0367] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0368] Step 6:

[0369] The server starts a loop and sequentially executes the following processes for each year.

[0370] Step 7:

[0371] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0372] Step 8:

[0373] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0374] Step 9:

[0375] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0376] Step 10:

[0377] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0378] Step 11:

[0379] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0380] Step 12:

[0381] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0382] (Example 1)

[0383] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0384] In ecosystem simulations, accurately replicating the population fluctuations of individual organisms in a way that closely resembles real-world environments is a challenging task. Furthermore, it is necessary to visually observe in real-time how specific organisms interact within different ecosystems and how their populations fluctuate. Additionally, reproducing year-to-year fluctuations through more realistic simulations is crucial. Conventional systems lack the means to randomly set birth and death rate fluctuations and to graphically display the results; therefore, effective methods to address these challenges are needed.

[0385] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0386] In this invention, the server includes means for initializing classes for calculating fluctuations in the population of organisms, means for calculating fluctuations in population based on birth and death rates, and means for displaying changes in population year by year. This allows users to visually check fluctuations in the population of animals in an ecosystem in real time, and furthermore, to more realistically simulate year by year changes in the ecosystem based on randomly set birth and death rates.

[0387] An "ecosystem" is a system that includes multiple organisms that survive and interact with each other within a specific environment.

[0388] "Simulation" is the process of recreating a real environment or situation on a computer, mimicking it.

[0389] "Living organisms" refer to entities that possess life, including populations of animals, plants, and microorganisms managed within the simulation.

[0390] "Population size" refers to the total number of individuals belonging to a particular group of organisms.

[0391] "Population fluctuation" refers to the phenomenon in which the number of individuals of an organism increases or decreases over time.

[0392] "Birth rate" refers to the rate at which new individuals are added to an organism through reproduction within a given period.

[0393] "Mortality rate" refers to the rate at which the number of individuals decreases due to death within a certain period of time.

[0394] A "fiscal year" refers to a unit of time used to observe and record fluctuations in the population size of organisms.

[0395] "Graphical display" refers to methods of visually representing data and results, such as expressing them in the form of graphs and charts.

[0396] In computer programs, a "class" refers to a blueprint for creating a specific object and defining the data and methods related to that object.

[0397] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system includes a computer program for calculating population fluctuations based on the birth and death rates of organisms and displaying these fluctuations year by year. Furthermore, it includes means for performing the simulation at predetermined time intervals to mimic the passage of time.

[0398] System initialization

[0399] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0400] Adding organisms

[0401] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0402] Start of simulation

[0403] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0404] display

[0405] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0406] System shutdown

[0407] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally.

[0408] Specific example

[0409] For example, when running a 10-year simulation, it would look like this:

[0410] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0411] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0412] Example of a prompt

[0413] The following is an example of an input prompt using a generative AI model.

[0414] "I would like to run a simulation of rabbit and fox population fluctuations. In the first year, the rabbit population is 100 and the fox population is 20. Randomly set the birth and death rates for each species and display the simulation results for 10 years."

[0415] This system allows users to simulate realistic ecosystem fluctuations and utilize them for academic research and educational purposes. Specific implementations of this system enable users to efficiently advance their ecosystem research.

[0416] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0417] Step 1: System Initialization

[0418] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. In this step, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. Inputs include initial setup information from the user (e.g., the types of organisms to include in the simulation and their initial populations). Outputs include instances of the initialized Ecosystem and Animal classes.

[0419] Step 2: Adding organisms

[0420] The user specifies the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they provide the species name and initial population as input. The server creates an instance of the Animal class based on this information and adds it to the organism list of the Ecosystem class. Specifically, the user inputs the type of organism and initial population through the terminal interface, and the server receives this information and saves it to the database. The output is an updated list of organisms in the ecosystem.

[0421] Step 3: Start the simulation

[0422] The user specifies the simulation period (number of years) and starts the simulation. The input is the number of years for the simulation. The terminal sends this information to the server. The server performs the following calculations for each year:

[0423] For each year, randomly set birth and death rates are generated for each organism.

[0424] The new population size is calculated by applying the birth rate and death rate to the current population size.

[0425] Specifically, the formula is "New population = Old population + (Old population × Birth rate) - (Old population × Death rate)". The output is the calculated new population, which is set as the initial state for the next year.

[0426] Step 4: Saving the calculation results for each fiscal year

[0427] At the end of each fiscal year, the server records the calculation results. The input is the new population count for that fiscal year. The server saves this data and carries it over to the next fiscal year. Specifically, the population count data for each fiscal year is saved to the database. The output is the initial data used to start the simulation for the next fiscal year.

[0428] Step 5: Displaying the results

[0429] The server sends the results to the terminal once it has finished calculating the population size of organisms for each year. The input is the population size data for each year. The terminal receives this data and displays it visually. Specifically, it uses a graph generation library (e.g., Matplotlib) to plot the changes in the organism population as a graph. The output is a graph or text format that the user can visually review.

[0430] Step 6: Shut down the system

[0431] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally. The input is a signal indicating simulation completion. The server saves the final results to a text file or database and shuts down the system. The output is the saved simulation result data.

[0432] (Application Example 1)

[0433] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0434] Traditional inventory management systems struggled to accurately predict the replenishment timing for each product, leading to a high likelihood of stockouts and excess inventory. Furthermore, they had difficulty reflecting real-time fluctuations in inventory levels over time, resulting in reduced operational efficiency.

[0435] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0436] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for performing simulations at predetermined time intervals to mimic the passage of time, means for simulating fluctuations in the inventory of each product based on product replenishment and consumption rates, and means for displaying changes in inventory at physical stores and issuing replenishment instructions. This makes it possible to predict inventory levels in a way that closely resembles reality, allows for timely replenishment instructions, and improves the efficiency of inventory management.

[0437] "Mimicking ecosystems" means using computer programs to reproduce the interrelationships and population fluctuations of biological groups that exist in natural environments.

[0438] "Managing multiple organisms" means maintaining data such as population size, birth rates, and mortality rates for different species or types of organisms, and processing and managing this data appropriately.

[0439] "Simulating population changes" means calculating and virtually reproducing how the population size of an organism fluctuates over time.

[0440] "Birth rate" refers to the proportion of newborns within a specific period of time.

[0441] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0442] "Displaying year-by-year changes" means outputting the fluctuations in the number of organisms or products, or the inventory levels, for each year in a way that can be visually confirmed.

[0443] "Replenishment rate" refers to the percentage of products added within a certain period.

[0444] "Consumption rate" refers to the percentage of products that are consumed or reduced within a certain period of time.

[0445] "Simulating inventory fluctuations" means calculating and virtually reproducing how the inventory levels of products in a physical store change over time.

[0446] "Issuing a replenishment order" means that when the inventory level falls below a certain threshold, the system outputs an instruction to secure additional inventory.

[0447] This invention is a system that combines inventory management in physical stores with ecosystem simulation, and aims to predict and manage the inventory levels of physical stores in real time. Specific embodiments of this system are described below.

[0448] Hardware and software to be used

[0449] Hardware: General-purpose computers and servers (Windows, macOS, Linux)

[0450] Software: Python 3.x, database management system

[0451] System initialization

[0452] The server first initializes classes for ecosystem management and inventory management. The "Ecosystem" class manages organisms within the ecosystem, and the "Inventory" class manages the inventory of goods. The "Animal" class corresponds to each organism and item, and maintains the number of individuals and inventory levels.

[0453] Add product

[0454] Users add products to the system. For example, to manage the inventory of "apples" and "oranges," users create instances of the "Product" class for each and add them to the "Inventory" class.

[0455] Start of simulation

[0456] The terminal starts a simulation over a specified period (for example, 10 years, year by year). The server calculates the inventory level of each product using randomly set replenishment and consumption rates for each year. As a result, the inventory levels of the products increase or decrease year by year and are displayed in real time.

[0457] Data processing and data calculation

[0458] The server maintains data such as the initial stock quantity, replenishment rate, and consumption rate for each product, and calculates the stock quantity annually. By using randomly set replenishment and consumption rates for each year, it realistically simulates fluctuations in inventory levels in physical stores. These inventory fluctuations are also displayed through a console and a graphical user interface.

[0459] Examples of prompt statements

[0460] When adding a new product to the system using a generative AI model, use the following prompt message.

[0461] "Please enter the name of the new product and the initial stock quantity."

[0462] For example, if "Bananas, 200" is returned, the system will add the product based on that information.

[0463] Examples

[0464] For example, here is a specific example of a 10-year simulation:

[0465] 1. First year: The initial stock of apples is assumed to be 100. Assuming a server replenishment rate of 15% and a consumption rate of 10%, the stock will increase to 115.

[0466] 2. Year 2: The server randomly sets a new replenishment rate of 20% and a consumption rate of 5%, increasing the inventory to 138 units. Continue the simulation by applying different replenishment and consumption rates each year.

[0467] This allows for realistic inventory management simulations in physical stores, enabling timely replenishment instructions.

[0468] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0469] Step 1:

[0470] The server initializes classes for ecosystem management and inventory management. Specifically, it creates the "Ecosystem" and "Inventory" classes and generates instances of the corresponding "Animal" and "Product" classes. At this stage, the initial data specified by the user is entered, and the system is configured based on that initial data. The output is a message indicating that the system's initial state is complete.

[0471] Step 2:

[0472] Users add products to the system. Specifically, users input product information (name and initial stock quantity), and an instance of the "Product" class is generated based on that data and added to the "Inventory" class. The input is the product name and initial stock quantity, and the output is the newly added product object.

[0473] Step 3:

[0474] The terminal sends a command to the server to start the simulation. The server starts simulating inventory levels over a specified period (e.g., 10 years). The input is information about the simulation period, and the output is a message indicating the progress of the simulation.

[0475] Step 4:

[0476] The server calculates the inventory quantity for each product using randomly set replenishment and depletion rates for each year. Specifically, it generates random replenishment and depletion rates for each product and updates the inventory quantity based on them. The inputs are the initial inventory quantity, replenishment rate, and depletion rate for each product, and the output is the updated inventory quantity for each product.

[0477] Step 5:

[0478] The server displays year-to-year inventory changes in real time. Specifically, it displays the simulation results for each year on a graphical user interface (GUI) or console. The input is updated inventory data, and the output is a visual display of inventory fluctuations.

[0479] Step 6:

[0480] Users can perform appropriate inventory replenishment and adjustments based on the real-time displayed inventory levels. During this process, they can input prompts into the system using a generative AI model to add new products. The input is new product information based on the prompt, and the output is inventory data for the added products.

[0481] Step 7:

[0482] Once the simulation for the specified number of years is complete, the server will shut down the system normally. The input is the simulation termination command, and the output is a message indicating system termination.

[0483] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0484] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0485] Furthermore, by incorporating an emotion engine that recognizes user emotions, dynamic adjustments to the simulation are made in response to the user's feelings. This makes the simulation experience more interactive and personalized.

[0486] The following describes specific embodiments of the system of the present invention.

[0487] System initialization

[0488] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0489] Adding organisms

[0490] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0491] Using an Emotion Engine

[0492] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. For example, if the user is stressed, the system will slow down the simulation speed or make adjustments to moderate the fluctuations of the displayed organisms.

[0493] Start of simulation

[0494] The terminal instructs the server to start a simulation spanning a specified number of years. The server then calls the `simulate` method to begin the simulation.

[0495] Specific example

[0496] For example, when running a 10-year simulation, it would look like this:

[0497] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0498] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0499] 3. Adjustments based on user state: If the emotion engine detects that the user is under stress, the server will slow down the rate of population change. If the user is relaxed, the system will return the simulation to normal or run a more active simulation.

[0500] display

[0501] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0502] System shutdown

[0503] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0504] The above describes specific embodiments of the present invention. This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, and is also useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by personalizing the user experience through an emotion engine.

[0505] The following describes the processing flow.

[0506] Step 1:

[0507] The server executes the program and calls the main function to begin program initialization.

[0508] Step 2:

[0509] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0510] Step 3:

[0511] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0512] Step 4:

[0513] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0514] Step 5:

[0515] The server starts the emotion engine and waits for input from the sensor device.

[0516] Step 6:

[0517] The user sends emotional data obtained from sensor devices to a server via an emotion engine. This emotional data is transmitted in various formats, such as heart rate and facial recognition data.

[0518] Step 7:

[0519] The emotion engine analyzes the user's emotions and returns the results to the server. For example, it identifies whether the user is relaxed or stressed.

[0520] Step 8:

[0521] The server adjusts simulation parameters (birth rate, death rate, simulation speed, etc.) based on sentiment data.

[0522] Step 9:

[0523] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0524] Step 10:

[0525] The server starts a loop and sequentially executes the following processes for each year.

[0526] Step 11:

[0527] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0528] Step 12:

[0529] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0530] Step 13:

[0531] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0532] Step 14:

[0533] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0534] Step 15:

[0535] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0536] Step 16:

[0537] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0538] (Example 2)

[0539] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0540] Conventional ecosystem simulation systems often use fixed birth and death rates to predict population fluctuations, making it difficult to obtain results that accurately reflect real ecosystems. Furthermore, they lacked the ability to dynamically adjust simulations based on user emotional states, resulting in a lack of interactive experiences. Additionally, they lacked sufficient means to simulate detailed interactions between different species. This led to a decline in the quality of the user experience and made them unsuitable for educational and research purposes.

[0541] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0542] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, and means for an emotion engine that analyzes input from sensor devices to recognize the user's emotional state and dynamically adjusts the simulation according to the user's emotional state. This improves the accuracy and realism of the simulation and makes it possible to provide an interactive experience that responds to the user's emotional state. Furthermore, it enables detailed simulations that take into account interactions between different species of organisms.

[0543] An "ecosystem simulation system" is a system that uses computer programs to mimic and simulate fluctuations in the populations and interactions of organisms.

[0544] "Organisms" refer to plants and animals whose population fluctuations within an ecosystem are tracked for simulation.

[0545] "Population fluctuation" refers to the phenomenon in which the number of a particular organism increases or decreases over time.

[0546] "Birth rate" refers to the proportion of new births within a specific period of time.

[0547] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0548] A "sensor device" is an input device used to measure a user's emotional state, and includes, for example, cameras and heart rate sensors.

[0549] An "emotion engine" is software or an algorithm that analyzes data received from sensor devices to identify the user's emotional state.

[0550] "Emotional state" refers to the psychological state a user is experiencing, such as stress or relaxation.

[0551] An "interactive experience" is an experience in which a user can directly interact with a system, and includes the system dynamically responding to the user's input and state.

[0552] This invention relates to a system for mimicking ecosystems and simulating fluctuations in the population of organisms. The system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running the simulation at predetermined time intervals to mimic the passage of time. Furthermore, by incorporating an emotion engine that recognizes the user's emotions, the system achieves dynamic adjustment of the simulation in response to the user's emotions.

[0553] Specifically, the server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. During this process, the classes are defined using a programming language such as Python, and instances are created at the start of the simulation. The Ecosystem class manages the list of organisms within the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0554] Next, the user creates instances of the Animal class and adds them to the Ecosystem class to specify the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they create instances of each organism as Animal class and add them to the Ecosystem class. Specifically, this involves setting the initial number of rabbits to 100 and the initial number of foxes to 10.

[0555] Next, the server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. Sensor devices such as cameras and heart rate sensors are used. For example, if the user is feeling stressed, the system will make adjustments such as slowing down the simulation speed.

[0556] The terminal then instructs the server to start a simulation over the specified number of years. The server calls the `simulate` method to begin the simulation. The server randomly sets birth and death rates for each year and calculates the population fluctuations. For example, if a 10-year simulation is run, it will show fluctuations such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0557] Furthermore, the server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in animal populations within the ecosystem. Libraries such as Matplotlib are used for the display.

[0558] Once the simulation for the specified number of years is complete, the server will shut down the system gracefully and release its resources.

[0559] Examples of prompt messages include the following:

[0560] "How are you feeling right now?"

[0561] "How do you feel about the speed of the simulation?"

[0562] This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, making it useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by the personalization of the user experience through an emotion engine.

[0563] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0564] Step 1:

[0565] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. Specifically, it defines the classes using a programming language such as Python and creates instances of them when the simulation starts. The input to this step is the initial conditions set when the program starts, and the output is instances of the Ecosystem and Animal classes. For example, class definition and initialization processes are performed, and the foundation of the system is built.

[0566] Step 2:

[0567] The user specifies the organisms to include in the ecosystem. Specifically, they create instances of the Animal class and add them to the Ecosystem class. The input for this step is the type of organism and its initial population specified by the user, and the output is the Animal instances added to the Ecosystem class. For example, you might set the initial population of rabbits to 100 and the initial population of foxes to 10.

[0568] Step 3:

[0569] The server receives input from the user's sensor device, and the emotion engine analyzes this input to recognize the user's emotional state. Specifically, data obtained from the sensor device (e.g., image data and heart rate data) is input to the emotion engine, and the user's emotional state (e.g., stressed or relaxed) is output. In this step, the input is data from the sensor device, and the output is the user's emotional state analyzed by the emotion engine. For example, based on the user's facial expression data acquired by the sensor device, it is determined whether the user is feeling stressed.

[0570] Step 4:

[0571] The terminal instructs the server to start a simulation over a specified number of years. Specifically, it calls the server's `simulate` method. The input for this step is the number of years to run the simulation (e.g., 10 years), and the output is the year-by-year population change data obtained as a result of the simulation. For example, after a 10-year setting is made, the `simulate` method is called.

[0572] Step 5:

[0573] The server runs the simulation and calculates population fluctuations for each year. Specifically, it sets birth and death rates randomly and calculates the population fluctuations for each year. The inputs to this step are the initial population size for each organism and the birth and death rates that are randomly generated each year, and the output is the population fluctuation data for each year. For example, calculations might be made such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0574] Step 6:

[0575] The server visually displays the population size of organisms for each year. Specifically, it displays the data using a console or a graphical user interface (GUI). In terms of operation, it uses libraries such as Matplotlib to create graphs. The input for this step is population size data for each year, and the output is visualized graphs and numerical data. For example, by displaying the annual population fluctuations in a graph, users can see those fluctuations.

[0576] Step 7:

[0577] Once the simulation for the specified number of years is complete, the server will shut down the system normally. Specifically, it will perform program termination processing and release resources. The input for this step is an instruction to terminate the simulation, and the output is the system's normal termination state. For example, it might notify the user that the simulation is complete and then shut down the system.

[0578] (Application Example 2)

[0579] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0580] Ecosystem simulations require a realistic and interactive experience. However, conventional simulation systems simply mimic population fluctuations and interspecies interactions without being able to dynamically adjust based on the user's emotional state. Furthermore, the visual display of simulation results is limited, making it difficult to maintain user interest.

[0581] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0582] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, means for analyzing the user's emotional state and dynamically adjusting the speed and content of the simulation, and means for visually displaying the simulation results. This enables interactive, real-time ecosystem simulations based on the user's emotional state.

[0583] An "ecosystem" is a system in which multiple species of organisms coexist while influencing each other, forming a biological community and its environment.

[0584] "Simulation" is the process of imitating real-world situations and phenomena and reproducing them on a computer.

[0585] "Population fluctuations" refer to the increase or decrease in the number of individuals in a biological group each year, and are influenced by birth and death rates.

[0586] "Birth rate" refers to the rate at which new individuals are born in a particular group of organisms during a specific period of time.

[0587] "Mortality rate" refers to the death rate of individuals in a particular group of organisms over a specific period of time.

[0588] "Emotional state" refers to the psychological and emotional state that the user is currently experiencing, and includes things like stress and relaxation.

[0589] "Means of visual display" refers to technologies that display simulation results in a graphical format, providing information to users visually.

[0590] "Means of dynamic adjustment" refers to a function in which the system changes variables in real time, altering the content and speed according to the user's emotional state and the progress of the simulation.

[0591] "Year-to-year changes" refers to fluctuations in the population size and other related data of a biological group from year to year.

[0592] The present invention provides a system for managing multiple organisms and simulating changes in the population size of each organism in order to conduct ecosystem simulations. Specific embodiments of the present invention will be described step by step below.

[0593] System initialization

[0594] The server first initializes classes for ecosystem management and organism management. This system is implemented using the Python programming language. For example, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and manages birth and death data.

[0595] Adding organisms

[0596] Users can specify which organisms to include in the ecosystem. For example, to include rabbits and foxes in the simulation, you would create instances of each organism as classes and add them to the Ecosystem class.

[0597] Using an Emotion Engine

[0598] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. This emotion engine uses the EmotionEngine library. For example, if the user is stressed, the system will adjust the simulation speed or moderate the fluctuations of the displayed organisms.

[0599] Start of simulation

[0600] The terminal instructs the server to start a simulation spanning a specified number of years. The server runs the simulation year by year, visualizing the changes from year to year. Specifically, it randomly sets birth and death rates and calculates the fluctuations in the population of the organism.

[0601] Display and Interaction

[0602] The server displays the population size of organisms for each year through a graphical user interface, providing users with visual information. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0603] Specific example

[0604] For example, if running a 10-year simulation, the initial rabbit population is set at 100 in the first year. The server assumes a birth rate of 15% and a death rate of 10% in the first year, increasing the population to 115. Next, in the second year, a new birth rate of 20% and a death rate of 5% are set, increasing the population to 138. If the emotion engine detects that the user is in a stressed state, the server slows down the rate of population change.

[0605] Example of a prompt

[0606] The following prompt messages are used to explain the simulation status to the user.

[0607] Let's begin the simulation. The initial number of rabbits is 100, and the initial number of foxes is 30. The fluctuations for each year will be displayed, so don't miss the changes in their emotions as you progress to the next year.

[0608] Thus, the system of the present invention provides an interactive, real-time ecosystem simulation based on the user's emotional state.

[0609] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0610] Step 1: User adds organism

[0611] The user specifies the organisms to include in the ecosystem. For example, by selecting rabbits and foxes, instances of each organism will be created as Animal class instances and added to the Ecosystem class. The input requires the species name and initial population size of each organism, and the output is the addition of the organisms to the Ecosystem class.

[0612] Step 2: Initializing the Emotion Engine

[0613] The server initializes the emotion engine. This emotion engine uses the EmotionEngine library to analyze and recognize the user's emotional state in real time. The input is raw data from sensor devices, and the output is the analyzed user's emotional state.

[0614] Step 3: Start the simulation

[0615] The terminal instructs the server to start a simulation for the specified number of years. At this point, the server sets the initial parameters of the simulation. The input is the number of years for the simulation period, and the output is the trigger for starting the simulation.

[0616] Step 4: Setting birth and death rates

[0617] The server randomly sets the birth and death rates for each organism for each year. The input is randomly generated values ​​for each year, and the output is the birth and death rates for each organism for each year.

[0618] Step 5: Annual fluctuations in population size

[0619] The server calculates the annual population fluctuations of each organism based on the set birth and death rates. The inputs are the initial population size and the birth and death rates for each organism, and the output is the updated population size.

[0620] Step 6: Adjustments based on user sentiment

[0621] The server analyzes the user's emotional state and dynamically adjusts the simulation speed and content. If the user is stressed, the simulation speed is slowed down; if relaxed, it is sped up. The input is the analyzed user's emotional state, and the output is the adjusted simulation speed.

[0622] Step 7: Displaying the simulation results

[0623] The server visually displays the annual fluctuations in the population size of organisms. A graphical user interface is used for this. The input is population data for each year, and the output is the visual simulation result.

[0624] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[0625] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0626] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[0627] [Third Embodiment]

[0628] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[0629] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[0630] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0631] The headset terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a display 343. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and display 343 are also connected to the bus 52.

[0632] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0633] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0634] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0635] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0636] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0637] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0638] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0639] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[0640] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0641] The following describes specific embodiments of the system of the present invention.

[0642] System initialization

[0643] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0644] Adding organisms

[0645] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0646] Start of simulation

[0647] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0648] Specific example

[0649] For example, when running a 10-year simulation, it would look like this:

[0650] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0651] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0652] display

[0653] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0654] System shutdown

[0655] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0656] The above describes specific embodiments of the present invention. This system allows users to perform realistic simulations of ecosystem fluctuations and is useful for academic research and educational purposes.

[0657] The following describes the processing flow.

[0658] Step 1:

[0659] The server executes the program and calls the main function to begin program initialization.

[0660] Step 2:

[0661] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0662] Step 3:

[0663] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0664] Step 4:

[0665] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0666] Step 5:

[0667] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0668] Step 6:

[0669] The server starts a loop and sequentially executes the following processes for each year.

[0670] Step 7:

[0671] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0672] Step 8:

[0673] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0674] Step 9:

[0675] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0676] Step 10:

[0677] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0678] Step 11:

[0679] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0680] Step 12:

[0681] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0682] (Example 1)

[0683] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0684] In ecosystem simulations, accurately replicating the population fluctuations of individual organisms in a way that closely resembles real-world environments is a challenging task. Furthermore, it is necessary to visually observe in real-time how specific organisms interact within different ecosystems and how their populations fluctuate. Additionally, reproducing year-to-year fluctuations through more realistic simulations is crucial. Conventional systems lack the means to randomly set birth and death rate fluctuations and to graphically display the results; therefore, effective methods to address these challenges are needed.

[0685] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0686] In this invention, the server includes means for initializing classes for calculating fluctuations in the population of organisms, means for calculating fluctuations in population based on birth and death rates, and means for displaying changes in population year by year. This allows users to visually check fluctuations in the population of animals in an ecosystem in real time, and furthermore, to more realistically simulate year by year changes in the ecosystem based on randomly set birth and death rates.

[0687] An "ecosystem" is a system that includes multiple organisms that survive and interact with each other within a specific environment.

[0688] "Simulation" is the process of recreating a real environment or situation on a computer, mimicking it.

[0689] "Living organisms" refer to entities that possess life, including populations of animals, plants, and microorganisms managed within the simulation.

[0690] "Population size" refers to the total number of individuals belonging to a particular group of organisms.

[0691] "Population fluctuation" refers to the phenomenon in which the number of individuals of an organism increases or decreases over time.

[0692] "Birth rate" refers to the rate at which new individuals are added to an organism through reproduction within a given period.

[0693] "Mortality rate" refers to the rate at which the number of individuals decreases due to death within a certain period of time.

[0694] A "fiscal year" refers to a unit of time used to observe and record fluctuations in the population size of organisms.

[0695] "Graphical display" refers to methods of visually representing data and results, such as expressing them in the form of graphs and charts.

[0696] In computer programs, a "class" refers to a blueprint for creating a specific object and defining the data and methods related to that object.

[0697] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system includes a computer program for calculating population fluctuations based on the birth and death rates of organisms and displaying these fluctuations year by year. Furthermore, it includes means for performing the simulation at predetermined time intervals to mimic the passage of time.

[0698] System initialization

[0699] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0700] Adding organisms

[0701] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0702] Start of simulation

[0703] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0704] display

[0705] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0706] System shutdown

[0707] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally.

[0708] Specific example

[0709] For example, when running a 10-year simulation, it would look like this:

[0710] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0711] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0712] Example of a prompt

[0713] The following is an example of an input prompt using a generative AI model.

[0714] "I would like to run a simulation of rabbit and fox population fluctuations. In the first year, the rabbit population is 100 and the fox population is 20. Randomly set the birth and death rates for each species and display the simulation results for 10 years."

[0715] This system allows users to simulate realistic ecosystem fluctuations and utilize them for academic research and educational purposes. Specific implementations of this system enable users to efficiently advance their ecosystem research.

[0716] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0717] Step 1: System Initialization

[0718] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. In this step, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. Inputs include initial setup information from the user (e.g., the types of organisms to include in the simulation and their initial populations). Outputs include instances of the initialized Ecosystem and Animal classes.

[0719] Step 2: Adding organisms

[0720] The user specifies the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they provide the species name and initial population as input. The server creates an instance of the Animal class based on this information and adds it to the organism list of the Ecosystem class. Specifically, the user inputs the type of organism and initial population through the terminal interface, and the server receives this information and saves it to the database. The output is an updated list of organisms in the ecosystem.

[0721] Step 3: Start the simulation

[0722] The user specifies the simulation period (number of years) and starts the simulation. The input is the number of years for the simulation. The terminal sends this information to the server. The server performs the following calculations for each year:

[0723] For each year, randomly set birth and death rates are generated for each organism.

[0724] The new population size is calculated by applying the birth rate and death rate to the current population size.

[0725] Specifically, the formula is "New population = Old population + (Old population × Birth rate) - (Old population × Death rate)". The output is the calculated new population, which is set as the initial state for the next year.

[0726] Step 4: Saving the calculation results for each fiscal year

[0727] At the end of each fiscal year, the server records the calculation results. The input is the new population count for that fiscal year. The server saves this data and carries it over to the next fiscal year. Specifically, the population count data for each fiscal year is saved to the database. The output is the initial data used to start the simulation for the next fiscal year.

[0728] Step 5: Displaying the results

[0729] The server sends the results to the terminal once it has finished calculating the population size of organisms for each year. The input is the population size data for each year. The terminal receives this data and displays it visually. Specifically, it uses a graph generation library (e.g., Matplotlib) to plot the changes in the organism population as a graph. The output is a graph or text format that the user can visually review.

[0730] Step 6: Shut down the system

[0731] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally. The input is a signal indicating simulation completion. The server saves the final results to a text file or database and shuts down the system. The output is the saved simulation result data.

[0732] (Application Example 1)

[0733] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0734] Traditional inventory management systems struggled to accurately predict the replenishment timing for each product, leading to a high likelihood of stockouts and excess inventory. Furthermore, they had difficulty reflecting real-time fluctuations in inventory levels over time, resulting in reduced operational efficiency.

[0735] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0736] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for performing simulations at predetermined time intervals to mimic the passage of time, means for simulating fluctuations in the inventory of each product based on product replenishment and consumption rates, and means for displaying changes in inventory at physical stores and issuing replenishment instructions. This makes it possible to predict inventory levels in a way that closely resembles reality, allows for timely replenishment instructions, and improves the efficiency of inventory management.

[0737] "Mimicking ecosystems" means using computer programs to reproduce the interrelationships and population fluctuations of biological groups that exist in natural environments.

[0738] "Managing multiple organisms" means maintaining data such as population size, birth rates, and mortality rates for different species or types of organisms, and processing and managing this data appropriately.

[0739] "Simulating population changes" means calculating and virtually reproducing how the population size of an organism fluctuates over time.

[0740] "Birth rate" refers to the proportion of newborns within a specific period of time.

[0741] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0742] "Displaying year-by-year changes" means outputting the fluctuations in the number of organisms or products, or the inventory levels, for each year in a way that can be visually confirmed.

[0743] "Replenishment rate" refers to the percentage of products added within a certain period.

[0744] "Consumption rate" refers to the percentage of products that are consumed or reduced within a certain period of time.

[0745] "Simulating inventory fluctuations" means calculating and virtually reproducing how the inventory levels of products in a physical store change over time.

[0746] "Issuing a replenishment order" means that when the inventory level falls below a certain threshold, the system outputs an instruction to secure additional inventory.

[0747] This invention is a system that combines inventory management in physical stores with ecosystem simulation, and aims to predict and manage the inventory levels of physical stores in real time. Specific embodiments of this system are described below.

[0748] Hardware and software to be used

[0749] Hardware: General-purpose computers and servers (Windows, macOS, Linux)

[0750] Software: Python 3.x, database management system

[0751] System initialization

[0752] The server first initializes classes for ecosystem management and inventory management. The "Ecosystem" class manages organisms within the ecosystem, and the "Inventory" class manages the inventory of goods. The "Animal" class corresponds to each organism and item, and maintains the number of individuals and inventory levels.

[0753] Add product

[0754] Users add products to the system. For example, to manage the inventory of "apples" and "oranges," users create instances of the "Product" class for each and add them to the "Inventory" class.

[0755] Start of simulation

[0756] The terminal starts a simulation over a specified period (for example, 10 years, year by year). The server calculates the inventory level of each product using randomly set replenishment and consumption rates for each year. As a result, the inventory levels of the products increase or decrease year by year and are displayed in real time.

[0757] Data processing and data calculation

[0758] The server maintains data such as the initial stock quantity, replenishment rate, and consumption rate for each product, and calculates the stock quantity annually. By using randomly set replenishment and consumption rates for each year, it realistically simulates fluctuations in inventory levels in physical stores. These inventory fluctuations are also displayed through a console and a graphical user interface.

[0759] Examples of prompt statements

[0760] When adding a new product to the system using a generative AI model, use the following prompt message.

[0761] "Please enter the name of the new product and the initial stock quantity."

[0762] For example, if "Bananas, 200" is returned, the system will add the product based on that information.

[0763] Examples

[0764] For example, here is a specific example of a 10-year simulation:

[0765] 1. First year: The initial stock of apples is assumed to be 100. Assuming a server replenishment rate of 15% and a consumption rate of 10%, the stock will increase to 115.

[0766] 2. Year 2: The server randomly sets a new replenishment rate of 20% and a consumption rate of 5%, increasing the inventory to 138 units. Continue the simulation by applying different replenishment and consumption rates each year.

[0767] This allows for realistic inventory management simulations in physical stores, enabling timely replenishment instructions.

[0768] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0769] Step 1:

[0770] The server initializes classes for ecosystem management and inventory management. Specifically, it creates the "Ecosystem" and "Inventory" classes and generates instances of the corresponding "Animal" and "Product" classes. At this stage, the initial data specified by the user is entered, and the system is configured based on that initial data. The output is a message indicating that the system's initial state is complete.

[0771] Step 2:

[0772] Users add products to the system. Specifically, users input product information (name and initial stock quantity), and an instance of the "Product" class is generated based on that data and added to the "Inventory" class. The input is the product name and initial stock quantity, and the output is the newly added product object.

[0773] Step 3:

[0774] The terminal sends a command to the server to start the simulation. The server starts simulating inventory levels over a specified period (e.g., 10 years). The input is information about the simulation period, and the output is a message indicating the progress of the simulation.

[0775] Step 4:

[0776] The server calculates the inventory quantity for each product using randomly set replenishment and depletion rates for each year. Specifically, it generates random replenishment and depletion rates for each product and updates the inventory quantity based on them. The inputs are the initial inventory quantity, replenishment rate, and depletion rate for each product, and the output is the updated inventory quantity for each product.

[0777] Step 5:

[0778] The server displays year-to-year inventory changes in real time. Specifically, it displays the simulation results for each year on a graphical user interface (GUI) or console. The input is updated inventory data, and the output is a visual display of inventory fluctuations.

[0779] Step 6:

[0780] Users can perform appropriate inventory replenishment and adjustments based on the real-time displayed inventory levels. During this process, they can input prompts into the system using a generative AI model to add new products. The input is new product information based on the prompt, and the output is inventory data for the added products.

[0781] Step 7:

[0782] Once the simulation for the specified number of years is complete, the server will shut down the system normally. The input is the simulation termination command, and the output is a message indicating system termination.

[0783] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0784] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0785] Furthermore, by incorporating an emotion engine that recognizes user emotions, dynamic adjustments to the simulation are made in response to the user's feelings. This makes the simulation experience more interactive and personalized.

[0786] The following describes specific embodiments of the system of the present invention.

[0787] System initialization

[0788] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0789] Adding organisms

[0790] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0791] Using an Emotion Engine

[0792] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. For example, if the user is stressed, the system will slow down the simulation speed or make adjustments to moderate the fluctuations of the displayed organisms.

[0793] Start of simulation

[0794] The terminal instructs the server to start a simulation spanning a specified number of years. The server then calls the `simulate` method to begin the simulation.

[0795] Specific example

[0796] For example, when running a 10-year simulation, it would look like this:

[0797] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0798] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0799] 3. Adjustments based on user state: If the emotion engine detects that the user is under stress, the server will slow down the rate of population change. If the user is relaxed, the system will return the simulation to normal or run a more active simulation.

[0800] display

[0801] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0802] System shutdown

[0803] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0804] The above describes specific embodiments of the present invention. This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, and is also useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by personalizing the user experience through an emotion engine.

[0805] The following describes the processing flow.

[0806] Step 1:

[0807] The server executes the program and calls the main function to begin program initialization.

[0808] Step 2:

[0809] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0810] Step 3:

[0811] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0812] Step 4:

[0813] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0814] Step 5:

[0815] The server starts the emotion engine and waits for input from the sensor device.

[0816] Step 6:

[0817] The user sends emotional data obtained from sensor devices to a server via an emotion engine. This emotional data is transmitted in various formats, such as heart rate and facial recognition data.

[0818] Step 7:

[0819] The emotion engine analyzes the user's emotions and returns the results to the server. For example, it identifies whether the user is relaxed or stressed.

[0820] Step 8:

[0821] The server adjusts simulation parameters (birth rate, death rate, simulation speed, etc.) based on sentiment data.

[0822] Step 9:

[0823] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0824] Step 10:

[0825] The server starts a loop and sequentially executes the following processes for each year.

[0826] Step 11:

[0827] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0828] Step 12:

[0829] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0830] Step 13:

[0831] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0832] Step 14:

[0833] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0834] Step 15:

[0835] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0836] Step 16:

[0837] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0838] (Example 2)

[0839] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0840] Conventional ecosystem simulation systems often use fixed birth and death rates to predict population fluctuations, making it difficult to obtain results that accurately reflect real ecosystems. Furthermore, they lacked the ability to dynamically adjust simulations based on user emotional states, resulting in a lack of interactive experiences. Additionally, they lacked sufficient means to simulate detailed interactions between different species. This led to a decline in the quality of the user experience and made them unsuitable for educational and research purposes.

[0841] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0842] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, and means for an emotion engine that analyzes input from sensor devices to recognize the user's emotional state and dynamically adjusts the simulation according to the user's emotional state. This improves the accuracy and realism of the simulation and makes it possible to provide an interactive experience that responds to the user's emotional state. Furthermore, it enables detailed simulations that take into account interactions between different species of organisms.

[0843] An "ecosystem simulation system" is a system that uses computer programs to mimic and simulate fluctuations in the populations and interactions of organisms.

[0844] "Organisms" refer to plants and animals whose population fluctuations within an ecosystem are tracked for simulation.

[0845] "Population fluctuation" refers to the phenomenon in which the number of a particular organism increases or decreases over time.

[0846] "Birth rate" refers to the proportion of new births within a specific period of time.

[0847] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[0848] A "sensor device" is an input device used to measure a user's emotional state, and includes, for example, cameras and heart rate sensors.

[0849] An "emotion engine" is software or an algorithm that analyzes data received from sensor devices to identify the user's emotional state.

[0850] "Emotional state" refers to the psychological state a user is experiencing, such as stress or relaxation.

[0851] An "interactive experience" is an experience in which a user can directly interact with a system, and includes the system dynamically responding to the user's input and state.

[0852] This invention relates to a system for mimicking ecosystems and simulating fluctuations in the population of organisms. The system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running the simulation at predetermined time intervals to mimic the passage of time. Furthermore, by incorporating an emotion engine that recognizes the user's emotions, the system achieves dynamic adjustment of the simulation in response to the user's emotions.

[0853] Specifically, the server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. During this process, the classes are defined using a programming language such as Python, and instances are created at the start of the simulation. The Ecosystem class manages the list of organisms within the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0854] Next, the user creates instances of the Animal class and adds them to the Ecosystem class to specify the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they create instances of each organism as Animal class and add them to the Ecosystem class. Specifically, this involves setting the initial number of rabbits to 100 and the initial number of foxes to 10.

[0855] Next, the server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. Sensor devices such as cameras and heart rate sensors are used. For example, if the user is feeling stressed, the system will make adjustments such as slowing down the simulation speed.

[0856] The terminal then instructs the server to start a simulation over the specified number of years. The server calls the `simulate` method to begin the simulation. The server randomly sets birth and death rates for each year and calculates the population fluctuations. For example, if a 10-year simulation is run, it will show fluctuations such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0857] Furthermore, the server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in animal populations within the ecosystem. Libraries such as Matplotlib are used for the display.

[0858] Once the simulation for the specified number of years is complete, the server will shut down the system gracefully and release its resources.

[0859] Examples of prompt messages include the following:

[0860] "How are you feeling right now?"

[0861] "How do you feel about the speed of the simulation?"

[0862] This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, making it useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by the personalization of the user experience through an emotion engine.

[0863] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0864] Step 1:

[0865] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. Specifically, it defines the classes using a programming language such as Python and creates instances of them when the simulation starts. The input to this step is the initial conditions set when the program starts, and the output is instances of the Ecosystem and Animal classes. For example, class definition and initialization processes are performed, and the foundation of the system is built.

[0866] Step 2:

[0867] The user specifies the organisms to include in the ecosystem. Specifically, they create instances of the Animal class and add them to the Ecosystem class. The input for this step is the type of organism and its initial population specified by the user, and the output is the Animal instances added to the Ecosystem class. For example, you might set the initial population of rabbits to 100 and the initial population of foxes to 10.

[0868] Step 3:

[0869] The server receives input from the user's sensor device, and the emotion engine analyzes this input to recognize the user's emotional state. Specifically, data obtained from the sensor device (e.g., image data and heart rate data) is input to the emotion engine, and the user's emotional state (e.g., stressed or relaxed) is output. In this step, the input is data from the sensor device, and the output is the user's emotional state analyzed by the emotion engine. For example, based on the user's facial expression data acquired by the sensor device, it is determined whether the user is feeling stressed.

[0870] Step 4:

[0871] The terminal instructs the server to start a simulation over a specified number of years. Specifically, it calls the server's `simulate` method. The input for this step is the number of years to run the simulation (e.g., 10 years), and the output is the year-by-year population change data obtained as a result of the simulation. For example, after a 10-year setting is made, the `simulate` method is called.

[0872] Step 5:

[0873] The server runs the simulation and calculates population fluctuations for each year. Specifically, it sets birth and death rates randomly and calculates the population fluctuations for each year. The inputs to this step are the initial population size for each organism and the birth and death rates that are randomly generated each year, and the output is the population fluctuation data for each year. For example, calculations might be made such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[0874] Step 6:

[0875] The server visually displays the population size of organisms for each year. Specifically, it displays the data using a console or a graphical user interface (GUI). In terms of operation, it uses libraries such as Matplotlib to create graphs. The input for this step is population size data for each year, and the output is visualized graphs and numerical data. For example, by displaying the annual population fluctuations in a graph, users can see those fluctuations.

[0876] Step 7:

[0877] Once the simulation for the specified number of years is complete, the server will shut down the system normally. Specifically, it will perform program termination processing and release resources. The input for this step is an instruction to terminate the simulation, and the output is the system's normal termination state. For example, it might notify the user that the simulation is complete and then shut down the system.

[0878] (Application Example 2)

[0879] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0880] Ecosystem simulations require a realistic and interactive experience. However, conventional simulation systems simply mimic population fluctuations and interspecies interactions without being able to dynamically adjust based on the user's emotional state. Furthermore, the visual display of simulation results is limited, making it difficult to maintain user interest.

[0881] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[0882] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, means for analyzing the user's emotional state and dynamically adjusting the speed and content of the simulation, and means for visually displaying the simulation results. This enables interactive, real-time ecosystem simulations based on the user's emotional state.

[0883] An "ecosystem" is a system in which multiple species of organisms coexist while influencing each other, forming a biological community and its environment.

[0884] "Simulation" is the process of imitating real-world situations and phenomena and reproducing them on a computer.

[0885] "Population fluctuations" refer to the increase or decrease in the number of individuals in a biological group each year, and are influenced by birth and death rates.

[0886] "Birth rate" refers to the rate at which new individuals are born in a particular group of organisms during a specific period of time.

[0887] "Mortality rate" refers to the death rate of individuals in a particular group of organisms over a specific period of time.

[0888] "Emotional state" refers to the psychological and emotional state that the user is currently experiencing, and includes things like stress and relaxation.

[0889] "Means of visual display" refers to technologies that display simulation results in a graphical format, providing information to users visually.

[0890] "Means of dynamic adjustment" refers to a function in which the system changes variables in real time, altering the content and speed according to the user's emotional state and the progress of the simulation.

[0891] "Year-to-year changes" refers to fluctuations in the population size and other related data of a biological group from year to year.

[0892] The present invention provides a system for managing multiple organisms and simulating changes in the population size of each organism in order to conduct ecosystem simulations. Specific embodiments of the present invention will be described step by step below.

[0893] System initialization

[0894] The server first initializes classes for ecosystem management and organism management. This system is implemented using the Python programming language. For example, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and manages birth and death data.

[0895] Adding organisms

[0896] Users can specify which organisms to include in the ecosystem. For example, to include rabbits and foxes in the simulation, you would create instances of each organism as classes and add them to the Ecosystem class.

[0897] Using an Emotion Engine

[0898] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. This emotion engine uses the EmotionEngine library. For example, if the user is stressed, the system will adjust the simulation speed or moderate the fluctuations of the displayed organisms.

[0899] Start of simulation

[0900] The terminal instructs the server to start a simulation spanning a specified number of years. The server runs the simulation year by year, visualizing the changes from year to year. Specifically, it randomly sets birth and death rates and calculates the fluctuations in the population of the organism.

[0901] Display and Interaction

[0902] The server displays the population size of organisms for each year through a graphical user interface, providing users with visual information. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0903] Specific example

[0904] For example, if running a 10-year simulation, the initial rabbit population is set at 100 in the first year. The server assumes a birth rate of 15% and a death rate of 10% in the first year, increasing the population to 115. Next, in the second year, a new birth rate of 20% and a death rate of 5% are set, increasing the population to 138. If the emotion engine detects that the user is in a stressed state, the server slows down the rate of population change.

[0905] Example of a prompt

[0906] The following prompt messages are used to explain the simulation status to the user.

[0907] Let's begin the simulation. The initial number of rabbits is 100, and the initial number of foxes is 30. The fluctuations for each year will be displayed, so don't miss the changes in their emotions as you progress to the next year.

[0908] Thus, the system of the present invention provides an interactive, real-time ecosystem simulation based on the user's emotional state.

[0909] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0910] Step 1: User adds organism

[0911] The user specifies the organisms to include in the ecosystem. For example, by selecting rabbits and foxes, instances of each organism will be created as Animal class instances and added to the Ecosystem class. The input requires the species name and initial population size of each organism, and the output is the addition of the organisms to the Ecosystem class.

[0912] Step 2: Initializing the Emotion Engine

[0913] The server initializes the emotion engine. This emotion engine uses the EmotionEngine library to analyze and recognize the user's emotional state in real time. The input is raw data from sensor devices, and the output is the analyzed user's emotional state.

[0914] Step 3: Start the simulation

[0915] The terminal instructs the server to start a simulation for the specified number of years. At this point, the server sets the initial parameters of the simulation. The input is the number of years for the simulation period, and the output is the trigger for starting the simulation.

[0916] Step 4: Setting birth and death rates

[0917] The server randomly sets the birth and death rates for each organism for each year. The input is randomly generated values ​​for each year, and the output is the birth and death rates for each organism for each year.

[0918] Step 5: Annual fluctuations in population size

[0919] The server calculates the annual population fluctuations of each organism based on the set birth and death rates. The inputs are the initial population size and the birth and death rates for each organism, and the output is the updated population size.

[0920] Step 6: Adjustments based on user sentiment

[0921] The server analyzes the user's emotional state and dynamically adjusts the simulation speed and content. If the user is stressed, the simulation speed is slowed down; if relaxed, it is sped up. The input is the analyzed user's emotional state, and the output is the adjusted simulation speed.

[0922] Step 7: Displaying the simulation results

[0923] The server visually displays the annual fluctuations in the population size of organisms. A graphical user interface is used for this. The input is population data for each year, and the output is the visual simulation result.

[0924] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[0925] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0926] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[0927] [Fourth Embodiment]

[0928] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[0929] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[0930] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0931] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[0932] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0933] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0934] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0935] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[0936] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0937] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0938] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0939] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0940] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0941] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[0942] The following describes specific embodiments of the system of the present invention.

[0943] System initialization

[0944] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[0945] Adding organisms

[0946] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[0947] Start of simulation

[0948] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[0949] Specific example

[0950] For example, when running a 10-year simulation, it would look like this:

[0951] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[0952] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[0953] display

[0954] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[0955] System shutdown

[0956] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[0957] The above describes specific embodiments of the present invention. This system allows users to perform realistic simulations of ecosystem fluctuations and is useful for academic research and educational purposes.

[0958] The following describes the processing flow.

[0959] Step 1:

[0960] The server executes the program and calls the main function to begin program initialization.

[0961] Step 2:

[0962] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[0963] Step 3:

[0964] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[0965] Step 4:

[0966] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[0967] Step 5:

[0968] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[0969] Step 6:

[0970] The server starts a loop and sequentially executes the following processes for each year.

[0971] Step 7:

[0972] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[0973] Step 8:

[0974] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[0975] Step 9:

[0976] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[0977] Step 10:

[0978] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[0979] Step 11:

[0980] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[0981] Step 12:

[0982] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[0983] (Example 1)

[0984] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0985] In ecosystem simulations, accurately replicating the population fluctuations of individual organisms in a way that closely resembles real-world environments is a challenging task. Furthermore, it is necessary to visually observe in real-time how specific organisms interact within different ecosystems and how their populations fluctuate. Additionally, reproducing year-to-year fluctuations through more realistic simulations is crucial. Conventional systems lack the means to randomly set birth and death rate fluctuations and to graphically display the results; therefore, effective methods to address these challenges are needed.

[0986] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0987] In this invention, the server includes means for initializing classes for calculating fluctuations in the population of organisms, means for calculating fluctuations in population based on birth and death rates, and means for displaying changes in population year by year. This allows users to visually check fluctuations in the population of animals in an ecosystem in real time, and furthermore, to more realistically simulate year by year changes in the ecosystem based on randomly set birth and death rates.

[0988] An "ecosystem" is a system that includes multiple organisms that survive and interact with each other within a specific environment.

[0989] "Simulation" is the process of recreating a real environment or situation on a computer, mimicking it.

[0990] "Living organisms" refer to entities that possess life, including populations of animals, plants, and microorganisms managed within the simulation.

[0991] "Population size" refers to the total number of individuals belonging to a particular group of organisms.

[0992] "Population fluctuation" refers to the phenomenon in which the number of individuals of an organism increases or decreases over time.

[0993] "Birth rate" refers to the rate at which new individuals are added to an organism through reproduction within a given period.

[0994] "Mortality rate" refers to the rate at which the number of individuals decreases due to death within a certain period of time.

[0995] A "fiscal year" refers to a unit of time used to observe and record fluctuations in the population size of organisms.

[0996] "Graphical display" refers to methods of visually representing data and results, such as expressing them in the form of graphs and charts.

[0997] In computer programs, a "class" refers to a blueprint for creating a specific object and defining the data and methods related to that object.

[0998] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system includes a computer program for calculating population fluctuations based on the birth and death rates of organisms and displaying these fluctuations year by year. Furthermore, it includes means for performing the simulation at predetermined time intervals to mimic the passage of time.

[0999] System initialization

[1000] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[1001] Adding organisms

[1002] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[1003] Start of simulation

[1004] The terminal initiates a simulation spanning a specified number of years. For each year, the server calculates the population using randomly set birth and death rates for each species. This allows the population to increase or decrease, in the rabbit example, and simulates year-to-year changes in real time.

[1005] display

[1006] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[1007] System shutdown

[1008] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally.

[1009] Specific example

[1010] For example, when running a 10-year simulation, it would look like this:

[1011] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[1012] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[1013] Example of a prompt

[1014] The following is an example of an input prompt using a generative AI model.

[1015] "I would like to run a simulation of rabbit and fox population fluctuations. In the first year, the rabbit population is 100 and the fox population is 20. Randomly set the birth and death rates for each species and display the simulation results for 10 years."

[1016] This system allows users to simulate realistic ecosystem fluctuations and utilize them for academic research and educational purposes. Specific implementations of this system enable users to efficiently advance their ecosystem research.

[1017] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1018] Step 1: System Initialization

[1019] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. In this step, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. Inputs include initial setup information from the user (e.g., the types of organisms to include in the simulation and their initial populations). Outputs include instances of the initialized Ecosystem and Animal classes.

[1020] Step 2: Adding organisms

[1021] The user specifies the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they provide the species name and initial population as input. The server creates an instance of the Animal class based on this information and adds it to the organism list of the Ecosystem class. Specifically, the user inputs the type of organism and initial population through the terminal interface, and the server receives this information and saves it to the database. The output is an updated list of organisms in the ecosystem.

[1022] Step 3: Start the simulation

[1023] The user specifies the simulation period (number of years) and starts the simulation. The input is the number of years for the simulation. The terminal sends this information to the server. The server performs the following calculations for each year:

[1024] For each year, randomly set birth and death rates are generated for each organism.

[1025] The new population size is calculated by applying the birth rate and death rate to the current population size.

[1026] Specifically, the formula is "New population = Old population + (Old population × Birth rate) - (Old population × Death rate)". The output is the calculated new population, which is set as the initial state for the next year.

[1027] Step 4: Saving the calculation results for each fiscal year

[1028] At the end of each fiscal year, the server records the calculation results. The input is the new population count for that fiscal year. The server saves this data and carries it over to the next fiscal year. Specifically, the population count data for each fiscal year is saved to the database. The output is the initial data used to start the simulation for the next fiscal year.

[1029] Step 5: Displaying the results

[1030] The server sends the results to the terminal once it has finished calculating the population size of organisms for each year. The input is the population size data for each year. The terminal receives this data and displays it visually. Specifically, it uses a graph generation library (e.g., Matplotlib) to plot the changes in the organism population as a graph. The output is a graph or text format that the user can visually review.

[1031] Step 6: Shut down the system

[1032] Once the simulation for the specified number of years is complete, the server saves the system state and shuts down normally. The input is a signal indicating simulation completion. The server saves the final results to a text file or database and shuts down the system. The output is the saved simulation result data.

[1033] (Application Example 1)

[1034] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1035] Traditional inventory management systems struggled to accurately predict the replenishment timing for each product, leading to a high likelihood of stockouts and excess inventory. Furthermore, they had difficulty reflecting real-time fluctuations in inventory levels over time, resulting in reduced operational efficiency.

[1036] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1037] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for performing simulations at predetermined time intervals to mimic the passage of time, means for simulating fluctuations in the inventory of each product based on product replenishment and consumption rates, and means for displaying changes in inventory at physical stores and issuing replenishment instructions. This makes it possible to predict inventory levels in a way that closely resembles reality, allows for timely replenishment instructions, and improves the efficiency of inventory management.

[1038] "Mimicking ecosystems" means using computer programs to reproduce the interrelationships and population fluctuations of biological groups that exist in natural environments.

[1039] "Managing multiple organisms" means maintaining data such as population size, birth rates, and mortality rates for different species or types of organisms, and processing and managing this data appropriately.

[1040] "Simulating population changes" means calculating and virtually reproducing how the population size of an organism fluctuates over time.

[1041] "Birth rate" refers to the proportion of newborns within a specific period of time.

[1042] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[1043] "Displaying year-by-year changes" means outputting the fluctuations in the number of organisms or products, or the inventory levels, for each year in a way that can be visually confirmed.

[1044] "Replenishment rate" refers to the percentage of products added within a certain period.

[1045] "Consumption rate" refers to the percentage of products that are consumed or reduced within a certain period of time.

[1046] "Simulating inventory fluctuations" means calculating and virtually reproducing how the inventory levels of products in a physical store change over time.

[1047] "Issuing a replenishment order" means that when the inventory level falls below a certain threshold, the system outputs an instruction to secure additional inventory.

[1048] This invention is a system that combines inventory management in physical stores with ecosystem simulation, and aims to predict and manage the inventory levels of physical stores in real time. Specific embodiments of this system are described below.

[1049] Hardware and software to be used

[1050] Hardware: General-purpose computers and servers (Windows, macOS, Linux)

[1051] Software: Python 3.x, database management system

[1052] System initialization

[1053] The server first initializes classes for ecosystem management and inventory management. The "Ecosystem" class manages organisms within the ecosystem, and the "Inventory" class manages the inventory of goods. The "Animal" class corresponds to each organism and item, and maintains the number of individuals and inventory levels.

[1054] Add product

[1055] Users add products to the system. For example, to manage the inventory of "apples" and "oranges," users create instances of the "Product" class for each and add them to the "Inventory" class.

[1056] Start of simulation

[1057] The terminal starts a simulation over a specified period (for example, 10 years, year by year). The server calculates the inventory level of each product using randomly set replenishment and consumption rates for each year. As a result, the inventory levels of the products increase or decrease year by year and are displayed in real time.

[1058] Data processing and data calculation

[1059] The server maintains data such as the initial stock quantity, replenishment rate, and consumption rate for each product, and calculates the stock quantity annually. By using randomly set replenishment and consumption rates for each year, it realistically simulates fluctuations in inventory levels in physical stores. These inventory fluctuations are also displayed through a console and a graphical user interface.

[1060] Examples of prompt statements

[1061] When adding a new product to the system using a generative AI model, use the following prompt message.

[1062] "Please enter the name of the new product and the initial stock quantity."

[1063] For example, if "Bananas, 200" is returned, the system will add the product based on that information.

[1064] Examples

[1065] For example, here is a specific example of a 10-year simulation:

[1066] 1. First year: The initial stock of apples is assumed to be 100. Assuming a server replenishment rate of 15% and a consumption rate of 10%, the stock will increase to 115.

[1067] 2. Year 2: The server randomly sets a new replenishment rate of 20% and a consumption rate of 5%, increasing the inventory to 138 units. Continue the simulation by applying different replenishment and consumption rates each year.

[1068] This allows for realistic inventory management simulations in physical stores, enabling timely replenishment instructions.

[1069] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1070] Step 1:

[1071] The server initializes classes for ecosystem management and inventory management. Specifically, it creates the "Ecosystem" and "Inventory" classes and generates instances of the corresponding "Animal" and "Product" classes. At this stage, the initial data specified by the user is entered, and the system is configured based on that initial data. The output is a message indicating that the system's initial state is complete.

[1072] Step 2:

[1073] Users add products to the system. Specifically, users input product information (name and initial stock quantity), and an instance of the "Product" class is generated based on that data and added to the "Inventory" class. The input is the product name and initial stock quantity, and the output is the newly added product object.

[1074] Step 3:

[1075] The terminal sends a command to the server to start the simulation. The server starts simulating inventory levels over a specified period (e.g., 10 years). The input is information about the simulation period, and the output is a message indicating the progress of the simulation.

[1076] Step 4:

[1077] The server calculates the inventory quantity for each product using randomly set replenishment and depletion rates for each year. Specifically, it generates random replenishment and depletion rates for each product and updates the inventory quantity based on them. The inputs are the initial inventory quantity, replenishment rate, and depletion rate for each product, and the output is the updated inventory quantity for each product.

[1078] Step 5:

[1079] The server displays year-to-year inventory changes in real time. Specifically, it displays the simulation results for each year on a graphical user interface (GUI) or console. The input is updated inventory data, and the output is a visual display of inventory fluctuations.

[1080] Step 6:

[1081] Users can perform appropriate inventory replenishment and adjustments based on the real-time displayed inventory levels. During this process, they can input prompts into the system using a generative AI model to add new products. The input is new product information based on the prompt, and the output is inventory data for the added products.

[1082] Step 7:

[1083] Once the simulation for the specified number of years is complete, the server will shut down the system normally. The input is the simulation termination command, and the output is a message indicating system termination.

[1084] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[1085] The present invention provides a system for mimicking ecosystems and simulating fluctuations in the populations of organisms. This system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running simulations at predetermined time intervals to simulate the passage of time. Furthermore, the system can randomly set birth and death rates to more realistically simulate year-to-year changes. Interactions between different species are also considered, allowing for separate tracking of population changes between species.

[1086] Furthermore, by incorporating an emotion engine that recognizes user emotions, dynamic adjustments to the simulation are made in response to the user's feelings. This makes the simulation experience more interactive and personalized.

[1087] The following describes specific embodiments of the system of the present invention.

[1088] System initialization

[1089] The server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. The Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[1090] Adding organisms

[1091] The user specifies the organisms to include in the ecosystem. For example, if you want to include rabbits and foxes in the simulation, you create each organism as an instance of the Animal class and add them to the Ecosystem class.

[1092] Using an Emotion Engine

[1093] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. For example, if the user is stressed, the system will slow down the simulation speed or make adjustments to moderate the fluctuations of the displayed organisms.

[1094] Start of simulation

[1095] The terminal instructs the server to start a simulation spanning a specified number of years. The server then calls the `simulate` method to begin the simulation.

[1096] Specific example

[1097] For example, when running a 10-year simulation, it would look like this:

[1098] 1. First year: The initial rabbit population is 100. Assuming a birth rate of 15% and a mortality rate of 10%, the population will increase to 115.

[1099] 2. Year 2: The server randomly sets a new birth rate of 20% and a death rate of 5%, increasing the population to 138. The simulation continues in this manner, applying different birth and death rates each year.

[1100] 3. Adjustments based on user state: If the emotion engine detects that the user is under stress, the server will slow down the rate of population change. If the user is relaxed, the system will return the simulation to normal or run a more active simulation.

[1101] display

[1102] The server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[1103] System shutdown

[1104] Once the simulation for the specified number of years is complete, the server will shut down the system normally.

[1105] The above describes specific embodiments of the present invention. This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, and is also useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by personalizing the user experience through an emotion engine.

[1106] The following describes the processing flow.

[1107] Step 1:

[1108] The server executes the program and calls the main function to begin program initialization.

[1109] Step 2:

[1110] The server creates an instance of the Ecosystem class. This generates an object for managing the ecosystem.

[1111] Step 3:

[1112] The user specifies the creatures to include in the simulation (e.g., rabbits and foxes), and the server creates instances of each Animal class. The initial population size is set.

[1113] Step 4:

[1114] The server adds the created Animal instances (rabbit and fox) to the Ecosystem instance.

[1115] Step 5:

[1116] The server starts the emotion engine and waits for input from the sensor device.

[1117] Step 6:

[1118] The user sends emotional data obtained from sensor devices to a server via an emotion engine. This emotional data is transmitted in various formats, such as heart rate and facial recognition data.

[1119] Step 7:

[1120] The emotion engine analyzes the user's emotions and returns the results to the server. For example, it identifies whether the user is relaxed or stressed.

[1121] Step 8:

[1122] The server adjusts simulation parameters (birth rate, death rate, simulation speed, etc.) based on sentiment data.

[1123] Step 9:

[1124] The terminal instructs the server to start a simulation for a specified number of years (e.g., 10 years). The server then calls the `simulate` method to begin the simulation.

[1125] Step 10:

[1126] The server starts a loop and sequentially executes the following processes for each year.

[1127] Step 11:

[1128] Within the loop, the server generates random birth rates (e.g., 0.1–0.2) and death rates (e.g., 0.05–0.15) for each creature (e.g., rabbits and foxes).

[1129] Step 12:

[1130] The server updates the population size of each organism using a randomly generated birth rate. Specifically, it calls the `animal.birth(birth_rate)` method to increase the population size.

[1131] Step 13:

[1132] The server updates the population size of each organism using a randomly generated mortality rate. Specifically, it calls the `animal.death(death_rate)` method to decrease the population size.

[1133] Step 14:

[1134] The server outputs the population count of each species for the current year to the console. For example, it will display in a format such as "Year 1, Rabbit: Population 110".

[1135] Step 15:

[1136] The server pauses for one second to prepare for the next year's simulation. This waiting period allows users to monitor the simulation's progress.

[1137] Step 16:

[1138] Once the server completes the simulation for the specified number of years, it terminates the simulation and stops the program normally.

[1139] (Example 2)

[1140] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1141] Conventional ecosystem simulation systems often use fixed birth and death rates to predict population fluctuations, making it difficult to obtain results that accurately reflect real ecosystems. Furthermore, they lacked the ability to dynamically adjust simulations based on user emotional states, resulting in a lack of interactive experiences. Additionally, they lacked sufficient means to simulate detailed interactions between different species. This led to a decline in the quality of the user experience and made them unsuitable for educational and research purposes.

[1142] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1143] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, and means for an emotion engine that analyzes input from sensor devices to recognize the user's emotional state and dynamically adjusts the simulation according to the user's emotional state. This improves the accuracy and realism of the simulation and makes it possible to provide an interactive experience that responds to the user's emotional state. Furthermore, it enables detailed simulations that take into account interactions between different species of organisms.

[1144] An "ecosystem simulation system" is a system that uses computer programs to mimic and simulate fluctuations in the populations and interactions of organisms.

[1145] "Organisms" refer to plants and animals whose population fluctuations within an ecosystem are tracked for simulation.

[1146] "Population fluctuation" refers to the phenomenon in which the number of a particular organism increases or decreases over time.

[1147] "Birth rate" refers to the proportion of new births within a specific period of time.

[1148] "Mortality rate" refers to the proportion of individuals that die within a specific period of time.

[1149] A "sensor device" is an input device used to measure a user's emotional state, and includes, for example, cameras and heart rate sensors.

[1150] An "emotion engine" is software or an algorithm that analyzes data received from sensor devices to identify the user's emotional state.

[1151] "Emotional state" refers to the psychological state a user is experiencing, such as stress or relaxation.

[1152] An "interactive experience" is an experience in which a user can directly interact with a system, and includes the system dynamically responding to the user's input and state.

[1153] This invention relates to a system for mimicking ecosystems and simulating fluctuations in the population of organisms. The system uses a computer program to calculate population fluctuations based on the birth and death rates of organisms and displays these fluctuations year by year. It also includes means for running the simulation at predetermined time intervals to mimic the passage of time. Furthermore, by incorporating an emotion engine that recognizes the user's emotions, the system achieves dynamic adjustment of the simulation in response to the user's emotions.

[1154] Specifically, the server first initializes the Ecosystem class for ecosystem management and the Animal class for organism management. During this process, the classes are defined using a programming language such as Python, and instances are created at the start of the simulation. The Ecosystem class manages the list of organisms within the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and provides methods for birth and death.

[1155] Next, the user creates instances of the Animal class and adds them to the Ecosystem class to specify the organisms to include in the ecosystem. For example, if the user wants to include rabbits and foxes in the simulation, they create instances of each organism as Animal class and add them to the Ecosystem class. Specifically, this involves setting the initial number of rabbits to 100 and the initial number of foxes to 10.

[1156] Next, the server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. Sensor devices such as cameras and heart rate sensors are used. For example, if the user is feeling stressed, the system will make adjustments such as slowing down the simulation speed.

[1157] The terminal then instructs the server to start a simulation over the specified number of years. The server calls the `simulate` method to begin the simulation. The server randomly sets birth and death rates for each year and calculates the population fluctuations. For example, if a 10-year simulation is run, it will show fluctuations such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[1158] Furthermore, the server displays the population size of organisms for each year through a console and a graphical user interface. This allows users to visually observe fluctuations in animal populations within the ecosystem. Libraries such as Matplotlib are used for the display.

[1159] Once the simulation for the specified number of years is complete, the server will shut down the system gracefully and release its resources.

[1160] Examples of prompt messages include the following:

[1161] "How are you feeling right now?"

[1162] "How do you feel about the speed of the simulation?"

[1163] This system allows users to experience realistic and interactive simulations of ecosystem fluctuations, making it useful for academic research and educational purposes. Furthermore, the system's value is further enhanced by the personalization of the user experience through an emotion engine.

[1164] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1165] Step 1:

[1166] The server initializes the Ecosystem class for ecosystem management and the Animal class for organism management. Specifically, it defines the classes using a programming language such as Python and creates instances of them when the simulation starts. The input to this step is the initial conditions set when the program starts, and the output is instances of the Ecosystem and Animal classes. For example, class definition and initialization processes are performed, and the foundation of the system is built.

[1167] Step 2:

[1168] The user specifies the organisms to include in the ecosystem. Specifically, they create instances of the Animal class and add them to the Ecosystem class. The input for this step is the type of organism and its initial population specified by the user, and the output is the Animal instances added to the Ecosystem class. For example, you might set the initial population of rabbits to 100 and the initial population of foxes to 10.

[1169] Step 3:

[1170] The server receives input from the user's sensor device, and the emotion engine analyzes this input to recognize the user's emotional state. Specifically, data obtained from the sensor device (e.g., image data and heart rate data) is input to the emotion engine, and the user's emotional state (e.g., stressed or relaxed) is output. In this step, the input is data from the sensor device, and the output is the user's emotional state analyzed by the emotion engine. For example, based on the user's facial expression data acquired by the sensor device, it is determined whether the user is feeling stressed.

[1171] Step 4:

[1172] The terminal instructs the server to start a simulation over a specified number of years. Specifically, it calls the server's `simulate` method. The input for this step is the number of years to run the simulation (e.g., 10 years), and the output is the year-by-year population change data obtained as a result of the simulation. For example, after a 10-year setting is made, the `simulate` method is called.

[1173] Step 5:

[1174] The server runs the simulation and calculates population fluctuations for each year. Specifically, it sets birth and death rates randomly and calculates the population fluctuations for each year. The inputs to this step are the initial population size for each organism and the birth and death rates that are randomly generated each year, and the output is the population fluctuation data for each year. For example, calculations might be made such as the rabbit population increasing to 115 in the first year and to 138 in the second year.

[1175] Step 6:

[1176] The server visually displays the population size of organisms for each year. Specifically, it displays the data using a console or a graphical user interface (GUI). In terms of operation, it uses libraries such as Matplotlib to create graphs. The input for this step is population size data for each year, and the output is visualized graphs and numerical data. For example, by displaying the annual population fluctuations in a graph, users can see those fluctuations.

[1177] Step 7:

[1178] Once the simulation for the specified number of years is complete, the server will shut down the system normally. Specifically, it will perform program termination processing and release resources. The input for this step is an instruction to terminate the simulation, and the output is the system's normal termination state. For example, it might notify the user that the simulation is complete and then shut down the system.

[1179] (Application Example 2)

[1180] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1181] Ecosystem simulations require a realistic and interactive experience. However, conventional simulation systems simply mimic population fluctuations and interspecies interactions without being able to dynamically adjust based on the user's emotional state. Furthermore, the visual display of simulation results is limited, making it difficult to maintain user interest.

[1182] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means.

[1183] In this invention, the server includes means for calculating fluctuations in the population of organisms based on birth and death rates, means for displaying year-to-year changes in the population of each organism, means for running simulations at predetermined time intervals to mimic the passage of time, means for analyzing the user's emotional state and dynamically adjusting the speed and content of the simulation, and means for visually displaying the simulation results. This enables interactive, real-time ecosystem simulations based on the user's emotional state.

[1184] An "ecosystem" is a system in which multiple species of organisms coexist while influencing each other, forming a biological community and its environment.

[1185] "Simulation" is the process of imitating real-world situations and phenomena and reproducing them on a computer.

[1186] "Population fluctuations" refer to the increase or decrease in the number of individuals in a biological group each year, and are influenced by birth and death rates.

[1187] "Birth rate" refers to the rate at which new individuals are born in a particular group of organisms during a specific period of time.

[1188] "Mortality rate" refers to the death rate of individuals in a particular group of organisms over a specific period of time.

[1189] "Emotional state" refers to the psychological and emotional state that the user is currently experiencing, and includes things like stress and relaxation.

[1190] "Means of visual display" refers to technologies that display simulation results in a graphical format, providing information to users visually.

[1191] "Means of dynamic adjustment" refers to a function in which the system changes variables in real time, altering the content and speed according to the user's emotional state and the progress of the simulation.

[1192] "Year-to-year changes" refers to fluctuations in the population size and other related data of a biological group from year to year.

[1193] The present invention provides a system for managing multiple organisms and simulating changes in the population size of each organism in order to conduct ecosystem simulations. Specific embodiments of the present invention will be described step by step below.

[1194] System initialization

[1195] The server first initializes classes for ecosystem management and organism management. This system is implemented using the Python programming language. For example, the Ecosystem class manages the list of organisms in the ecosystem and controls the progress of the simulation. The Animal class holds the species name and population size of each organism and manages birth and death data.

[1196] Adding organisms

[1197] Users can specify which organisms to include in the ecosystem. For example, to include rabbits and foxes in the simulation, you would create instances of each organism as classes and add them to the Ecosystem class.

[1198] Using an Emotion Engine

[1199] The server receives input from the user's sensor devices, and the emotion engine analyzes this to recognize the user's emotional state. This emotion engine uses the EmotionEngine library. For example, if the user is stressed, the system will adjust the simulation speed or moderate the fluctuations of the displayed organisms.

[1200] Start of simulation

[1201] The terminal instructs the server to start a simulation spanning a specified number of years. The server runs the simulation year by year, visualizing the changes from year to year. Specifically, it randomly sets birth and death rates and calculates the fluctuations in the population of the organism.

[1202] Display and Interaction

[1203] The server displays the population size of organisms for each year through a graphical user interface, providing users with visual information. This allows users to visually observe fluctuations in the population sizes of animals within an ecosystem.

[1204] Specific example

[1205] For example, if running a 10-year simulation, the initial rabbit population is set at 100 in the first year. The server assumes a birth rate of 15% and a death rate of 10% in the first year, increasing the population to 115. Next, in the second year, a new birth rate of 20% and a death rate of 5% are set, increasing the population to 138. If the emotion engine detects that the user is in a stressed state, the server slows down the rate of population change.

[1206] Example of a prompt

[1207] The following prompt messages are used to explain the simulation status to the user.

[1208] Let's begin the simulation. The initial number of rabbits is 100, and the initial number of foxes is 30. The fluctuations for each year will be displayed, so don't miss the changes in their emotions as you progress to the next year.

[1209] Thus, the system of the present invention provides an interactive, real-time ecosystem simulation based on the user's emotional state.

[1210] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1211] Step 1: User adds organism

[1212] The user specifies the organisms to include in the ecosystem. For example, by selecting rabbits and foxes, instances of each organism will be created as Animal class instances and added to the Ecosystem class. The input requires the species name and initial population size of each organism, and the output is the addition of the organisms to the Ecosystem class.

[1213] Step 2: Initializing the Emotion Engine

[1214] The server initializes the emotion engine. This emotion engine uses the EmotionEngine library to analyze and recognize the user's emotional state in real time. The input is raw data from sensor devices, and the output is the analyzed user's emotional state.

[1215] Step 3: Start the simulation

[1216] The terminal instructs the server to start a simulation for the specified number of years. At this point, the server sets the initial parameters of the simulation. The input is the number of years for the simulation period, and the output is the trigger for starting the simulation.

[1217] Step 4: Setting birth and death rates

[1218] The server randomly sets the birth and death rates for each organism for each year. The input is randomly generated values ​​for each year, and the output is the birth and death rates for each organism for each year.

[1219] Step 5: Annual fluctuations in population size

[1220] The server calculates the annual population fluctuations of each organism based on the set birth and death rates. The inputs are the initial population size and the birth and death rates for each organism, and the output is the updated population size.

[1221] Step 6: Adjustments based on user sentiment

[1222] The server analyzes the user's emotional state and dynamically adjusts the simulation speed and content. If the user is stressed, the simulation speed is slowed down; if relaxed, it is sped up. The input is the analyzed user's emotional state, and the output is the adjusted simulation speed.

[1223] Step 7: Displaying the simulation results

[1224] The server visually displays the annual fluctuations in the population size of organisms. A graphical user interface is used for this. The input is population data for each year, and the output is the visual simulation result.

[1225] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1226] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1227] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the robot 414.

[1228] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1229] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[1230] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[1231] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[1232] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[1233] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is the emotion around the positive "desire" on the reaction side. In other words, it is when the robot has positive feelings such as "I want more" or "I want to know more."

[1234] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​representing each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple training data sets, which are combinations of user input and emotion values ​​representing each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions located close together have similar values, as shown in the emotion map 900 in Figure 10. Figure 10 shows an example where multiple emotions such as "reassured," "calm," and "confident" have similar emotion values.

[1235] The above description primarily focuses on the functions of the data processing device 12 in relation to this disclosure. However, the system related to this disclosure is not necessarily implemented on a server. The system related to this disclosure may be implemented as a general information processing system. This disclosure may be implemented, for example, as a software program that runs on a personal computer or as an application that runs on a smartphone. The method related to this disclosure may be provided to users in SaaS (Software as a Service) format.

[1236] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing of the specific process may be performed by multiple computers, including computer 22. For example, a data generation model 58 may be provided in an external device of the data processing device 12, and the external device may generate data according to the input data.

[1237] In the above embodiment, an example was given in which the specific processing program 56 is stored in the storage 32, but the technology of this disclosure is not limited thereto. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-temporary storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-temporary storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes specific processing according to the specific processing program 56.

[1238] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1239] Furthermore, it is not necessary to store the entirety of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store the entirety of the specific processing program 56 in the storage 32; it is acceptable to store only a portion of the specific processing program 56.

[1240] The following types of processors can be used as hardware resources to perform specific processing. Examples of processors include a CPU, a general-purpose processor that functions as a hardware resource to perform specific processing by executing software, i.e., a program. Other examples of processors include dedicated electrical circuits, such as FPGAs (Field-Programmable Gate Arrays), PLDs (Programmable Logic Devices), or ASICs (Application Specific Integrated Circuits), which have circuit configurations specifically designed to perform specific processing. All of these processors have built-in or connected memory, and all of them perform specific processing by using memory.

[1241] The hardware resource that performs a specific process may consist of one of these various processors, or it may consist of a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Alternatively, the hardware resource that performs a specific process may consist of a single processor.

[1242] Examples of configurations using a single processor include, firstly, a configuration in which one or more CPUs and software are combined to form a single processor, and this processor functions as a hardware resource that performs a specific process. Secondly, there is a configuration using a processor that realizes the functions of the entire system, including multiple hardware resources that perform a specific process, on a single IC chip, as exemplified by SoCs (System-on-a-chip). In this way, a specific process is realized using one or more of the above types of processors as hardware resources.

[1243] Furthermore, the hardware structure of these various processors can more specifically utilize electrical circuits that combine circuit elements such as semiconductor devices. Also, the specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps can be deleted, new steps added, or the processing order rearranged, as long as it does not deviate from the main purpose.

[1244] The descriptions and illustrations presented above are detailed explanations of the technical aspects of this disclosure and are merely examples of the technical aspects. For example, the above descriptions of the structure, function, operation, and effect are examples of the structure, function, operation, and effect of the technical aspects of this disclosure. Therefore, it goes without saying that you may delete unnecessary parts, add new elements, or replace elements in the descriptions and illustrations presented above, as long as you do not deviate from the essence of the technical aspects of this disclosure. Furthermore, in order to avoid confusion and facilitate understanding of the technical aspects of this disclosure, explanations of common technical knowledge and the like that do not require special explanation to enable the implementation of the technical aspects of this disclosure have been omitted from the descriptions and illustrations presented above.

[1245] All documents, patent applications, and technical standards described herein are incorporated by reference to the same extent as if each individual document, patent application, and technical standard were specifically and individually noted as being incorporated by reference.

[1246] The following is further disclosed regarding the embodiments described above.

[1247] (Claim 1)

[1248] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem,

[1249] A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate,

[1250] A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms,

[1251] A system including means for performing a simulation at predetermined time intervals to mimic the passage of time.

[1252] (Claim 2)

[1253] The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

[1254] (Claim 3)

[1255] The system according to claim 1, wherein each of the organisms includes a different species and has means for separately tracking changes in the population size between species.

[1256] "Example 1"

[1257] (Claim 1)

[1258] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem,

[1259] Means for initializing a class for managing each of the aforementioned organisms,

[1260] A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate,

[1261] A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms,

[1262] A means for running a simulation at predetermined time intervals to simulate the passage of time,

[1263] Means for graphically displaying the results of the aforementioned simulation,

[1264] After the simulation is completed, the system state is saved and the system is terminated normally.

[1265] A system that includes this.

[1266] (Claim 2)

[1267] The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

[1268] (Claim 3)

[1269] The system according to claim 1, wherein each of the organisms includes a different species and has means for separately tracking changes in the population size between species.

[1270] "Application Example 1"

[1271] (Claim 1)

[1272] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem,

[1273] A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate,

[1274] A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms,

[1275] A means for running a simulation at predetermined time intervals to simulate the passage of time,

[1276] A means for simulating fluctuations in inventory levels for each product based on the product replenishment rate and consumption rate,

[1277] A means of displaying changes in inventory at physical stores and issuing replenishment orders,

[1278] A system that includes this.

[1279] (Claim 2)

[1280] The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

[1281] (Claim 3)

[1282] The system according to claim 1, wherein each of the organisms includes a different species and has means for separately tracking changes in the population size between species.

[1283] "Example 2 of combining an emotion engine"

[1284] (Claim 1)

[1285] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem,

[1286] A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate,

[1287] A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms,

[1288] A means for running a simulation at predetermined time intervals to simulate the passage of time,

[1289] It includes an emotion engine that analyzes input from sensor devices to recognize the user's emotional state, and means for dynamically adjusting the simulation according to the user's emotional state,

[1290] A system that includes this.

[1291] (Claim 2)

[1292] The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

[1293] (Claim 3)

[1294] The system according to claim 1, wherein each of the organisms includes a different species and has means for separately tracking changes in the population size between species.

[1295] "Application example 2 when combining with an emotional engine"

[1296] (Claim 1)

[1297] A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem,

[1298] A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate,

[1299] A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms,

[1300] A means for running a simulation at predetermined time intervals to simulate the passage of time,

[1301] A means to analyze the user's emotional state and dynamically adjust the speed and content of the simulation,

[1302] A means of visually displaying the simulation results,

[1303] A system that includes this.

[1304] (Claim 2)

[1305] The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

[1306] (Claim 3)

[1307] The system according to claim 1, wherein each of the organisms includes a different species and has means for separately tracking changes in the population size between species. [Explanation of Symbols]

[1308] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots< / url:> < / url:> < / url:> < / url:>

Claims

1. A system having a computer program that manages multiple organisms and simulates changes in the population size of each organism in order to mimic an ecosystem, A means for calculating the fluctuations in the population of the organism based on the birth rate and death rate, A means for displaying the year-to-year changes in the population size of each of the aforementioned organisms, A system including means for performing a simulation at predetermined time intervals to mimic the passage of time.

2. The system according to claim 1, further comprising means for randomly setting the birth rate and death rate to more realistically simulate year-to-year changes.

3. The system according to claim 1, wherein each of the organisms includes different species and has means for separately tracking changes in the population size between species.

Images