System

Abstract

A system is provided.SOLUTION: A method for simulating social influence of a policy, the method comprising: establishing a policy through a user terminal; transmitting policy data to a server; storing the policy data received by the server in a database; acquiring correlation data required to simulate social influence of the policy; performing a simulation based on the acquired correlation data and the policy data; generating a simulation result and transmitting the simulation result to the user terminal; and displaying the simulation result received by the user terminal. The system includes a means for notifying the user terminal of the information, a means for participating in the election and voting through the user terminal, and a means for totalizing voting results in the server and notifying the election result.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the 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] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] Apathy and lack of understanding of politics are serious problems among young people today, leading to low voter turnout and a decline in social participation. Furthermore, limited opportunities to understand the real political process make it difficult for them to become involved in or interested in politics. For this reason, a new approach is needed that allows young people to understand politics while having fun learning, and promotes their social participation. [Means for solving the problem]

[0005] The present invention provides an educational support system that allows users to formulate policies, operate a virtual government, and participate in elections. This system includes a means for inputting policies through a user terminal, a means for transmitting policy data to a server, a means for storing the received policy data in a database, a means for acquiring correlation data, a means for running a simulation, a means for generating and transmitting simulation results to the user terminal, a means for visually displaying the results, a means for hosting and announcing election events, a means for participating in and voting in elections, and a means for tallying votes and announcing election results. This allows users to understand the impact of policies on society in real time and increase their interest in politics. Furthermore, the quality of learning is improved by accurately simulating the impact of policies using an AI model.

[0006] "User terminal" means a device used by a user to formulate policies and display simulation results and election information.

[0007] "Policy data" refers to information on policy content, details, target groups, etc. formulated by users.

[0008] The "server" is a central control device that receives policy data sent from user terminals, stores it in a database, obtains correlation data, and executes simulations.

[0009] "Database" means a data management system for storing policy data and correlation data.

[0010] "Correlation data" refers to data that includes past statistical data and related information necessary to simulate the social impact of policies.

[0011] "Simulation" is the process of using AI models to perform calculations and analysis to predict the impact of policies on society.

[0012] "Simulation results" are predicted data on the social impact of a policy obtained by running a simulation.

[0013] An "election event" refers to the holding of a virtual election in which users can promote their own policies and vote for the policies of other users.

[0014] "Voting Results" refers to aggregated data of user votes, which indicates the results of an election event.

[0015] "Election Results" are the final election results generated based on the voting results. [Brief explanation of the drawings]

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

[0017] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0018] First, the terms used in the following description will be explained.

[0019] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0020] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

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

[0022] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0023] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0024] [First embodiment]

[0025] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0026] 1, a 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.

[0027] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0029] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the 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.

[0030] 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 of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0031] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

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

[0033] 2, in the data processing device 12, a specific process 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" according to the technology of the present 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 process 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.

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

[0035] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[0037] This invention relates to an educational support system that allows users to formulate policies, run a virtual government, and participate in elections. The system comprises the following components:

[0038] 1. User Device

[0039] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through an interface and send policy data directly from the terminal to the server. The terminal also visually displays received simulation results and election notifications to users.

[0040] 2. Server

[0041] The server receives policy data sent from user devices and stores it in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[0042] 3. Database

[0043] The database is for storing policy data and correlation data, including historical statistical data and related information necessary for simulating the social impact of policies.

[0044] 4. AI Simulation Engine

[0045] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are generated and sent to the user's device.

[0046] Program processing

[0047] Policy formulation

[0048] The user inputs a new policy using the device interface. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[0049] Receiving and storing data

[0050] The server receives the policy data sent to it and stores it in a database, which is used later in the simulation process.

[0051] Correlated Data Acquisition and Simulation

[0052] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, the server uses an AI simulation engine to predict the social impact of policies.

[0053] Notification and display of simulation results

[0054] When the simulation is complete, the server generates the results and sends them to the user's device, which then visually displays the received simulation results. For example, the result might be, "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0055] The Election Process

[0056] The server periodically holds election events and notifies user devices of the information. Users use their devices to participate in elections and promote their policies to other users. Users can evaluate the policies of other users and vote via their devices. The server tally the voting results of all users, generate election results, and notify the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[0057] Through this system, users can learn by experiencing everything from policy formulation to elections in a virtual environment that models the real political process, which will contribute to improving political understanding and social participation, especially among young people.

[0058] The processing flow will be explained below.

[0059] Step 1:

[0060] The user inputs the policy into the device interface. The user inputs information such as the policy name, details, and target group into the device.

[0061] Step 2:

[0062] The terminal sends the policy data entered by the user to the server, and the terminal formats the policy data in an appropriate format and generates a request to send it to the server.

[0063] Step 3:

[0064] The server receives the policy data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[0065] Step 4:

[0066] The server stores the received policy data in a database, and assigns an ID to the database so that the stored policy data can be uniquely identified.

[0067] Step 5:

[0068] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[0069] Step 6:

[0070] The server generates a dataset for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[0071] Step 7:

[0072] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[0073] Step 8:

[0074] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[0075] Step 9:

[0076] The server transmits the generated simulation results to the user terminal, and the server generates a request to package the simulation results into an appropriate format and transmit them to the user terminal.

[0077] Step 10:

[0078] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[0079] Step 11:

[0080] The simulation results received by the user device are visually displayed, showing specific results such as "a 5% expected improvement in academic performance due to an increase in the education budget."

[0081] Step 12:

[0082] The server periodically holds election events and notifies the terminals of the information. The server generates notifications to inform users of the election event times and related information.

[0083] Step 13:

[0084] Users use their devices to participate in elections and promote their policies. Users input appeal information to present the benefits and data of their policies to other users.

[0085] Step 14:

[0086] The device sends the appeal information entered by the user to the server, where it is managed so that it can be displayed to other users.

[0087] Step 15:

[0088] Users use their devices to vote for policies of other users. Users evaluate and vote for policies formulated by other users.

[0089] Step 16:

[0090] The server tally the votes of all users and generate the election results. The server analyzes the voting data and identifies the most popular policy.

[0091] Step 17:

[0092] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[0093] Step 18:

[0094] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[0095] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The system aims to contribute to improving political understanding and social participation, especially among young people.

[0096] Example 1

[0097] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0098] In modern society, political education, especially for young people, offers few opportunities to experience the actual political process, resulting in low levels of political understanding and a sense of social participation. Furthermore, there is a lack of simulation tools to concretely understand the impact of policies, and there is no system that provides a consistent experience from policy formulation to electoral participation.

[0099] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0100] In this invention, the server includes a means for a user terminal to access and log in to the system via a browser or a dedicated application, a means for packetizing policy data and sending it to the server via HTTPS, a means for the server to receive the policy data at an API endpoint, and a means for visually displaying simulation results in graphs or text format. This allows users to learn through hands-on experience in a virtual environment the entire political process, from policy formulation to simulating its social impact, and even policy evaluation and voting in elections, thereby improving their understanding of politics and their sense of social participation.

[0101] A "user terminal" is a device used by a user to perform operations such as formulating policies, displaying simulation results, and participating in elections.

[0102] A "server" is a computer system that receives policy data sent from user terminals, stores it in a database, runs simulations based on correlation data, and performs other tasks such as holding election events and tallying voting results.

[0103] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0104] A "database" is a collection of data managed on a server, and is an area where policy data, correlation data, etc. are stored.

[0105] "Correlation data" refers to past statistical data and related information necessary to simulate the social impact of policies.

[0106] The "AI simulation engine" is a system equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[0107] "Simulation results" are predictive data generated by an AI simulation engine that shows how a particular policy will affect society.

[0108] An "election event" is an event in which users vote in a virtual environment based on policies proposed by users to determine the most popular policy.

[0109] "Voting results" are the aggregated results of users' votes at election events, and are data showing which policies received how much support.

[0110] The "HTTPS protocol" is a communication method for securely sending and receiving data over the Internet.

[0111] An "API endpoint" is a URL on a server that can be accessed by external systems to provide a specific function.

[0112] This invention relates to an educational support system that allows users to formulate policies, manage a virtual government, and participate in elections. The system includes a user terminal, a server, a database, and an AI simulation engine.

[0113] The user terminal is a device used by users to formulate policies, view simulation results, participate in elections, and perform other operations. Specifically, users can access the system and log in to their own accounts using a browser or a dedicated application. Users enter the policy name, details, target group, etc. through the policy formulation interface and click the "Submit" button to send the policy data to the server. The policy data is packetized in JSON format and securely sent to the server via the HTTPS protocol.

[0114] The server is the central component that processes the received policy data. The server receives the policy data via the API endpoint, parses it, and stores it in a database. The stored policy data is later used for simulations. The server also retrieves correlation data from the database, which is necessary to simulate the social impact of policies. The correlation data includes historical statistical data and related information.

[0115] The AI ​​simulation engine is equipped with artificial intelligence to predict the social impact of policies based on policy data and correlation data. The server passes the acquired correlation data and policy data to the AI ​​simulation engine, which then runs the simulation. The resulting simulation results are returned to the server, converted back to JSON format, and sent to the user's device.

[0116] The user device has the function of visually displaying the simulation results. It parses the received simulation results and displays them visually in graphs and text format. For example, it displays specific results such as "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0117] The server also periodically holds election events. It uses a scheduler to set the timing of election events and sends notifications to all users. Users can view and evaluate the policies of other candidates, then vote for their choice. The server aggregates the voting results of all users and generates election results, such as "Policy 'Increase education budget' received the most votes." These election results are again notified to user devices and displayed visually.

[0118] As a concrete example, when a user formulates an "environmental protection policy," they input the policy details as "increasing the investment rate in renewable energy, strengthening forest conservation activities, and improving waste recycling rates." Simulation results are displayed such as "investment in renewable energy will increase the region's energy self-sufficiency rate by 15% and reduce carbon emissions by 10%." During the election process, the server notifies users of the results, such as "The environmental protection policy received the most votes in the user vote and will be adopted as the next policy."

[0119] An example of a prompt is as follows:

[0120] "Simulate how an increase in the education budget would affect society."

[0121] "You have proposed a policy to increase the share of investment in renewable energy to 50%. Simulate the social impact of this policy and display the results."

[0122] In this way, the present invention provides a system that allows users to experience the political process in a virtual environment through a series of processes including policy planning, simulation, and elections, thereby improving their understanding of politics and their sense of social participation.

[0123] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0124] Step 1:

[0125] The user starts up the device and logs in using a browser or a dedicated application. As input, the user enters their account information (username and password). The server executes the authentication process and outputs the success or failure of user authentication. Specifically, if authentication is successful, the policy formulation interface is displayed to the user.

[0126] Step 2:

[0127] The user inputs a new policy using the policy formulation interface. As input, the user enters the policy name, details, target group, etc. When the user clicks the "Submit" button, the user terminal packets the entered policy data into JSON format and sends it to the server via the HTTPS protocol. As output, the policy data is sent.

[0128] Step 3:

[0129] The server receives the policy data. Specifically, the server waits for POST requests at a specific API endpoint and parses the received data. It receives JSON-formatted policy data as input and obtains the parsed policy data as output.

[0130] Step 4:

[0131] The server stores the received policy data in the database. Specifically, the server executes an insert query to store the parsed policy data in the database. It receives the parsed policy data as input and adds a new record to the database as output.

[0132] Step 5:

[0133] The server retrieves correlation data from the database. Specifically, the server uses a SELECT query to retrieve the data needed to simulate the impact of policies from the "CorrelationData" table, which stores past statistical data. As input, the conditions for the correlation data to be retrieved are specified, and as output, the correlation data is obtained.

[0134] Step 6:

[0135] The server passes the acquired correlation data and policy data to the AI ​​simulation engine. Specifically, the server sends the policy data and correlation data to the AI ​​simulation engine's API. It receives the policy data and correlation data as input and sends the simulation prompt and data to the AI ​​simulation engine as output.

[0136] Step 7:

[0137] The AI ​​simulation engine simulates the social impact of policies and generates results. Specifically, the AI ​​simulation engine predicts the impact based on the data it receives and generates results. It receives policy data and correlation data as input and generates simulation results as output.

[0138] Step 8:

[0139] The server receives the simulation results from the AI ​​simulation engine and sends them to the user device. Specifically, the server converts the simulation results back into JSON format and sends them to the user device. The server receives the simulation results from the AI ​​simulation engine as input and sends them to the user device as output.

[0140] Step 9:

[0141] The user terminal visually displays the received simulation results. Specifically, the user terminal parses the JSON format data and displays it on the screen in graph or text format. It receives the simulation result data as input and visually displays it to the user as output.

[0142] Step 10:

[0143] The server periodically holds election events and notifies user terminals of the information. Specifically, the server sends election start notifications to all users based on a pre-set schedule. The server receives schedule information as input and sends notifications to user terminals as output.

[0144] Step 11:

[0145] Users participate in elections, advocate for their policies, and cast their votes. Specifically, users view and evaluate the policies of other users, and then vote. The system receives other users' policy information and voting options as input, and transmits the voting results as output.

[0146] Step 12:

[0147] The server tally the votes of all users and generate the final election results. Specifically, the server retrieves the voting data from the database and calculates the results using a tallying algorithm. It receives each user's voting data as input and obtains the tally results as output.

[0148] Step 13:

[0149] The server notifies the user device of the election results, which are then displayed visually. Specifically, the server converts the results into JSON format and sends them to the user device, which then displays them on the screen. The server receives the results as input and visually notifies the user as output.

[0150] (Application example 1)

[0151] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0152] One issue is the lack of systems that model the real political process and allow users to experience and learn about the entire process from policy formulation to elections. There is a particular lack of educational support systems aimed at improving young people's understanding of politics and their sense of social participation. Furthermore, there are no adequate mechanisms for evaluating policies through competition and cooperation among users.

[0153] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0154] In this invention, the server includes a means for allowing users to formulate policies as managers of a virtual city and simulate their impact, a means for holding elections among users and evaluating the policies, and a user terminal includes a means for formulating policies and receiving and displaying the results of the simulation, a means for notifying users of election information, and a means for participating in and voting in elections. This enables users to deepen their understanding of politics through policy formulation in a virtual environment, simulating its social impact, and the election process.

[0155] A "user terminal" is a device that provides functions such as formulating policies, receiving and displaying simulation results, notifying election information, and participating in and voting in elections.

[0156] A "server" is a device whose role is to receive policy data sent from user terminals, store it in a database, simulate the social impact of policies, hold election events, and notify the user terminals of that information.

[0157] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0158] A "database" is a storage device for storing policy and correlation data received by a server.

[0159] "Correlation data" refers to data that includes past statistical data and related information that is necessary to simulate the social impact of policies.

[0160] An "AI simulation engine" is an artificial intelligence engine used to predict the social impact of a policy based on policy data and correlation data.

[0161] "Simulation results" are predictive data generated by the AI ​​simulation engine about the impact of specific policies on society.

[0162] An "election event" is an election activity conducted by a user to receive evaluations from other users regarding policies formulated by the user.

[0163] "Voting results" refers to the aggregated results of votes cast by all users in the election event.

[0164] "Virtual city management" is a process in which users act as managers of a virtual city, drafting policies and simulating their social impact.

[0165] The invention is implemented as a virtual city management simulator application, in which users access the simulator and, as managers of a virtual city, formulate various policies, simulate their social impact, and participate in the election process.

[0166] System Configuration

[0167] The system mainly consists of the following components:

[0168] 1. User Device

[0169] Provide an interface for formulating policy.

[0170] Displays simulation results, election information, etc.

[0171] Providing a means for users to participate in elections and cast their votes.

[0172] 2. Server

[0173] Receives policy data sent by users and stores it in a database.

[0174] Obtain the necessary correlation data and simulate the social impact of policies using an AI simulation engine.

[0175] Simulation results are generated and sent to the user terminal.

[0176] Election events will be held periodically and information about them will be sent to users' devices.

[0177] The voting results for each election event will be tallied and the election results will be announced.

[0178] 3. Database

[0179] Stores policy and correlation data.

[0180] Correlated data includes historical statistical data and related information.

[0181] 4. AI Simulation Engine

[0182] It is used to predict the social impact of policies based on policy data and correlation data formulated by users.

[0183] The specific hardware and software used

[0184] Server: Web server using Flask

[0185] Database: SQLite

[0186] AI Simulation Engine: Linear Regression Models Using Scikit-learn

[0187] Program processing explanation

[0188] The server is operated using a web server framework called Flask and stores policy data and correlation data in an SQLite database. Policy data sent from user devices is received by the server and saved in the database. The server then uses the saved policy data and correlation data to run an AI simulation engine (here, a Linear Regression model from Scikit-learn) to predict the impact of policies on society.

[0189] Simulation results are generated by the server and sent to the user's device. The received simulation results are visually displayed on the user's device. The server also periodically holds election events and notifies the user's device. Users can participate in elections via their device, evaluate other users' policies, and cast their votes. The voting results are tallied by the server and notified to the user's device.

[0190] Specific examples

[0191] When a user proposes a policy such as "increasing the education budget," the device sends the policy data to the server. The server stores the policy data in a database and performs a simulation based on correlation data. The result is that "increasing the education budget is expected to improve academic performance by 5% in the next year," which is displayed on the user's device.

[0192] Example prompt sentence:

[0193] "Simulate the impact of increasing the education budget by 10%."

[0194] In this way, users can experience everything from policy formulation to simulation and the electoral process, virtually learning about the processes involved in the formation of politics and policies.

[0195] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0196] Step 1:

[0197] The user inputs the policy on the terminal and sends it to the server. The user uses the terminal interface to create a new policy and input its details. The input policy data (policy name, details, target group, etc.) is sent from the terminal to the server. The input data is the basic information of the policy.

[0198] Step 2:

[0199] The server receives the policy data and stores it in a database. The server receives the policy data sent from the terminal and stores the data in an SQLite database. The received data is detailed policy information, and the saving operation persists the data.

[0200] Step 3:

[0201] The server retrieves the necessary correlation data from the database. The server retrieves past statistical data and related information needed to simulate the social impact of policies from the database. The retrieved data is statistical data on the effects of past policies, etc.

[0202] Step 4:

[0203] The server runs a simulation based on policy data and correlation data. Using an AI simulation engine (using a Linear Regression model), the server inputs the acquired policy data and correlation data and performs data calculations to predict the social impact of the policy. The input data are policy data and correlation data, and the output is the simulation results for predicting the impact of the policy.

[0204] Step 5:

[0205] The server generates the simulation results and sends them to the user terminal. The simulation results (e.g., "An increase in the education budget is expected to improve academic performance by 5% in the next year") are generated by the server and sent to the user terminal. The output data are the simulation results.

[0206] Step 6:

[0207] The user terminal visually displays the simulation results received. The user terminal visually displays the simulation results received from the server in an easy-to-read manner. The display operation is the visualization of data.

[0208] Step 7:

[0209] The server periodically holds election events and notifies user terminals of the information. The server generates information about election events that are periodically held and notifies user terminals of the information. The notification data is detailed information about the election events.

[0210] Step 8:

[0211] Users participate in elections and vote through their devices. Users evaluate policies proposed by other users and cast their votes through their devices. The input data is the user's voting information.

[0212] Step 9:

[0213] The server tally the voting results and notify the election results. The server tally the voting data sent by all users and generate the election results. These election results are notified to the user terminals. The output data is the election results.

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

[0215] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections, and also combines it with an emotion recognition engine that recognizes user emotions. The system consists of the following components:

[0216] 1. User Device

[0217] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through the interface and send policy data directly to the server from the terminal. It also has an emotion recognition engine that analyzes the user's facial expressions and tone of voice to recognize their emotions.

[0218] 2. Server

[0219] The server receives policy data and emotion data sent from user devices and stores them in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[0220] 3. Database

[0221] The database is intended to store policy data, correlation data, and sentiment data. The correlation data includes historical statistical data and related information necessary for simulating the social impact of policies, while the sentiment data records user reactions.

[0222] 4. AI Simulation Engine

[0223] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are automatically generated and sent to the user's device.

[0224] 5. Emotion Recognition Engine

[0225] The emotion recognition engine is installed on the user's device and recognizes emotions by analyzing the user's facial expressions and tone of voice. This data is used for policy simulations and election results analysis, and is used to customize the display of results.

[0226] Program processing

[0227] Policy formulation

[0228] The user inputs a new policy through the device interface and sends the policy data to the server. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[0229] Acquiring emotion data

[0230] The emotion recognition engine analyzes the user's facial expressions and tone of voice to generate emotion data. For example, it can recognize whether the user is feeling stressed when entering a policy. The generated emotion data is simultaneously sent to the server.

[0231] Receiving and storing data

[0232] The server receives the policy data and emotion data and stores them in a database for later use in simulations and result analysis.

[0233] Correlated Data Acquisition and Simulation

[0234] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, an AI simulation engine is used to predict the social impact of policies.

[0235] Notification and display of simulation results

[0236] Once the simulation is complete, the server generates results and sends them to the user's device in a format customized based on the user's emotional data. For example, if the user is feeling stressed, the results are displayed in an easy-to-understand format. The user's device visually displays the received simulation results to the user. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed.

[0237] The Election Process

[0238] The server periodically holds election events and notifies user devices of this information. Users use their devices to participate in elections and appeal their policies to other users. Users can present their policies while observing the reactions of other users through an emotion recognition engine. The device sends the appeal information entered by the user to the server, which other users can then evaluate and vote for. The server tallys the voting results of all users, generates the election results, and notifies the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[0239] Through this system, users can experience the process from policy formulation to elections and understand its impact on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, enhancing user understanding and engagement. This is expected to improve political understanding and social participation, especially among young people.

[0240] The processing flow will be explained below.

[0241] Step 1:

[0242] The user inputs the policy into the device interface. The user inputs information such as the policy name (e.g., "Increase the education budget"), details, and target group into the device.

[0243] Step 2:

[0244] The device analyzes the user's facial expressions and tone of voice to generate emotional data, and the emotion recognition engine determines whether the user is stressed or excited.

[0245] Step 3:

[0246] The terminal sends the input policy data and generated emotion data to the server, which then formats the data appropriately and generates a request to send to the server.

[0247] Step 4:

[0248] The server receives the policy data and emotion data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[0249] Step 5:

[0250] The server stores the received policy data and emotion data in a database, where IDs are assigned so that the policy data and emotion data can be uniquely identified.

[0251] Step 6:

[0252] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[0253] Step 7:

[0254] The server generates a data set for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[0255] Step 8:

[0256] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[0257] Step 9:

[0258] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[0259] Step 10:

[0260] The server sends the generated simulation results to the user terminal, and the server packages the simulation results in an appropriate format and generates a request to send them to the user terminal.

[0261] Step 11:

[0262] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[0263] Step 12:

[0264] The simulation results received by the user's device are visually displayed. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed. The display is also customized to the user based on emotional data.

[0265] Step 13:

[0266] The server periodically holds election events and notifies the terminal of the information. The server generates notifications to inform users of the election event time and related information.

[0267] Step 14:

[0268] Users use their devices to participate in elections and promote their policies. Users input presentation information to promote their policies to other users.

[0269] Step 15:

[0270] The device sends the presentation information and emotion data entered by the user to the server, which stores the data and makes it available to other users.

[0271] Step 16:

[0272] Users use their devices to vote for other users' policies. Users evaluate the presented policy information and send their voting data from their devices.

[0273] Step 17:

[0274] The server aggregates the votes of all users and generates the election results. The server analyzes the aggregated voting data and identifies the policy that received the most support.

[0275] Step 18:

[0276] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[0277] Step 19:

[0278] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[0279] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, improving user understanding and engagement. This is expected to improve young people's understanding of politics and their sense of social participation.

[0280] Example 2

[0281] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0282] In modern society, young people are expected to take an interest in politics and policy and to actively participate in it. However, understanding policy-making and its social impact is not easy, and many young people are reluctant to participate in politics. An educational support system is needed to solve this problem and improve young people's understanding of politics and their awareness of social participation.

[0283] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0284] In this invention, the server includes: means for formulating policies through a user terminal; means for transmitting policy data to the server; means for acquiring user emotion data in the user terminal and transmitting it to the server; means for storing the received policy data and emotion data in a database in the server; means for acquiring correlation data necessary for simulating the social impact of policies in the server; means for running a simulation based on the acquired correlation data and policy data in the server; means for generating simulation results in the server, customizing them based on the emotion data, and transmitting them to the user terminal; means for visually displaying the received simulation results in the user terminal; means for periodically holding an election event in the server and notifying the user terminal of the information; means for participating in elections and voting through the user terminal; and means for tallying vote results in the server and notifying the user of the election results. This allows young people to experience the process from policy formulation to elections in real time and receive feedback based on their emotions, thereby improving their understanding of politics and their sense of social participation.

[0285] A "user terminal" is a device used by a user to input policies and display simulation results and election information.

[0286] "Policy data" is data containing information about policies formulated by users, including policy names, details, target groups, etc.

[0287] "Emotion data" refers to data that includes information about emotions obtained by analyzing a user's facial expressions and tone of voice.

[0288] The "server" is a central computer that receives policy data and emotion data from user terminals, stores them in a database, obtains correlation data, and runs simulations.

[0289] "Database" is an information management system for storing policy data, emotion data, and correlation data.

[0290] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[0291] The "AI simulation engine" is a program equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[0292] "Simulation results" are predicted data on the social impact of policies generated by the AI ​​simulation engine.

[0293] An "election event" is an event that involves a user virtually participating in an election, promoting their own policies, and receiving votes from other users.

[0294] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections. It also incorporates an emotion recognition engine that recognizes user emotions. The system is implemented by combining the following main components and operations:

[0295] System configuration and functions

[0296] 1. User Device

[0297] A user terminal is a device used by users to input policies and display simulation results and election information. Specifically, this includes PCs, smartphones, and tablets. The terminal is equipped with an emotion recognition engine that analyzes the user's facial expressions and tone of voice. This generates user emotion data.

[0298] 2. Server

[0299] The server receives policy data and emotion data sent from user devices and stores them in a database. The server then retrieves correlation data from the database to simulate the social impact of policies and runs the simulation using an AI simulation engine.

[0300] 3. Database

[0301] The database is an information management system that stores policy data, sentiment data, and correlation data. The correlation data includes historical statistical data and related information and is used to simulate the social impact of policies.

[0302] 4. AI Simulation Engine

[0303] The AI ​​simulation engine is a program that predicts the social impact of policies based on policy data and correlation data. The simulation results are customized based on the user's emotional data and sent to the user's device.

[0304] 5. Emotion Recognition Engine

[0305] The emotion recognition engine is installed on the user's device and generates emotional data by analyzing the user's facial expressions and tone of voice, which is used for policy simulations and election results analysis.

[0306] Use cases and specific steps

[0307] Below are the specific steps users can take to formulate new policies, simulate their impact, and participate in elections.

[0308] 1. Policy input

[0309] The user inputs a policy using the device interface. For example, to formulate a policy such as "increase the education budget by 10%," the user enters this into the device's text field and clicks the submit button.

[0310] 2. Acquiring Emotion Data

[0311] While entering the policy, the camera and microphone on the user's device capture the user's facial expressions and voice in real time, which are then analyzed by the emotion recognition engine to generate emotion data, such as "Stress level: High."

[0312] 3. Data transmission and storage

[0313] The device sends policy data and emotion data to the server, which receives them and stores them in a database.

[0314] 4. Running the Simulation

[0315] The server retrieves the necessary correlation data from the database and inputs it into the AI ​​simulation engine along with the policy data. The simulation is run and the social impact of the policy is predicted. For example, a result such as "Increasing the education budget will improve academic performance by 5%" is generated.

[0316] 5. Notification of simulation results

[0317] The simulation results are customized based on emotional data, for example, to be displayed in a more understandable format for users who are feeling stressed, and then sent to the user's device for visual display.

[0318] 6. Holding election events

[0319] The server periodically holds election events and sends information to user devices. Users appeal to other users about their policies and receive votes. They can also observe other users' reactions using an emotion recognition engine. Finally, the server tallys the votes and notifies users of the election results.

[0320] Prompt Sentence Examples

[0321] An example prompt might use the following text:

[0322] "Simulate how an increase in the education budget will affect student academic performance."

[0323] "Please provide data on the socio-economic impact of investments in the education sector over the past 10 years and analyze the correlations."

[0324] The system allows users to experience the process from policymaking to elections and understand its impact on society in real time. The system also incorporates an emotion recognition engine to provide personalized learning and feedback, helping users better understand politics and participate in society.

[0325] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0326] Step 1: Enter and submit policy data

[0327] The user inputs the policy using the terminal interface. The policy data includes the policy name, details, target group, etc. After inputting is complete, the user clicks the "Submit" button, which is sent to the terminal. The terminal then sends this policy data to the server.

[0328] Input: Policy data entered by the user into the interface.

[0329] Output: Policy data sent from the terminal to the server

[0330] Specific operation: For example, enter a policy such as "Increase the education budget by 10%" and click the send button. At this time, the policy data (the policy name "Increase the education budget by 10%" and details) is sent from the device to the server.

[0331] Step 2: Obtaining and sending emotion data

[0332] While the user is entering the policy, the device's camera and microphone capture the user's facial expressions and voice in real time. The emotion recognition engine analyzes this and generates the user's emotional data. The generated emotional data is then sent to the server along with the policy data.

[0333] Input: User facial expressions and tone of voice

[0334] Output: Emotion data sent to the server

[0335] Specific operation: During policy input, the camera and microphone capture the user's face and voice, and emotional data such as "stress level: high" and "happiness level: low" is generated and sent to the server.

[0336] Step 3: Receiving and storing data

[0337] The server receives the policy data and emotion data sent from the device and stores them in a database for later use in simulations and result analysis.

[0338] Input: Policy data and emotion data sent from the device

[0339] Output: Policy data and sentiment data stored in a database

[0340] Specific operation: The server checks the received policy data and emotion data and stores them appropriately in the database. This storage process allows for future reference.

[0341] Step 4: Obtain correlation data and run simulation

[0342] The server retrieves the correlation data needed to simulate the impact of policies from the database. This correlation data includes past statistical data and related information. The AI ​​simulation engine runs a simulation based on the retrieved correlation data to predict the social impact of policies.

[0343] Input: Correlation data and policy data retrieved from databases

[0344] Output: Simulation results

[0345] Specific operation: The server retrieves correlation data from the database, such as "the impact of past increases in education budgets on academic performance and the national economy," and based on this, the AI ​​simulation engine generates simulation results, such as "a 5% improvement in academic performance is expected."

[0346] Step 5: Generate and communicate simulation results

[0347] Once the simulation is complete, the server generates results and customizes them based on the user's emotional data. For example, if the user is feeling stressed, the results will be adjusted to be displayed in an easy-to-understand format. The generated results are sent to the user's device and displayed visually.

[0348] Input: Simulation results and emotion data

[0349] Output: Customized simulation results

[0350] How it works: The server generates simulation results and adjusts the display format based on emotional data (e.g., "Stress level: High"). The customized results are then sent to the user's device, where they are displayed, such as "Increasing the education budget will improve academic performance by 5%."

[0351] Step 6: Holding election events and announcing results

[0352] The server periodically holds election events and notifies users of the information on their devices. Users can use their devices to participate in elections and promote their policies to other users. During this process, the emotion recognition engine observes the reactions of other users and provides feedback. After the votes are cast, the server tallys the voting results of all users and notifies them of the results.

[0353] Input: Election information and user voting data

[0354] Output: Counted voting results

[0355] Specific operation: The server notifies the user that an election event has started, and the user creates and submits a policy appeal. The device analyzes other users' reactions in real time and provides feedback, such as "This policy is highly rated." Finally, the server tallies the voting results and notifies the user of the result, such as "Increasing the education budget received the most votes."

[0356] (Application example 2)

[0357] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0358] Current educational systems make it difficult for users to experience the entire political process, from policy formulation to the electoral process. Furthermore, the educational effectiveness is limited by the lack of ways for users to understand the social impact of policies in real time and receive individual feedback. Furthermore, systems that provide feedback tailored to the user's state through emotion recognition are also inadequate. Furthermore, when considering use in physical stores, creating an environment where a large number of users can use the system simultaneously presents a challenge.

[0359] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for formulating policies through a user terminal, means for transmitting policy data to the server, and means for storing the received policy data in a database. This enables users to formulate policies in physical stores and simulate their social impact in real time. In addition, by including means for acquiring user emotion data through an emotion recognition engine and customizing and displaying simulation results based on the emotion data, and means for the user to input policies through smart glasses and visually provide the displayed content, feedback can be provided according to the user's state, enhancing the effectiveness of education.

[0360] A "user terminal" is a device used by a user to input policies and display simulation results.

[0361] The "server" is a central processing unit that receives, stores, and processes policy data and emotion data, and generates and notifies the results of simulations.

[0362] "Policy data" is information about policies formulated by users, including details and target groups.

[0363] A "database" is an information storage system that stores policy data, sentiment data, and correlation data and makes them accessible when needed.

[0364] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[0365] The "AI simulation engine" is an artificial intelligence engine that predicts the social impact of policies based on policy data and correlation data, and generates simulation results.

[0366] An "emotion recognition engine" is software that analyzes a user's facial expressions and tone of voice and generates emotional data.

[0367] "Emotion data" is information about a user's emotions generated by an emotion recognition engine.

[0368] "Smart glasses" are wearable devices used to virtually provide policy formulation, display simulation results, and more.

[0369] An "election event" is an event that is periodically held by the server to allow users to evaluate and vote on policies formulated by users.

[0370] "Voting results" refers to information that compiles the voting results of users who participated in the election event.

[0371] "Customized display" is a display method that provides simulation results in an easy-to-understand manner based on the user's emotional data.

[0372] This invention relates to an educational support system that allows users to formulate policies in physical stores and simulate their social impact. It uses an emotion recognition engine and smart glasses to provide feedback according to the user's emotional state. The program and processing of this system are described below.

[0373] System Overview

[0374] The system consists of the following major components:

[0375] 1. User Device

[0376] 2. Server

[0377] 3. Database

[0378] 4. AI Simulation Engine

[0379] 5. Emotion Recognition Engine

[0380] 6. Smart Glasses

[0381] Hardware and software used

[0382] Smart glasses (e.g. Google Glass)

[0383] Emotion recognition API (e.g. Microsoft Azure Emotion API)

[0384] Front-end frameworks (React, Vue.js, etc.)

[0385] Server API (Node.js, Python Flask, etc.)

[0386] Database (MySQL, MongoDB, etc.)

[0387] AI simulation engines (TensorFlow, PyTorch, etc.)

[0388] Program processing overview

[0389] 1. Policy input and formulation:

[0390] Users input new policies using the touchpad or voice recognition function of the smart glasses. This policy data is sent to the server in real time. The user terminal (smart glasses) provides an interface where data such as the policy name, details, and target group can be entered.

[0391] 2. Acquiring emotion data:

[0392] The smart glasses' built-in camera and microphone are used to analyze the user's facial expressions and tone of voice. This data is sent to an emotion recognition API, which generates emotion data. The generated emotion data is then simultaneously sent to the server.

[0393] 3. Data storage and processing:

[0394] The server stores the received policy and emotion data in a database. These data are used for subsequent simulations and result analysis. The data is properly structured and stored, and can be accessed at any time.

[0395] 4. Simulation and Results Notification:

[0396] The server retrieves relevant correlation data from the database and uses an AI simulation engine to simulate the social impact of policies. The simulation results are customized based on the user's emotional data and displayed on the smart glasses. If the user is feeling stressed, the results will be presented in an easy-to-understand format.

[0397] 5. Visualization of results:

[0398] The smart glasses display visually displays the simulation results, such as "Increasing the education budget" as a policy that "is expected to improve academic performance by 5%." This allows users to intuitively understand the results.

[0399] Examples and prompts

[0400] Example: A user puts on smart glasses and inputs a policy of "increasing the education budget" via voice command. The camera in the glasses analyzes the user's facial expression, and the emotion recognition engine determines that the user is stressed. The server runs a simulation based on the data for the "increasing the education budget" policy, and displays a simple bar graph on the smart glasses showing the expected 5% improvement in student academic performance due to the increase in the education budget. The results are presented in an easy-to-understand format even when the user is stressed.

[0401] Example prompt sentence:

[0402] "A user has proposed a policy to 'increase the education budget.' Simulate the social impact of this policy and briefly explain the results."

[0403] Through this system, users can concretely experience the entire process, from policy formulation to the election process, and receive real-time feedback using emotion recognition, which is expected to improve political understanding and social participation.

[0404] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0405] Step 1:

[0406] The user inputs a new policy through the user terminal (smart glasses). The user inputs the policy data using voice recognition or the touchpad, and the data is sent to the server in real time. The input includes the policy name, details, and target group, and the server receives the policy data based on this. The input policy data is temporarily stored in memory and passed to the next step.

[0407] Step 2:

[0408] The camera and microphone built into the smart glasses capture the user's facial expressions and tone of voice. The emotion recognition engine analyzes this data and generates emotional data. The emotion recognition API (Microsoft Azure Emotion API) is called, and the emotion is output as numerical data as the analysis result. This generated emotional data is immediately sent to the server. The emotional data includes items such as stress level, joy, and surprise.

[0409] Step 3:

[0410] The server stores the received policy data and emotion data in a database. The data is stored using an appropriate data structure, using SQL queries or NoSQL document operations. Metadata is also stored for later retrieval and processing. The input data is stored in the database and prepared with the correlation data required for the next step.

[0411] Step 4:

[0412] The server retrieves the correlation data needed to simulate the social impact of policies from the database. This correlation data includes past policy data and related statistical information. It searches these using keys, loads the relevant data into main memory, and uses it in the next simulation step. All correlation data corresponding to the input policy is collected and passed to the AI ​​simulation engine.

[0413] Step 5:

[0414] The server runs a simulation using an AI simulation engine based on the acquired correlation data and policy data. The simulation engine (TensorFlow, PyTorch) is used to predict the social impact of policies. The simulation process involves preprocessing the data, applying models, generating results, and outputting the simulation results. The output results are passed on to the next step.

[0415] Step 6:

[0416] The server generates simulation results and sends them to the user's device in a format customized based on the user's emotional data. If the user is feeling stressed, the results are provided in a visually simple format, allowing the user to receive the simulation results in a format that is easy to understand. The results are output in a format that can be displayed on the smart glasses as simple graphs and charts.

[0417] Step 7:

[0418] The smart glasses visually display the received simulation results to the user. The results are optimized based on emotion recognition, providing information in a format that is easy for the user to understand. Specific results can be displayed, such as "a 5% expected improvement in academic performance" in response to the policy "increase in education budget." The displayed content is rendered on the screen and fed back to the user.

[0419] Through these steps, users can understand policy impacts in real time, enriching their in-store educational experience.

[0420] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the 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.

[0421] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0422] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0423] [Second embodiment]

[0424] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0425] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0426] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0428] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0430] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0431] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0432] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0434] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0435] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0436] This invention relates to an educational support system that allows users to formulate policies, run a virtual government, and participate in elections. The system comprises the following components:

[0437] 1. User Device

[0438] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through an interface and send policy data directly from the terminal to the server. The terminal also visually displays received simulation results and election notifications to users.

[0439] 2. Server

[0440] The server receives policy data sent from user devices and stores it in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[0441] 3. Database

[0442] The database is for storing policy data and correlation data, including historical statistical data and related information necessary for simulating the social impact of policies.

[0443] 4. AI Simulation Engine

[0444] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are generated and sent to the user's device.

[0445] Program processing

[0446] Policy formulation

[0447] The user inputs a new policy using the device interface. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[0448] Receiving and storing data

[0449] The server receives the policy data sent to it and stores it in a database, which is used later in the simulation process.

[0450] Correlated Data Acquisition and Simulation

[0451] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, the server uses an AI simulation engine to predict the social impact of policies.

[0452] Notification and display of simulation results

[0453] When the simulation is complete, the server generates the results and sends them to the user's device, which then visually displays the received simulation results. For example, the result might be, "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0454] The Election Process

[0455] The server periodically holds election events and notifies user devices of the information. Users use their devices to participate in elections and promote their policies to other users. Users can evaluate the policies of other users and vote via their devices. The server tally the voting results of all users, generate election results, and notify the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[0456] Through this system, users can learn by experiencing everything from policy formulation to elections in a virtual environment that models the real political process, which will contribute to improving political understanding and social participation, especially among young people.

[0457] The processing flow will be explained below.

[0458] Step 1:

[0459] The user inputs the policy into the device interface. The user inputs information such as the policy name, details, and target group into the device.

[0460] Step 2:

[0461] The terminal sends the policy data entered by the user to the server, and the terminal formats the policy data in an appropriate format and generates a request to send it to the server.

[0462] Step 3:

[0463] The server receives the policy data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[0464] Step 4:

[0465] The server stores the received policy data in a database, and assigns an ID to the database so that the stored policy data can be uniquely identified.

[0466] Step 5:

[0467] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[0468] Step 6:

[0469] The server generates a dataset for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[0470] Step 7:

[0471] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[0472] Step 8:

[0473] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[0474] Step 9:

[0475] The server transmits the generated simulation results to the user terminal, and the server generates a request to package the simulation results into an appropriate format and transmit them to the user terminal.

[0476] Step 10:

[0477] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[0478] Step 11:

[0479] The simulation results received by the user device are visually displayed, showing specific results such as "a 5% expected improvement in academic performance due to an increase in the education budget."

[0480] Step 12:

[0481] The server periodically holds election events and notifies the terminals of the information. The server generates notifications to inform users of the election event times and related information.

[0482] Step 13:

[0483] Users use their devices to participate in elections and promote their policies. Users input appeal information to present the benefits and data of their policies to other users.

[0484] Step 14:

[0485] The device sends the appeal information entered by the user to the server, where it is managed so that it can be displayed to other users.

[0486] Step 15:

[0487] Users use their devices to vote for policies of other users. Users evaluate and vote for policies formulated by other users.

[0488] Step 16:

[0489] The server tally the votes of all users and generate the election results. The server analyzes the voting data and identifies the most popular policy.

[0490] Step 17:

[0491] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[0492] Step 18:

[0493] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[0494] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The system aims to contribute to improving political understanding and social participation, especially among young people.

[0495] Example 1

[0496] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0497] In modern society, political education, especially for young people, offers few opportunities to experience the actual political process, resulting in low levels of political understanding and a sense of social participation. Furthermore, there is a lack of simulation tools to concretely understand the impact of policies, and there is no system that provides a consistent experience from policy formulation to electoral participation.

[0498] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0499] In this invention, the server includes a means for a user terminal to access and log in to the system via a browser or a dedicated application, a means for packetizing policy data and sending it to the server via HTTPS, a means for the server to receive the policy data at an API endpoint, and a means for visually displaying simulation results in graphs or text format. This allows users to learn through hands-on experience in a virtual environment the entire political process, from policy formulation to simulating its social impact, and even policy evaluation and voting in elections, thereby improving their understanding of politics and their sense of social participation.

[0500] A "user terminal" is a device used by a user to perform operations such as formulating policies, displaying simulation results, and participating in elections.

[0501] A "server" is a computer system that receives policy data sent from user terminals, stores it in a database, runs simulations based on correlation data, and performs other tasks such as holding election events and tallying voting results.

[0502] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0503] A "database" is a collection of data managed on a server, and is an area where policy data, correlation data, etc. are stored.

[0504] "Correlation data" refers to past statistical data and related information necessary to simulate the social impact of policies.

[0505] The "AI simulation engine" is a system equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[0506] "Simulation results" are predictive data generated by an AI simulation engine that shows how a particular policy will affect society.

[0507] An "election event" is an event in which users vote in a virtual environment based on policies proposed by users to determine the most popular policy.

[0508] "Voting results" are the aggregated results of users' votes at election events, and are data showing which policies received how much support.

[0509] The "HTTPS protocol" is a communication method for securely sending and receiving data over the Internet.

[0510] An "API endpoint" is a URL on a server that can be accessed by external systems to provide a specific function.

[0511] This invention relates to an educational support system that allows users to formulate policies, manage a virtual government, and participate in elections. The system includes a user terminal, a server, a database, and an AI simulation engine.

[0512] The user terminal is a device used by users to formulate policies, view simulation results, participate in elections, and perform other operations. Specifically, users can access the system and log in to their own accounts using a browser or a dedicated application. Users enter the policy name, details, target group, etc. through the policy formulation interface and click the "Submit" button to send the policy data to the server. The policy data is packetized in JSON format and securely sent to the server via the HTTPS protocol.

[0513] The server is the central component that processes the received policy data. The server receives the policy data via the API endpoint, parses it, and stores it in a database. The stored policy data is later used for simulations. The server also retrieves correlation data from the database, which is necessary to simulate the social impact of policies. The correlation data includes historical statistical data and related information.

[0514] The AI ​​simulation engine is equipped with artificial intelligence to predict the social impact of policies based on policy data and correlation data. The server passes the acquired correlation data and policy data to the AI ​​simulation engine, which then runs the simulation. The resulting simulation results are returned to the server, converted back to JSON format, and sent to the user's device.

[0515] The user device has the function of visually displaying the simulation results. It parses the received simulation results and displays them visually in graphs and text format. For example, it displays specific results such as "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0516] The server also periodically holds election events. It uses a scheduler to set the timing of election events and sends notifications to all users. Users can view and evaluate the policies of other candidates, then vote for their choice. The server aggregates the voting results of all users and generates election results, such as "Policy 'Increase education budget' received the most votes." These election results are again notified to user devices and displayed visually.

[0517] As a concrete example, when a user formulates an "environmental protection policy," they input the policy details as "increasing the investment rate in renewable energy, strengthening forest conservation activities, and improving waste recycling rates." Simulation results are displayed such as "investment in renewable energy will increase the region's energy self-sufficiency rate by 15% and reduce carbon emissions by 10%." During the election process, the server notifies users of the results, such as "The environmental protection policy received the most votes in the user vote and will be adopted as the next policy."

[0518] An example of a prompt is as follows:

[0519] "Simulate how an increase in the education budget would affect society."

[0520] "You have proposed a policy to increase the share of investment in renewable energy to 50%. Simulate the social impact of this policy and display the results."

[0521] In this way, the present invention provides a system that allows users to experience the political process in a virtual environment through a series of processes including policy planning, simulation, and elections, thereby improving their understanding of politics and their sense of social participation.

[0522] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0523] Step 1:

[0524] The user starts up the device and logs in using a browser or a dedicated application. As input, the user enters their account information (username and password). The server executes the authentication process and outputs the success or failure of user authentication. Specifically, if authentication is successful, the policy formulation interface is displayed to the user.

[0525] Step 2:

[0526] The user inputs a new policy using the policy formulation interface. As input, the user enters the policy name, details, target group, etc. When the user clicks the "Submit" button, the user terminal packets the entered policy data into JSON format and sends it to the server via the HTTPS protocol. As output, the policy data is sent.

[0527] Step 3:

[0528] The server receives the policy data. Specifically, the server waits for POST requests at a specific API endpoint and parses the received data. It receives JSON-formatted policy data as input and obtains the parsed policy data as output.

[0529] Step 4:

[0530] The server stores the received policy data in the database. Specifically, the server executes an insert query to store the parsed policy data in the database. It receives the parsed policy data as input and adds a new record to the database as output.

[0531] Step 5:

[0532] The server retrieves correlation data from the database. Specifically, the server uses a SELECT query to retrieve the data needed to simulate the impact of policies from the "CorrelationData" table, which stores past statistical data. As input, the conditions for the correlation data to be retrieved are specified, and as output, the correlation data is obtained.

[0533] Step 6:

[0534] The server passes the acquired correlation data and policy data to the AI ​​simulation engine. Specifically, the server sends the policy data and correlation data to the AI ​​simulation engine's API. It receives the policy data and correlation data as input and sends the simulation prompt and data to the AI ​​simulation engine as output.

[0535] Step 7:

[0536] The AI ​​simulation engine simulates the social impact of policies and generates results. Specifically, the AI ​​simulation engine predicts the impact based on the data it receives and generates results. It receives policy data and correlation data as input and generates simulation results as output.

[0537] Step 8:

[0538] The server receives the simulation results from the AI ​​simulation engine and sends them to the user device. Specifically, the server converts the simulation results back into JSON format and sends them to the user device. The server receives the simulation results from the AI ​​simulation engine as input and sends them to the user device as output.

[0539] Step 9:

[0540] The user terminal visually displays the received simulation results. Specifically, the user terminal parses the JSON format data and displays it on the screen in graph or text format. It receives the simulation result data as input and visually displays it to the user as output.

[0541] Step 10:

[0542] The server periodically holds election events and notifies user terminals of the information. Specifically, the server sends election start notifications to all users based on a pre-set schedule. The server receives schedule information as input and sends notifications to user terminals as output.

[0543] Step 11:

[0544] Users participate in elections, advocate for their policies, and cast their votes. Specifically, users view and evaluate the policies of other users, and then vote. The system receives other users' policy information and voting options as input, and transmits the voting results as output.

[0545] Step 12:

[0546] The server tally the votes of all users and generate the final election results. Specifically, the server retrieves the voting data from the database and calculates the results using a tallying algorithm. It receives each user's voting data as input and obtains the tally results as output.

[0547] Step 13:

[0548] The server notifies the user device of the election results, which are then displayed visually. Specifically, the server converts the results into JSON format and sends them to the user device, which then displays them on the screen. The server receives the results as input and visually notifies the user as output.

[0549] (Application example 1)

[0550] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0551] One issue is the lack of systems that model the real political process and allow users to experience and learn about the entire process from policy formulation to elections. There is a particular lack of educational support systems aimed at improving young people's understanding of politics and their sense of social participation. Furthermore, there are no adequate mechanisms for evaluating policies through competition and cooperation among users.

[0552] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0553] In this invention, the server includes a means for allowing users to formulate policies as managers of a virtual city and simulate their impact, a means for holding elections among users and evaluating the policies, and a user terminal includes a means for formulating policies and receiving and displaying the results of the simulation, a means for notifying users of election information, and a means for participating in and voting in elections. This enables users to deepen their understanding of politics through policy formulation in a virtual environment, simulating its social impact, and the election process.

[0554] A "user terminal" is a device that provides functions such as formulating policies, receiving and displaying simulation results, notifying election information, and participating in and voting in elections.

[0555] A "server" is a device whose role is to receive policy data sent from user terminals, store it in a database, simulate the social impact of policies, hold election events, and notify the user terminals of that information.

[0556] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0557] A "database" is a storage device for storing policy and correlation data received by a server.

[0558] "Correlation data" refers to data that includes past statistical data and related information that is necessary to simulate the social impact of policies.

[0559] An "AI simulation engine" is an artificial intelligence engine used to predict the social impact of a policy based on policy data and correlation data.

[0560] "Simulation results" are predictive data generated by the AI ​​simulation engine about the impact of specific policies on society.

[0561] An "election event" is an election activity conducted by a user to receive evaluations from other users regarding policies formulated by the user.

[0562] "Voting results" refers to the aggregated results of votes cast by all users in the election event.

[0563] "Virtual city management" is a process in which users act as managers of a virtual city, drafting policies and simulating their social impact.

[0564] The invention is implemented as a virtual city management simulator application, in which users access the simulator and, as managers of a virtual city, formulate various policies, simulate their social impact, and participate in the election process.

[0565] System Configuration

[0566] The system mainly consists of the following components:

[0567] 1. User Device

[0568] Provide an interface for formulating policy.

[0569] Displays simulation results, election information, etc.

[0570] Providing a means for users to participate in elections and cast their votes.

[0571] 2. Server

[0572] Receives policy data sent by users and stores it in a database.

[0573] Obtain the necessary correlation data and simulate the social impact of policies using an AI simulation engine.

[0574] Simulation results are generated and sent to the user terminal.

[0575] Election events will be held periodically and information about them will be sent to users' devices.

[0576] The voting results for each election event will be tallied and the election results will be announced.

[0577] 3. Database

[0578] Stores policy and correlation data.

[0579] Correlated data includes historical statistical data and related information.

[0580] 4. AI Simulation Engine

[0581] It is used to predict the social impact of policies based on policy data and correlation data formulated by users.

[0582] The specific hardware and software used

[0583] Server: Web server using Flask

[0584] Database: SQLite

[0585] AI Simulation Engine: Linear Regression Models Using Scikit-learn

[0586] Program processing explanation

[0587] The server is operated using a web server framework called Flask and stores policy data and correlation data in an SQLite database. Policy data sent from user devices is received by the server and saved in the database. The server then uses the saved policy data and correlation data to run an AI simulation engine (here, a Linear Regression model from Scikit-learn) to predict the impact of policies on society.

[0588] Simulation results are generated by the server and sent to the user's device. The received simulation results are visually displayed on the user's device. The server also periodically holds election events and notifies the user's device. Users can participate in elections via their device, evaluate other users' policies, and cast their votes. The voting results are tallied by the server and notified to the user's device.

[0589] Specific examples

[0590] When a user proposes a policy such as "increasing the education budget," the device sends the policy data to the server. The server stores the policy data in a database and performs a simulation based on correlation data. The result is that "increasing the education budget is expected to improve academic performance by 5% in the next year," which is displayed on the user's device.

[0591] Example prompt sentence:

[0592] "Simulate the impact of increasing the education budget by 10%."

[0593] In this way, users can experience everything from policy formulation to simulation and the electoral process, virtually learning about the processes involved in the formation of politics and policies.

[0594] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0595] Step 1:

[0596] The user inputs the policy on the terminal and sends it to the server. The user uses the terminal interface to create a new policy and input its details. The input policy data (policy name, details, target group, etc.) is sent from the terminal to the server. The input data is the basic information of the policy.

[0597] Step 2:

[0598] The server receives the policy data and stores it in a database. The server receives the policy data sent from the terminal and stores the data in an SQLite database. The received data is detailed policy information, and the saving operation persists the data.

[0599] Step 3:

[0600] The server retrieves the necessary correlation data from the database. The server retrieves past statistical data and related information needed to simulate the social impact of policies from the database. The retrieved data is statistical data on the effects of past policies, etc.

[0601] Step 4:

[0602] The server runs a simulation based on policy data and correlation data. Using an AI simulation engine (using a Linear Regression model), the server inputs the acquired policy data and correlation data and performs data calculations to predict the social impact of the policy. The input data are policy data and correlation data, and the output is the simulation results for predicting the impact of the policy.

[0603] Step 5:

[0604] The server generates the simulation results and sends them to the user terminal. The simulation results (e.g., "An increase in the education budget is expected to improve academic performance by 5% in the next year") are generated by the server and sent to the user terminal. The output data are the simulation results.

[0605] Step 6:

[0606] The user terminal visually displays the simulation results received. The user terminal visually displays the simulation results received from the server in an easy-to-read manner. The display operation is the visualization of data.

[0607] Step 7:

[0608] The server periodically holds election events and notifies user terminals of the information. The server generates information about election events that are periodically held and notifies user terminals of the information. The notification data is detailed information about the election events.

[0609] Step 8:

[0610] Users participate in elections and vote through their devices. Users evaluate policies proposed by other users and cast their votes through their devices. The input data is the user's voting information.

[0611] Step 9:

[0612] The server tally the voting results and notify the election results. The server tally the voting data sent by all users and generate the election results. These election results are notified to the user terminals. The output data is the election results.

[0613] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0614] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections, and also combines it with an emotion recognition engine that recognizes user emotions. The system consists of the following components:

[0615] 1. User Device

[0616] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through the interface and send policy data directly to the server from the terminal. It also has an emotion recognition engine that analyzes the user's facial expressions and tone of voice to recognize their emotions.

[0617] 2. Server

[0618] The server receives policy data and emotion data sent from user devices and stores them in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[0619] 3. Database

[0620] The database is intended to store policy data, correlation data, and sentiment data. The correlation data includes historical statistical data and related information necessary for simulating the social impact of policies, while the sentiment data records user reactions.

[0621] 4. AI Simulation Engine

[0622] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are automatically generated and sent to the user's device.

[0623] 5. Emotion Recognition Engine

[0624] The emotion recognition engine is installed on the user's device and recognizes emotions by analyzing the user's facial expressions and tone of voice. This data is used for policy simulations and election results analysis, and is used to customize the display of results.

[0625] Program processing

[0626] Policy formulation

[0627] The user inputs a new policy through the device interface and sends the policy data to the server. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[0628] Acquiring emotion data

[0629] The emotion recognition engine analyzes the user's facial expressions and tone of voice to generate emotion data. For example, it can recognize whether the user is feeling stressed when entering a policy. The generated emotion data is simultaneously sent to the server.

[0630] Receiving and storing data

[0631] The server receives the policy data and emotion data and stores them in a database for later use in simulations and result analysis.

[0632] Correlated Data Acquisition and Simulation

[0633] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, an AI simulation engine is used to predict the social impact of policies.

[0634] Notification and display of simulation results

[0635] Once the simulation is complete, the server generates results and sends them to the user's device in a format customized based on the user's emotional data. For example, if the user is feeling stressed, the results are displayed in an easy-to-understand format. The user's device visually displays the received simulation results to the user. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed.

[0636] The Election Process

[0637] The server periodically holds election events and notifies user devices of this information. Users use their devices to participate in elections and appeal their policies to other users. Users can present their policies while observing the reactions of other users through an emotion recognition engine. The device sends the appeal information entered by the user to the server, which other users can then evaluate and vote for. The server tallys the voting results of all users, generates the election results, and notifies the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[0638] Through this system, users can experience the process from policy formulation to elections and understand its impact on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, enhancing user understanding and engagement. This is expected to improve political understanding and social participation, especially among young people.

[0639] The processing flow will be explained below.

[0640] Step 1:

[0641] The user inputs the policy into the device interface. The user inputs information such as the policy name (e.g., "Increase the education budget"), details, and target group into the device.

[0642] Step 2:

[0643] The device analyzes the user's facial expressions and tone of voice to generate emotional data, and the emotion recognition engine determines whether the user is stressed or excited.

[0644] Step 3:

[0645] The terminal sends the input policy data and generated emotion data to the server, which then formats the data appropriately and generates a request to send to the server.

[0646] Step 4:

[0647] The server receives the policy data and emotion data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[0648] Step 5:

[0649] The server stores the received policy data and emotion data in a database, where IDs are assigned so that the policy data and emotion data can be uniquely identified.

[0650] Step 6:

[0651] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[0652] Step 7:

[0653] The server generates a data set for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[0654] Step 8:

[0655] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[0656] Step 9:

[0657] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[0658] Step 10:

[0659] The server sends the generated simulation results to the user terminal, and the server packages the simulation results in an appropriate format and generates a request to send them to the user terminal.

[0660] Step 11:

[0661] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[0662] Step 12:

[0663] The simulation results received by the user's device are visually displayed. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed. The display is also customized to the user based on emotional data.

[0664] Step 13:

[0665] The server periodically holds election events and notifies the terminal of the information. The server generates notifications to inform users of the election event time and related information.

[0666] Step 14:

[0667] Users use their devices to participate in elections and promote their policies. Users input presentation information to promote their policies to other users.

[0668] Step 15:

[0669] The device sends the presentation information and emotion data entered by the user to the server, which stores the data and makes it available to other users.

[0670] Step 16:

[0671] Users use their devices to vote for other users' policies. Users evaluate the presented policy information and send their voting data from their devices.

[0672] Step 17:

[0673] The server aggregates the votes of all users and generates the election results. The server analyzes the aggregated voting data and identifies the policy that received the most support.

[0674] Step 18:

[0675] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[0676] Step 19:

[0677] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[0678] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, improving user understanding and engagement. This is expected to improve young people's understanding of politics and their sense of social participation.

[0679] Example 2

[0680] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0681] In modern society, young people are expected to take an interest in politics and policy and to actively participate in it. However, understanding policy-making and its social impact is not easy, and many young people are reluctant to participate in politics. An educational support system is needed to solve this problem and improve young people's understanding of politics and their awareness of social participation.

[0682] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0683] In this invention, the server includes: means for formulating policies through a user terminal; means for transmitting policy data to the server; means for acquiring user emotion data in the user terminal and transmitting it to the server; means for storing the received policy data and emotion data in a database in the server; means for acquiring correlation data necessary for simulating the social impact of policies in the server; means for running a simulation based on the acquired correlation data and policy data in the server; means for generating simulation results in the server, customizing them based on the emotion data, and transmitting them to the user terminal; means for visually displaying the received simulation results in the user terminal; means for periodically holding an election event in the server and notifying the user terminal of the information; means for participating in elections and voting through the user terminal; and means for tallying vote results in the server and notifying the user of the election results. This allows young people to experience the process from policy formulation to elections in real time and receive feedback based on their emotions, thereby improving their understanding of politics and their sense of social participation.

[0684] A "user terminal" is a device used by a user to input policies and display simulation results and election information.

[0685] "Policy data" is data containing information about policies formulated by users, including policy names, details, target groups, etc.

[0686] "Emotion data" refers to data that includes information about emotions obtained by analyzing a user's facial expressions and tone of voice.

[0687] The "server" is a central computer that receives policy data and emotion data from user terminals, stores them in a database, obtains correlation data, and runs simulations.

[0688] "Database" is an information management system for storing policy data, emotion data, and correlation data.

[0689] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[0690] The "AI simulation engine" is a program equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[0691] "Simulation results" are predicted data on the social impact of policies generated by the AI ​​simulation engine.

[0692] An "election event" is an event that involves a user virtually participating in an election, promoting their own policies, and receiving votes from other users.

[0693] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections. It also incorporates an emotion recognition engine that recognizes user emotions. The system is implemented by combining the following main components and operations:

[0694] System configuration and functions

[0695] 1. User Device

[0696] A user terminal is a device used by users to input policies and display simulation results and election information. Specifically, this includes PCs, smartphones, and tablets. The terminal is equipped with an emotion recognition engine that analyzes the user's facial expressions and tone of voice. This generates user emotion data.

[0697] 2. Server

[0698] The server receives policy data and emotion data sent from user devices and stores them in a database. The server then retrieves correlation data from the database to simulate the social impact of policies and runs the simulation using an AI simulation engine.

[0699] 3. Database

[0700] The database is an information management system that stores policy data, sentiment data, and correlation data. The correlation data includes historical statistical data and related information and is used to simulate the social impact of policies.

[0701] 4. AI Simulation Engine

[0702] The AI ​​simulation engine is a program that predicts the social impact of policies based on policy data and correlation data. The simulation results are customized based on the user's emotional data and sent to the user's device.

[0703] 5. Emotion Recognition Engine

[0704] The emotion recognition engine is installed on the user's device and generates emotional data by analyzing the user's facial expressions and tone of voice, which is used for policy simulations and election results analysis.

[0705] Use cases and specific steps

[0706] Below are the specific steps users can take to formulate new policies, simulate their impact, and participate in elections.

[0707] 1. Policy input

[0708] The user inputs a policy using the device interface. For example, to formulate a policy such as "increase the education budget by 10%," the user enters this into the device's text field and clicks the submit button.

[0709] 2. Acquiring Emotion Data

[0710] While entering the policy, the camera and microphone on the user's device capture the user's facial expressions and voice in real time, which are then analyzed by the emotion recognition engine to generate emotion data, such as "Stress level: High."

[0711] 3. Data transmission and storage

[0712] The device sends policy data and emotion data to the server, which receives them and stores them in a database.

[0713] 4. Running the Simulation

[0714] The server retrieves the necessary correlation data from the database and inputs it into the AI ​​simulation engine along with the policy data. The simulation is run and the social impact of the policy is predicted. For example, a result such as "Increasing the education budget will improve academic performance by 5%" is generated.

[0715] 5. Notification of simulation results

[0716] The simulation results are customized based on emotional data, for example, to be displayed in a more understandable format for users who are feeling stressed, and then sent to the user's device for visual display.

[0717] 6. Holding election events

[0718] The server periodically holds election events and sends information to user devices. Users appeal to other users about their policies and receive votes. They can also observe other users' reactions using an emotion recognition engine. Finally, the server tallys the votes and notifies users of the election results.

[0719] Prompt Sentence Examples

[0720] An example prompt might use the following text:

[0721] "Simulate how an increase in the education budget will affect student academic performance."

[0722] "Please provide data on the socio-economic impact of investments in the education sector over the past 10 years and analyze the correlations."

[0723] The system allows users to experience the process from policymaking to elections and understand its impact on society in real time. The system also incorporates an emotion recognition engine to provide personalized learning and feedback, helping users better understand politics and participate in society.

[0724] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0725] Step 1: Enter and submit policy data

[0726] The user inputs the policy using the terminal interface. The policy data includes the policy name, details, target group, etc. After inputting is complete, the user clicks the "Submit" button, which is sent to the terminal. The terminal then sends this policy data to the server.

[0727] Input: Policy data entered by the user into the interface.

[0728] Output: Policy data sent from the terminal to the server

[0729] Specific operation: For example, enter a policy such as "Increase the education budget by 10%" and click the send button. At this time, the policy data (the policy name "Increase the education budget by 10%" and details) is sent from the device to the server.

[0730] Step 2: Obtaining and sending emotion data

[0731] While the user is entering the policy, the device's camera and microphone capture the user's facial expressions and voice in real time. The emotion recognition engine analyzes this and generates the user's emotional data. The generated emotional data is then sent to the server along with the policy data.

[0732] Input: User facial expressions and tone of voice

[0733] Output: Emotion data sent to the server

[0734] Specific operation: During policy input, the camera and microphone capture the user's face and voice, and emotional data such as "stress level: high" and "happiness level: low" is generated and sent to the server.

[0735] Step 3: Receiving and storing data

[0736] The server receives the policy data and emotion data sent from the device and stores them in a database for later use in simulations and result analysis.

[0737] Input: Policy data and emotion data sent from the device

[0738] Output: Policy data and sentiment data stored in a database

[0739] Specific operation: The server checks the received policy data and emotion data and stores them appropriately in the database. This storage process allows for future reference.

[0740] Step 4: Obtain correlation data and run simulation

[0741] The server retrieves the correlation data needed to simulate the impact of policies from the database. This correlation data includes past statistical data and related information. The AI ​​simulation engine runs a simulation based on the retrieved correlation data to predict the social impact of policies.

[0742] Input: Correlation data and policy data retrieved from databases

[0743] Output: Simulation results

[0744] Specific operation: The server retrieves correlation data from the database, such as "the impact of past increases in education budgets on academic performance and the national economy," and based on this, the AI ​​simulation engine generates simulation results, such as "a 5% improvement in academic performance is expected."

[0745] Step 5: Generate and communicate simulation results

[0746] Once the simulation is complete, the server generates results and customizes them based on the user's emotional data. For example, if the user is feeling stressed, the results will be adjusted to be displayed in an easy-to-understand format. The generated results are sent to the user's device and displayed visually.

[0747] Input: Simulation results and emotion data

[0748] Output: Customized simulation results

[0749] How it works: The server generates simulation results and adjusts the display format based on emotional data (e.g., "Stress level: High"). The customized results are then sent to the user's device, where they are displayed, such as "Increasing the education budget will improve academic performance by 5%."

[0750] Step 6: Holding election events and announcing results

[0751] The server periodically holds election events and notifies users of the information on their devices. Users can use their devices to participate in elections and promote their policies to other users. During this process, the emotion recognition engine observes the reactions of other users and provides feedback. After the votes are cast, the server tallys the voting results of all users and notifies them of the results.

[0752] Input: Election information and user voting data

[0753] Output: Counted voting results

[0754] Specific operation: The server notifies the user that an election event has started, and the user creates and submits a policy appeal. The device analyzes other users' reactions in real time and provides feedback, such as "This policy is highly rated." Finally, the server tallies the voting results and notifies the user of the result, such as "Increasing the education budget received the most votes."

[0755] (Application example 2)

[0756] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0757] Current educational systems make it difficult for users to experience the entire political process, from policy formulation to the electoral process. Furthermore, the educational effectiveness is limited by the lack of ways for users to understand the social impact of policies in real time and receive individual feedback. Furthermore, systems that provide feedback tailored to the user's state through emotion recognition are also inadequate. Furthermore, when considering use in physical stores, creating an environment where a large number of users can use the system simultaneously presents a challenge.

[0758] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for formulating policies through a user terminal, means for transmitting policy data to the server, and means for storing the received policy data in a database. This enables users to formulate policies in physical stores and simulate their social impact in real time. In addition, by including means for acquiring user emotion data through an emotion recognition engine and customizing and displaying simulation results based on the emotion data, and means for the user to input policies through smart glasses and visually provide the displayed content, feedback can be provided according to the user's state, enhancing the effectiveness of education.

[0759] A "user terminal" is a device used by a user to input policies and display simulation results.

[0760] The "server" is a central processing unit that receives, stores, and processes policy data and emotion data, and generates and notifies the results of simulations.

[0761] "Policy data" is information about policies formulated by users, including details and target groups.

[0762] A "database" is an information storage system that stores policy data, sentiment data, and correlation data and makes them accessible when needed.

[0763] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[0764] The "AI simulation engine" is an artificial intelligence engine that predicts the social impact of policies based on policy data and correlation data, and generates simulation results.

[0765] An "emotion recognition engine" is software that analyzes a user's facial expressions and tone of voice and generates emotional data.

[0766] "Emotion data" is information about a user's emotions generated by an emotion recognition engine.

[0767] "Smart glasses" are wearable devices used to virtually provide policy formulation, display simulation results, and more.

[0768] An "election event" is an event that is periodically held by the server to allow users to evaluate and vote on policies formulated by users.

[0769] "Voting results" refers to information that compiles the voting results of users who participated in the election event.

[0770] "Customized display" is a display method that provides simulation results in an easy-to-understand manner based on the user's emotional data.

[0771] This invention relates to an educational support system that allows users to formulate policies in physical stores and simulate their social impact. It uses an emotion recognition engine and smart glasses to provide feedback according to the user's emotional state. The program and processing of this system are described below.

[0772] System Overview

[0773] The system consists of the following major components:

[0774] 1. User Device

[0775] 2. Server

[0776] 3. Database

[0777] 4. AI Simulation Engine

[0778] 5. Emotion Recognition Engine

[0779] 6. Smart Glasses

[0780] Hardware and software used

[0781] Smart glasses (e.g. Google Glass)

[0782] Emotion recognition API (e.g. Microsoft Azure Emotion API)

[0783] Front-end frameworks (React, Vue.js, etc.)

[0784] Server API (Node.js, Python Flask, etc.)

[0785] Database (MySQL, MongoDB, etc.)

[0786] AI simulation engines (TensorFlow, PyTorch, etc.)

[0787] Program processing overview

[0788] 1. Policy input and formulation:

[0789] Users input new policies using the touchpad or voice recognition function of the smart glasses. This policy data is sent to the server in real time. The user terminal (smart glasses) provides an interface where data such as the policy name, details, and target group can be entered.

[0790] 2. Acquiring emotion data:

[0791] The smart glasses' built-in camera and microphone are used to analyze the user's facial expressions and tone of voice. This data is sent to an emotion recognition API, which generates emotion data. The generated emotion data is then simultaneously sent to the server.

[0792] 3. Data storage and processing:

[0793] The server stores the received policy and emotion data in a database. These data are used for subsequent simulations and result analysis. The data is properly structured and stored, and can be accessed at any time.

[0794] 4. Simulation and Results Notification:

[0795] The server retrieves relevant correlation data from the database and uses an AI simulation engine to simulate the social impact of policies. The simulation results are customized based on the user's emotional data and displayed on the smart glasses. If the user is feeling stressed, the results will be presented in an easy-to-understand format.

[0796] 5. Visualization of results:

[0797] The smart glasses display visually displays the simulation results, such as "Increasing the education budget" as a policy that "is expected to improve academic performance by 5%." This allows users to intuitively understand the results.

[0798] Examples and prompts

[0799] Example: A user puts on smart glasses and inputs a policy of "increasing the education budget" via voice command. The camera in the glasses analyzes the user's facial expression, and the emotion recognition engine determines that the user is stressed. The server runs a simulation based on the data for the "increasing the education budget" policy, and displays a simple bar graph on the smart glasses showing the expected 5% improvement in student academic performance due to the increase in the education budget. The results are presented in an easy-to-understand format even when the user is stressed.

[0800] Example prompt sentence:

[0801] "A user has proposed a policy to 'increase the education budget.' Simulate the social impact of this policy and briefly explain the results."

[0802] Through this system, users can concretely experience the entire process, from policy formulation to the election process, and receive real-time feedback using emotion recognition, which is expected to improve political understanding and social participation.

[0803] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0804] Step 1:

[0805] The user inputs a new policy through the user terminal (smart glasses). The user inputs the policy data using voice recognition or the touchpad, and the data is sent to the server in real time. The input includes the policy name, details, and target group, and the server receives the policy data based on this. The input policy data is temporarily stored in memory and passed to the next step.

[0806] Step 2:

[0807] The camera and microphone built into the smart glasses capture the user's facial expressions and tone of voice. The emotion recognition engine analyzes this data and generates emotional data. The emotion recognition API (Microsoft Azure Emotion API) is called, and the emotion is output as numerical data as the analysis result. This generated emotional data is immediately sent to the server. The emotional data includes items such as stress level, joy, and surprise.

[0808] Step 3:

[0809] The server stores the received policy data and emotion data in a database. The data is stored using an appropriate data structure, using SQL queries or NoSQL document operations. Metadata is also stored for later retrieval and processing. The input data is stored in the database and prepared with the correlation data required for the next step.

[0810] Step 4:

[0811] The server retrieves the correlation data needed to simulate the social impact of policies from the database. This correlation data includes past policy data and related statistical information. It searches these using keys, loads the relevant data into main memory, and uses it in the next simulation step. All correlation data corresponding to the input policy is collected and passed to the AI ​​simulation engine.

[0812] Step 5:

[0813] The server runs a simulation using an AI simulation engine based on the acquired correlation data and policy data. The simulation engine (TensorFlow, PyTorch) is used to predict the social impact of policies. The simulation process involves preprocessing the data, applying models, generating results, and outputting the simulation results. The output results are passed on to the next step.

[0814] Step 6:

[0815] The server generates simulation results and sends them to the user's device in a format customized based on the user's emotional data. If the user is feeling stressed, the results are provided in a visually simple format, allowing the user to receive the simulation results in a format that is easy to understand. The results are output in a format that can be displayed on the smart glasses as simple graphs and charts.

[0816] Step 7:

[0817] The smart glasses visually display the received simulation results to the user. The results are optimized based on emotion recognition, providing information in a format that is easy for the user to understand. Specific results can be displayed, such as "a 5% expected improvement in academic performance" in response to the policy "increase in education budget." The displayed content is rendered on the screen and fed back to the user.

[0818] Through these steps, users can understand policy impacts in real time, enriching their in-store educational experience.

[0819] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0820] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0821] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0822] [Third embodiment]

[0823] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[0824] 5, the data processing system 310 includes the data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[0825] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0827] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0829] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0830] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0831] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0833] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0834] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0835] This invention relates to an educational support system that allows users to formulate policies, run a virtual government, and participate in elections. The system comprises the following components:

[0836] 1. User Device

[0837] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through an interface and send policy data directly from the terminal to the server. The terminal also visually displays received simulation results and election notifications to users.

[0838] 2. Server

[0839] The server receives policy data sent from user devices and stores it in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[0840] 3. Database

[0841] The database is for storing policy data and correlation data, including historical statistical data and related information necessary for simulating the social impact of policies.

[0842] 4. AI Simulation Engine

[0843] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are generated and sent to the user's device.

[0844] Program processing

[0845] Policy formulation

[0846] The user inputs a new policy using the device interface. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[0847] Receiving and storing data

[0848] The server receives the policy data sent to it and stores it in a database, which is used later in the simulation process.

[0849] Correlated Data Acquisition and Simulation

[0850] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, the server uses an AI simulation engine to predict the social impact of policies.

[0851] Notification and display of simulation results

[0852] When the simulation is complete, the server generates the results and sends them to the user's device, which then visually displays the received simulation results. For example, the result might be, "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0853] The Election Process

[0854] The server periodically holds election events and notifies user devices of the information. Users use their devices to participate in elections and promote their policies to other users. Users can evaluate the policies of other users and vote via their devices. The server tally the voting results of all users, generate election results, and notify the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[0855] Through this system, users can learn by experiencing everything from policy formulation to elections in a virtual environment that models the real political process, which will contribute to improving political understanding and social participation, especially among young people.

[0856] The processing flow will be explained below.

[0857] Step 1:

[0858] The user inputs the policy into the device interface. The user inputs information such as the policy name, details, and target group into the device.

[0859] Step 2:

[0860] The terminal sends the policy data entered by the user to the server, and the terminal formats the policy data in an appropriate format and generates a request to send it to the server.

[0861] Step 3:

[0862] The server receives the policy data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[0863] Step 4:

[0864] The server stores the received policy data in a database, and assigns an ID to the database so that the stored policy data can be uniquely identified.

[0865] Step 5:

[0866] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[0867] Step 6:

[0868] The server generates a dataset for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[0869] Step 7:

[0870] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[0871] Step 8:

[0872] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[0873] Step 9:

[0874] The server transmits the generated simulation results to the user terminal, and the server generates a request to package the simulation results into an appropriate format and transmit them to the user terminal.

[0875] Step 10:

[0876] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[0877] Step 11:

[0878] The simulation results received by the user device are visually displayed, showing specific results such as "a 5% expected improvement in academic performance due to an increase in the education budget."

[0879] Step 12:

[0880] The server periodically holds election events and notifies the terminals of the information. The server generates notifications to inform users of the election event times and related information.

[0881] Step 13:

[0882] Users use their devices to participate in elections and promote their policies. Users input appeal information to present the benefits and data of their policies to other users.

[0883] Step 14:

[0884] The device sends the appeal information entered by the user to the server, where it is managed so that it can be displayed to other users.

[0885] Step 15:

[0886] Users use their devices to vote for policies of other users. Users evaluate and vote for policies formulated by other users.

[0887] Step 16:

[0888] The server tally the votes of all users and generate the election results. The server analyzes the voting data and identifies the most popular policy.

[0889] Step 17:

[0890] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[0891] Step 18:

[0892] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[0893] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The system aims to contribute to improving political understanding and social participation, especially among young people.

[0894] Example 1

[0895] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0896] In modern society, political education, especially for young people, offers few opportunities to experience the actual political process, resulting in low levels of political understanding and a sense of social participation. Furthermore, there is a lack of simulation tools to concretely understand the impact of policies, and there is no system that provides a consistent experience from policy formulation to electoral participation.

[0897] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0898] In this invention, the server includes a means for a user terminal to access and log in to the system via a browser or a dedicated application, a means for packetizing policy data and sending it to the server via HTTPS, a means for the server to receive the policy data at an API endpoint, and a means for visually displaying simulation results in graphs or text format. This allows users to learn through hands-on experience in a virtual environment the entire political process, from policy formulation to simulating its social impact, and even policy evaluation and voting in elections, thereby improving their understanding of politics and their sense of social participation.

[0899] A "user terminal" is a device used by a user to perform operations such as formulating policies, displaying simulation results, and participating in elections.

[0900] A "server" is a computer system that receives policy data sent from user terminals, stores it in a database, runs simulations based on correlation data, and performs other tasks such as holding election events and tallying voting results.

[0901] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0902] A "database" is a collection of data managed on a server, and is an area where policy data, correlation data, etc. are stored.

[0903] "Correlation data" refers to past statistical data and related information necessary to simulate the social impact of policies.

[0904] The "AI simulation engine" is a system equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[0905] "Simulation results" are predictive data generated by an AI simulation engine that shows how a particular policy will affect society.

[0906] An "election event" is an event in which users vote in a virtual environment based on policies proposed by users to determine the most popular policy.

[0907] "Voting results" are the aggregated results of users' votes at election events, and are data showing which policies received how much support.

[0908] The "HTTPS protocol" is a communication method for securely sending and receiving data over the Internet.

[0909] An "API endpoint" is a URL on a server that can be accessed by external systems to provide a specific function.

[0910] This invention relates to an educational support system that allows users to formulate policies, manage a virtual government, and participate in elections. The system includes a user terminal, a server, a database, and an AI simulation engine.

[0911] The user terminal is a device used by users to formulate policies, view simulation results, participate in elections, and perform other operations. Specifically, users can access the system and log in to their own accounts using a browser or a dedicated application. Users enter the policy name, details, target group, etc. through the policy formulation interface and click the "Submit" button to send the policy data to the server. The policy data is packetized in JSON format and securely sent to the server via the HTTPS protocol.

[0912] The server is the central component that processes the received policy data. The server receives the policy data via the API endpoint, parses it, and stores it in a database. The stored policy data is later used for simulations. The server also retrieves correlation data from the database, which is necessary to simulate the social impact of policies. The correlation data includes historical statistical data and related information.

[0913] The AI ​​simulation engine is equipped with artificial intelligence to predict the social impact of policies based on policy data and correlation data. The server passes the acquired correlation data and policy data to the AI ​​simulation engine, which then runs the simulation. The resulting simulation results are returned to the server, converted back to JSON format, and sent to the user's device.

[0914] The user device has the function of visually displaying the simulation results. It parses the received simulation results and displays them visually in graphs and text format. For example, it displays specific results such as "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[0915] The server also periodically holds election events. It uses a scheduler to set the timing of election events and sends notifications to all users. Users can view and evaluate the policies of other candidates, then vote for their choice. The server aggregates the voting results of all users and generates election results, such as "Policy 'Increase education budget' received the most votes." These election results are again notified to user devices and displayed visually.

[0916] As a concrete example, when a user formulates an "environmental protection policy," they input the policy details as "increasing the investment rate in renewable energy, strengthening forest conservation activities, and improving waste recycling rates." Simulation results are displayed such as "investment in renewable energy will increase the region's energy self-sufficiency rate by 15% and reduce carbon emissions by 10%." During the election process, the server notifies users of the results, such as "The environmental protection policy received the most votes in the user vote and will be adopted as the next policy."

[0917] An example of a prompt is as follows:

[0918] "Simulate how an increase in the education budget would affect society."

[0919] "You have proposed a policy to increase the share of investment in renewable energy to 50%. Simulate the social impact of this policy and display the results."

[0920] In this way, the present invention provides a system that allows users to experience the political process in a virtual environment through a series of processes including policy planning, simulation, and elections, thereby improving their understanding of politics and their sense of social participation.

[0921] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0922] Step 1:

[0923] The user starts up the device and logs in using a browser or a dedicated application. As input, the user enters their account information (username and password). The server executes the authentication process and outputs the success or failure of user authentication. Specifically, if authentication is successful, the policy formulation interface is displayed to the user.

[0924] Step 2:

[0925] The user inputs a new policy using the policy formulation interface. As input, the user enters the policy name, details, target group, etc. When the user clicks the "Submit" button, the user terminal packets the entered policy data into JSON format and sends it to the server via the HTTPS protocol. As output, the policy data is sent.

[0926] Step 3:

[0927] The server receives the policy data. Specifically, the server waits for POST requests at a specific API endpoint and parses the received data. It receives JSON-formatted policy data as input and obtains the parsed policy data as output.

[0928] Step 4:

[0929] The server stores the received policy data in the database. Specifically, the server executes an insert query to store the parsed policy data in the database. It receives the parsed policy data as input and adds a new record to the database as output.

[0930] Step 5:

[0931] The server retrieves correlation data from the database. Specifically, the server uses a SELECT query to retrieve the data needed to simulate the impact of policies from the "CorrelationData" table, which stores past statistical data. As input, the conditions for the correlation data to be retrieved are specified, and as output, the correlation data is obtained.

[0932] Step 6:

[0933] The server passes the acquired correlation data and policy data to the AI ​​simulation engine. Specifically, the server sends the policy data and correlation data to the AI ​​simulation engine's API. It receives the policy data and correlation data as input and sends the simulation prompt and data to the AI ​​simulation engine as output.

[0934] Step 7:

[0935] The AI ​​simulation engine simulates the social impact of policies and generates results. Specifically, the AI ​​simulation engine predicts the impact based on the data it receives and generates results. It receives policy data and correlation data as input and generates simulation results as output.

[0936] Step 8:

[0937] The server receives the simulation results from the AI ​​simulation engine and sends them to the user device. Specifically, the server converts the simulation results back into JSON format and sends them to the user device. The server receives the simulation results from the AI ​​simulation engine as input and sends them to the user device as output.

[0938] Step 9:

[0939] The user terminal visually displays the received simulation results. Specifically, the user terminal parses the JSON format data and displays it on the screen in graph or text format. It receives the simulation result data as input and visually displays it to the user as output.

[0940] Step 10:

[0941] The server periodically holds election events and notifies user terminals of the information. Specifically, the server sends election start notifications to all users based on a pre-set schedule. The server receives schedule information as input and sends notifications to user terminals as output.

[0942] Step 11:

[0943] Users participate in elections, advocate for their policies, and cast their votes. Specifically, users view and evaluate the policies of other users, and then vote. The system receives other users' policy information and voting options as input, and transmits the voting results as output.

[0944] Step 12:

[0945] The server tally the votes of all users and generate the final election results. Specifically, the server retrieves the voting data from the database and calculates the results using a tallying algorithm. It receives each user's voting data as input and obtains the tally results as output.

[0946] Step 13:

[0947] The server notifies the user device of the election results, which are then displayed visually. Specifically, the server converts the results into JSON format and sends them to the user device, which then displays them on the screen. The server receives the results as input and visually notifies the user as output.

[0948] (Application example 1)

[0949] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0950] One issue is the lack of systems that model the real political process and allow users to experience and learn about the entire process from policy formulation to elections. There is a particular lack of educational support systems aimed at improving young people's understanding of politics and their sense of social participation. Furthermore, there are no adequate mechanisms for evaluating policies through competition and cooperation among users.

[0951] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0952] In this invention, the server includes a means for allowing users to formulate policies as managers of a virtual city and simulate their impact, a means for holding elections among users and evaluating the policies, and a user terminal includes a means for formulating policies and receiving and displaying the results of the simulation, a means for notifying users of election information, and a means for participating in and voting in elections. This enables users to deepen their understanding of politics through policy formulation in a virtual environment, simulating its social impact, and the election process.

[0953] A "user terminal" is a device that provides functions such as formulating policies, receiving and displaying simulation results, notifying election information, and participating in and voting in elections.

[0954] A "server" is a device whose role is to receive policy data sent from user terminals, store it in a database, simulate the social impact of policies, hold election events, and notify the user terminals of that information.

[0955] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[0956] A "database" is a storage device for storing policy and correlation data received by a server.

[0957] "Correlation data" refers to data that includes past statistical data and related information that is necessary to simulate the social impact of policies.

[0958] An "AI simulation engine" is an artificial intelligence engine used to predict the social impact of a policy based on policy data and correlation data.

[0959] "Simulation results" are predictive data generated by the AI ​​simulation engine about the impact of specific policies on society.

[0960] An "election event" is an election activity conducted by a user to receive evaluations from other users regarding policies formulated by the user.

[0961] "Voting results" refers to the aggregated results of votes cast by all users in the election event.

[0962] "Virtual city management" is a process in which users act as managers of a virtual city, drafting policies and simulating their social impact.

[0963] The invention is implemented as a virtual city management simulator application, in which users access the simulator and, as managers of a virtual city, formulate various policies, simulate their social impact, and participate in the election process.

[0964] System Configuration

[0965] The system mainly consists of the following components:

[0966] 1. User Device

[0967] Provide an interface for formulating policy.

[0968] Displays simulation results, election information, etc.

[0969] Providing a means for users to participate in elections and cast their votes.

[0970] 2. Server

[0971] Receives policy data sent by users and stores it in a database.

[0972] Obtain the necessary correlation data and simulate the social impact of policies using an AI simulation engine.

[0973] Simulation results are generated and sent to the user terminal.

[0974] Election events will be held periodically and information about them will be sent to users' devices.

[0975] The voting results for each election event will be tallied and the election results will be announced.

[0976] 3. Database

[0977] Stores policy and correlation data.

[0978] Correlated data includes historical statistical data and related information.

[0979] 4. AI Simulation Engine

[0980] It is used to predict the social impact of policies based on policy data and correlation data formulated by users.

[0981] The specific hardware and software used

[0982] Server: Web server using Flask

[0983] Database: SQLite

[0984] AI Simulation Engine: Linear Regression Models Using Scikit-learn

[0985] Program processing explanation

[0986] The server is operated using a web server framework called Flask and stores policy data and correlation data in an SQLite database. Policy data sent from user devices is received by the server and saved in the database. The server then uses the saved policy data and correlation data to run an AI simulation engine (here, a Linear Regression model from Scikit-learn) to predict the impact of policies on society.

[0987] Simulation results are generated by the server and sent to the user's device. The received simulation results are visually displayed on the user's device. The server also periodically holds election events and notifies the user's device. Users can participate in elections via their device, evaluate other users' policies, and cast their votes. The voting results are tallied by the server and notified to the user's device.

[0988] Specific examples

[0989] When a user proposes a policy such as "increasing the education budget," the device sends the policy data to the server. The server stores the policy data in a database and performs a simulation based on correlation data. The result is that "increasing the education budget is expected to improve academic performance by 5% in the next year," which is displayed on the user's device.

[0990] Example prompt sentence:

[0991] "Simulate the impact of increasing the education budget by 10%."

[0992] In this way, users can experience everything from policy formulation to simulation and the electoral process, virtually learning about the processes involved in the formation of politics and policies.

[0993] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0994] Step 1:

[0995] The user inputs the policy on the terminal and sends it to the server. The user uses the terminal interface to create a new policy and input its details. The input policy data (policy name, details, target group, etc.) is sent from the terminal to the server. The input data is the basic information of the policy.

[0996] Step 2:

[0997] The server receives the policy data and stores it in a database. The server receives the policy data sent from the terminal and stores the data in an SQLite database. The received data is detailed policy information, and the saving operation persists the data.

[0998] Step 3:

[0999] The server retrieves the necessary correlation data from the database. The server retrieves past statistical data and related information needed to simulate the social impact of policies from the database. The retrieved data is statistical data on the effects of past policies, etc.

[1000] Step 4:

[1001] The server runs a simulation based on policy data and correlation data. Using an AI simulation engine (using a Linear Regression model), the server inputs the acquired policy data and correlation data and performs data calculations to predict the social impact of the policy. The input data are policy data and correlation data, and the output is the simulation results for predicting the impact of the policy.

[1002] Step 5:

[1003] The server generates the simulation results and sends them to the user terminal. The simulation results (e.g., "An increase in the education budget is expected to improve academic performance by 5% in the next year") are generated by the server and sent to the user terminal. The output data are the simulation results.

[1004] Step 6:

[1005] The user terminal visually displays the simulation results received. The user terminal visually displays the simulation results received from the server in an easy-to-read manner. The display operation is the visualization of data.

[1006] Step 7:

[1007] The server periodically holds election events and notifies user terminals of the information. The server generates information about election events that are periodically held and notifies user terminals of the information. The notification data is detailed information about the election events.

[1008] Step 8:

[1009] Users participate in elections and vote through their devices. Users evaluate policies proposed by other users and cast their votes through their devices. The input data is the user's voting information.

[1010] Step 9:

[1011] The server tally the voting results and notify the election results. The server tally the voting data sent by all users and generate the election results. These election results are notified to the user terminals. The output data is the election results.

[1012] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1013] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections, and also combines it with an emotion recognition engine that recognizes user emotions. The system consists of the following components:

[1014] 1. User Device

[1015] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through the interface and send policy data directly to the server from the terminal. It also has an emotion recognition engine that analyzes the user's facial expressions and tone of voice to recognize their emotions.

[1016] 2. Server

[1017] The server receives policy data and emotion data sent from user devices and stores them in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[1018] 3. Database

[1019] The database is intended to store policy data, correlation data, and sentiment data. The correlation data includes historical statistical data and related information necessary for simulating the social impact of policies, while the sentiment data records user reactions.

[1020] 4. AI Simulation Engine

[1021] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are automatically generated and sent to the user's device.

[1022] 5. Emotion Recognition Engine

[1023] The emotion recognition engine is installed on the user's device and recognizes emotions by analyzing the user's facial expressions and tone of voice. This data is used for policy simulations and election results analysis, and is used to customize the display of results.

[1024] Program processing

[1025] Policy formulation

[1026] The user inputs a new policy through the device interface and sends the policy data to the server. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[1027] Acquiring emotion data

[1028] The emotion recognition engine analyzes the user's facial expressions and tone of voice to generate emotion data. For example, it can recognize whether the user is feeling stressed when entering a policy. The generated emotion data is simultaneously sent to the server.

[1029] Receiving and storing data

[1030] The server receives the policy data and emotion data and stores them in a database for later use in simulations and result analysis.

[1031] Correlated Data Acquisition and Simulation

[1032] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, an AI simulation engine is used to predict the social impact of policies.

[1033] Notification and display of simulation results

[1034] Once the simulation is complete, the server generates results and sends them to the user's device in a format customized based on the user's emotional data. For example, if the user is feeling stressed, the results are displayed in an easy-to-understand format. The user's device visually displays the received simulation results to the user. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed.

[1035] The Election Process

[1036] The server periodically holds election events and notifies user devices of this information. Users use their devices to participate in elections and appeal their policies to other users. Users can present their policies while observing the reactions of other users through an emotion recognition engine. The device sends the appeal information entered by the user to the server, which other users can then evaluate and vote for. The server tallys the voting results of all users, generates the election results, and notifies the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[1037] Through this system, users can experience the process from policy formulation to elections and understand its impact on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, enhancing user understanding and engagement. This is expected to improve political understanding and social participation, especially among young people.

[1038] The processing flow will be explained below.

[1039] Step 1:

[1040] The user inputs the policy into the device interface. The user inputs information such as the policy name (e.g., "Increase the education budget"), details, and target group into the device.

[1041] Step 2:

[1042] The device analyzes the user's facial expressions and tone of voice to generate emotional data, and the emotion recognition engine determines whether the user is stressed or excited.

[1043] Step 3:

[1044] The terminal sends the input policy data and generated emotion data to the server, which then formats the data appropriately and generates a request to send to the server.

[1045] Step 4:

[1046] The server receives the policy data and emotion data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[1047] Step 5:

[1048] The server stores the received policy data and emotion data in a database, where IDs are assigned so that the policy data and emotion data can be uniquely identified.

[1049] Step 6:

[1050] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[1051] Step 7:

[1052] The server generates a data set for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[1053] Step 8:

[1054] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[1055] Step 9:

[1056] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[1057] Step 10:

[1058] The server sends the generated simulation results to the user terminal, and the server packages the simulation results in an appropriate format and generates a request to send them to the user terminal.

[1059] Step 11:

[1060] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[1061] Step 12:

[1062] The simulation results received by the user's device are visually displayed. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed. The display is also customized to the user based on emotional data.

[1063] Step 13:

[1064] The server periodically holds election events and notifies the terminal of the information. The server generates notifications to inform users of the election event time and related information.

[1065] Step 14:

[1066] Users use their devices to participate in elections and promote their policies. Users input presentation information to promote their policies to other users.

[1067] Step 15:

[1068] The device sends the presentation information and emotion data entered by the user to the server, which stores the data and makes it available to other users.

[1069] Step 16:

[1070] Users use their devices to vote for other users' policies. Users evaluate the presented policy information and send their voting data from their devices.

[1071] Step 17:

[1072] The server aggregates the votes of all users and generates the election results. The server analyzes the aggregated voting data and identifies the policy that received the most support.

[1073] Step 18:

[1074] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[1075] Step 19:

[1076] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[1077] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, improving user understanding and engagement. This is expected to improve young people's understanding of politics and their sense of social participation.

[1078] Example 2

[1079] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1080] In modern society, young people are expected to take an interest in politics and policy and to actively participate in it. However, understanding policy-making and its social impact is not easy, and many young people are reluctant to participate in politics. An educational support system is needed to solve this problem and improve young people's understanding of politics and their awareness of social participation.

[1081] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1082] In this invention, the server includes: means for formulating policies through a user terminal; means for transmitting policy data to the server; means for acquiring user emotion data in the user terminal and transmitting it to the server; means for storing the received policy data and emotion data in a database in the server; means for acquiring correlation data necessary for simulating the social impact of policies in the server; means for running a simulation based on the acquired correlation data and policy data in the server; means for generating simulation results in the server, customizing them based on the emotion data, and transmitting them to the user terminal; means for visually displaying the received simulation results in the user terminal; means for periodically holding an election event in the server and notifying the user terminal of the information; means for participating in elections and voting through the user terminal; and means for tallying vote results in the server and notifying the user of the election results. This allows young people to experience the process from policy formulation to elections in real time and receive feedback based on their emotions, thereby improving their understanding of politics and their sense of social participation.

[1083] A "user terminal" is a device used by a user to input policies and display simulation results and election information.

[1084] "Policy data" is data containing information about policies formulated by users, including policy names, details, target groups, etc.

[1085] "Emotion data" refers to data that includes information about emotions obtained by analyzing a user's facial expressions and tone of voice.

[1086] The "server" is a central computer that receives policy data and emotion data from user terminals, stores them in a database, obtains correlation data, and runs simulations.

[1087] "Database" is an information management system for storing policy data, emotion data, and correlation data.

[1088] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[1089] The "AI simulation engine" is a program equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[1090] "Simulation results" are predicted data on the social impact of policies generated by the AI ​​simulation engine.

[1091] An "election event" is an event that involves a user virtually participating in an election, promoting their own policies, and receiving votes from other users.

[1092] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections. It also incorporates an emotion recognition engine that recognizes user emotions. The system is implemented by combining the following main components and operations:

[1093] System configuration and functions

[1094] 1. User Device

[1095] A user terminal is a device used by users to input policies and display simulation results and election information. Specifically, this includes PCs, smartphones, and tablets. The terminal is equipped with an emotion recognition engine that analyzes the user's facial expressions and tone of voice. This generates user emotion data.

[1096] 2. Server

[1097] The server receives policy data and emotion data sent from user devices and stores them in a database. The server then retrieves correlation data from the database to simulate the social impact of policies and runs the simulation using an AI simulation engine.

[1098] 3. Database

[1099] The database is an information management system that stores policy data, sentiment data, and correlation data. The correlation data includes historical statistical data and related information and is used to simulate the social impact of policies.

[1100] 4. AI Simulation Engine

[1101] The AI ​​simulation engine is a program that predicts the social impact of policies based on policy data and correlation data. The simulation results are customized based on the user's emotional data and sent to the user's device.

[1102] 5. Emotion Recognition Engine

[1103] The emotion recognition engine is installed on the user's device and generates emotional data by analyzing the user's facial expressions and tone of voice, which is used for policy simulations and election results analysis.

[1104] Use cases and specific steps

[1105] Below are the specific steps users can take to formulate new policies, simulate their impact, and participate in elections.

[1106] 1. Policy input

[1107] The user inputs a policy using the device interface. For example, to formulate a policy such as "increase the education budget by 10%," the user enters this into the device's text field and clicks the submit button.

[1108] 2. Acquiring Emotion Data

[1109] While entering the policy, the camera and microphone on the user's device capture the user's facial expressions and voice in real time, which are then analyzed by the emotion recognition engine to generate emotion data, such as "Stress level: High."

[1110] 3. Data transmission and storage

[1111] The device sends policy data and emotion data to the server, which receives them and stores them in a database.

[1112] 4. Running the Simulation

[1113] The server retrieves the necessary correlation data from the database and inputs it into the AI ​​simulation engine along with the policy data. The simulation is run and the social impact of the policy is predicted. For example, a result such as "Increasing the education budget will improve academic performance by 5%" is generated.

[1114] 5. Notification of simulation results

[1115] The simulation results are customized based on emotional data, for example, to be displayed in a more understandable format for users who are feeling stressed, and then sent to the user's device for visual display.

[1116] 6. Holding election events

[1117] The server periodically holds election events and sends information to user devices. Users appeal to other users about their policies and receive votes. They can also observe other users' reactions using an emotion recognition engine. Finally, the server tallys the votes and notifies users of the election results.

[1118] Prompt Sentence Examples

[1119] An example prompt might use the following text:

[1120] "Simulate how an increase in the education budget will affect student academic performance."

[1121] "Please provide data on the socio-economic impact of investments in the education sector over the past 10 years and analyze the correlations."

[1122] The system allows users to experience the process from policymaking to elections and understand its impact on society in real time. The system also incorporates an emotion recognition engine to provide personalized learning and feedback, helping users better understand politics and participate in society.

[1123] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1124] Step 1: Enter and submit policy data

[1125] The user inputs the policy using the terminal interface. The policy data includes the policy name, details, target group, etc. After inputting is complete, the user clicks the "Submit" button, which is sent to the terminal. The terminal then sends this policy data to the server.

[1126] Input: Policy data entered by the user into the interface.

[1127] Output: Policy data sent from the terminal to the server

[1128] Specific operation: For example, enter a policy such as "Increase the education budget by 10%" and click the send button. At this time, the policy data (the policy name "Increase the education budget by 10%" and details) is sent from the device to the server.

[1129] Step 2: Obtaining and sending emotion data

[1130] While the user is entering the policy, the device's camera and microphone capture the user's facial expressions and voice in real time. The emotion recognition engine analyzes this and generates the user's emotional data. The generated emotional data is then sent to the server along with the policy data.

[1131] Input: User facial expressions and tone of voice

[1132] Output: Emotion data sent to the server

[1133] Specific operation: During policy input, the camera and microphone capture the user's face and voice, and emotional data such as "stress level: high" and "happiness level: low" is generated and sent to the server.

[1134] Step 3: Receiving and storing data

[1135] The server receives the policy data and emotion data sent from the device and stores them in a database for later use in simulations and result analysis.

[1136] Input: Policy data and emotion data sent from the device

[1137] Output: Policy data and sentiment data stored in a database

[1138] Specific operation: The server checks the received policy data and emotion data and stores them appropriately in the database. This storage process allows for future reference.

[1139] Step 4: Obtain correlation data and run simulation

[1140] The server retrieves the correlation data needed to simulate the impact of policies from the database. This correlation data includes past statistical data and related information. The AI ​​simulation engine runs a simulation based on the retrieved correlation data to predict the social impact of policies.

[1141] Input: Correlation data and policy data retrieved from databases

[1142] Output: Simulation results

[1143] Specific operation: The server retrieves correlation data from the database, such as "the impact of past increases in education budgets on academic performance and the national economy," and based on this, the AI ​​simulation engine generates simulation results, such as "a 5% improvement in academic performance is expected."

[1144] Step 5: Generate and communicate simulation results

[1145] Once the simulation is complete, the server generates results and customizes them based on the user's emotional data. For example, if the user is feeling stressed, the results will be adjusted to be displayed in an easy-to-understand format. The generated results are sent to the user's device and displayed visually.

[1146] Input: Simulation results and emotion data

[1147] Output: Customized simulation results

[1148] How it works: The server generates simulation results and adjusts the display format based on emotional data (e.g., "Stress level: High"). The customized results are then sent to the user's device, where they are displayed, such as "Increasing the education budget will improve academic performance by 5%."

[1149] Step 6: Holding election events and announcing results

[1150] The server periodically holds election events and notifies users of the information on their devices. Users can use their devices to participate in elections and promote their policies to other users. During this process, the emotion recognition engine observes the reactions of other users and provides feedback. After the votes are cast, the server tallys the voting results of all users and notifies them of the results.

[1151] Input: Election information and user voting data

[1152] Output: Counted voting results

[1153] Specific operation: The server notifies the user that an election event has started, and the user creates and submits a policy appeal. The device analyzes other users' reactions in real time and provides feedback, such as "This policy is highly rated." Finally, the server tallies the voting results and notifies the user of the result, such as "Increasing the education budget received the most votes."

[1154] (Application example 2)

[1155] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1156] Current educational systems make it difficult for users to experience the entire political process, from policy formulation to the electoral process. Furthermore, the educational effectiveness is limited by the lack of ways for users to understand the social impact of policies in real time and receive individual feedback. Furthermore, systems that provide feedback tailored to the user's state through emotion recognition are also inadequate. Furthermore, when considering use in physical stores, creating an environment where a large number of users can use the system simultaneously presents a challenge.

[1157] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for formulating policies through a user terminal, means for transmitting policy data to the server, and means for storing the received policy data in a database. This enables users to formulate policies in physical stores and simulate their social impact in real time. In addition, by including means for acquiring user emotion data through an emotion recognition engine and customizing and displaying simulation results based on the emotion data, and means for the user to input policies through smart glasses and visually provide the displayed content, feedback can be provided according to the user's state, enhancing the effectiveness of education.

[1158] A "user terminal" is a device used by a user to input policies and display simulation results.

[1159] The "server" is a central processing unit that receives, stores, and processes policy data and emotion data, and generates and notifies the results of simulations.

[1160] "Policy data" is information about policies formulated by users, including details and target groups.

[1161] A "database" is an information storage system that stores policy data, sentiment data, and correlation data and makes them accessible when needed.

[1162] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[1163] The "AI simulation engine" is an artificial intelligence engine that predicts the social impact of policies based on policy data and correlation data, and generates simulation results.

[1164] An "emotion recognition engine" is software that analyzes a user's facial expressions and tone of voice and generates emotional data.

[1165] "Emotion data" is information about a user's emotions generated by an emotion recognition engine.

[1166] "Smart glasses" are wearable devices used to virtually provide policy formulation, display simulation results, and more.

[1167] An "election event" is an event that is periodically held by the server to allow users to evaluate and vote on policies formulated by users.

[1168] "Voting results" refers to information that compiles the voting results of users who participated in the election event.

[1169] "Customized display" is a display method that provides simulation results in an easy-to-understand manner based on the user's emotional data.

[1170] This invention relates to an educational support system that allows users to formulate policies in physical stores and simulate their social impact. It uses an emotion recognition engine and smart glasses to provide feedback according to the user's emotional state. The program and processing of this system are described below.

[1171] System Overview

[1172] The system consists of the following major components:

[1173] 1. User Device

[1174] 2. Server

[1175] 3. Database

[1176] 4. AI Simulation Engine

[1177] 5. Emotion Recognition Engine

[1178] 6. Smart Glasses

[1179] Hardware and software used

[1180] Smart glasses (e.g. Google Glass)

[1181] Emotion recognition API (e.g. Microsoft Azure Emotion API)

[1182] Front-end frameworks (React, Vue.js, etc.)

[1183] Server API (Node.js, Python Flask, etc.)

[1184] Database (MySQL, MongoDB, etc.)

[1185] AI simulation engines (TensorFlow, PyTorch, etc.)

[1186] Program processing overview

[1187] 1. Policy input and formulation:

[1188] Users input new policies using the touchpad or voice recognition function of the smart glasses. This policy data is sent to the server in real time. The user terminal (smart glasses) provides an interface where data such as the policy name, details, and target group can be entered.

[1189] 2. Acquiring emotion data:

[1190] The smart glasses' built-in camera and microphone are used to analyze the user's facial expressions and tone of voice. This data is sent to an emotion recognition API, which generates emotion data. The generated emotion data is then simultaneously sent to the server.

[1191] 3. Data storage and processing:

[1192] The server stores the received policy and emotion data in a database. These data are used for subsequent simulations and result analysis. The data is properly structured and stored, and can be accessed at any time.

[1193] 4. Simulation and Results Notification:

[1194] The server retrieves relevant correlation data from the database and uses an AI simulation engine to simulate the social impact of policies. The simulation results are customized based on the user's emotional data and displayed on the smart glasses. If the user is feeling stressed, the results will be presented in an easy-to-understand format.

[1195] 5. Visualization of results:

[1196] The smart glasses display visually displays the simulation results, such as "Increasing the education budget" as a policy that "is expected to improve academic performance by 5%." This allows users to intuitively understand the results.

[1197] Examples and prompts

[1198] Example: A user puts on smart glasses and inputs a policy of "increasing the education budget" via voice command. The camera in the glasses analyzes the user's facial expression, and the emotion recognition engine determines that the user is stressed. The server runs a simulation based on the data for the "increasing the education budget" policy, and displays a simple bar graph on the smart glasses showing the expected 5% improvement in student academic performance due to the increase in the education budget. The results are presented in an easy-to-understand format even when the user is stressed.

[1199] Example prompt sentence:

[1200] "A user has proposed a policy to 'increase the education budget.' Simulate the social impact of this policy and briefly explain the results."

[1201] Through this system, users can concretely experience the entire process, from policy formulation to the election process, and receive real-time feedback using emotion recognition, which is expected to improve political understanding and social participation.

[1202] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1203] Step 1:

[1204] The user inputs a new policy through the user terminal (smart glasses). The user inputs the policy data using voice recognition or the touchpad, and the data is sent to the server in real time. The input includes the policy name, details, and target group, and the server receives the policy data based on this. The input policy data is temporarily stored in memory and passed to the next step.

[1205] Step 2:

[1206] The camera and microphone built into the smart glasses capture the user's facial expressions and tone of voice. The emotion recognition engine analyzes this data and generates emotional data. The emotion recognition API (Microsoft Azure Emotion API) is called, and the emotion is output as numerical data as the analysis result. This generated emotional data is immediately sent to the server. The emotional data includes items such as stress level, joy, and surprise.

[1207] Step 3:

[1208] The server stores the received policy data and emotion data in a database. The data is stored using an appropriate data structure, using SQL queries or NoSQL document operations. Metadata is also stored for later retrieval and processing. The input data is stored in the database and prepared with the correlation data required for the next step.

[1209] Step 4:

[1210] The server retrieves the correlation data needed to simulate the social impact of policies from the database. This correlation data includes past policy data and related statistical information. It searches these using keys, loads the relevant data into main memory, and uses it in the next simulation step. All correlation data corresponding to the input policy is collected and passed to the AI ​​simulation engine.

[1211] Step 5:

[1212] The server runs a simulation using an AI simulation engine based on the acquired correlation data and policy data. The simulation engine (TensorFlow, PyTorch) is used to predict the social impact of policies. The simulation process involves preprocessing the data, applying models, generating results, and outputting the simulation results. The output results are passed on to the next step.

[1213] Step 6:

[1214] The server generates simulation results and sends them to the user's device in a format customized based on the user's emotional data. If the user is feeling stressed, the results are provided in a visually simple format, allowing the user to receive the simulation results in a format that is easy to understand. The results are output in a format that can be displayed on the smart glasses as simple graphs and charts.

[1215] Step 7:

[1216] The smart glasses visually display the received simulation results to the user. The results are optimized based on emotion recognition, providing information in a format that is easy for the user to understand. Specific results can be displayed, such as "a 5% expected improvement in academic performance" in response to the policy "increase in education budget." The displayed content is rendered on the screen and fed back to the user.

[1217] Through these steps, users can understand policy impacts in real time, enriching their in-store educational experience.

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

[1219] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

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

[1221] [Fourth embodiment]

[1222] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1223] 7, a 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.

[1224] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1225] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1226] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[1228] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1229] The control object 443 includes a display device, LEDs in the eyes, and motors for driving 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 emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1230] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1231] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[1233] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[1235] This invention relates to an educational support system that allows users to formulate policies, run a virtual government, and participate in elections. The system comprises the following components:

[1236] 1. User Device

[1237] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through an interface and send policy data directly from the terminal to the server. The terminal also visually displays received simulation results and election notifications to users.

[1238] 2. Server

[1239] The server receives policy data sent from user devices and stores it in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[1240] 3. Database

[1241] The database is for storing policy data and correlation data, including historical statistical data and related information necessary for simulating the social impact of policies.

[1242] 4. AI Simulation Engine

[1243] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are generated and sent to the user's device.

[1244] Program processing

[1245] Policy formulation

[1246] The user inputs a new policy using the device interface. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[1247] Receiving and storing data

[1248] The server receives the policy data sent to it and stores it in a database, which is used later in the simulation process.

[1249] Correlated Data Acquisition and Simulation

[1250] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, the server uses an AI simulation engine to predict the social impact of policies.

[1251] Notification and display of simulation results

[1252] When the simulation is complete, the server generates the results and sends them to the user's device, which then visually displays the received simulation results. For example, the result might be, "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[1253] The Election Process

[1254] The server periodically holds election events and notifies user devices of the information. Users use their devices to participate in elections and promote their policies to other users. Users can evaluate the policies of other users and vote via their devices. The server tally the voting results of all users, generate election results, and notify the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[1255] Through this system, users can learn by experiencing everything from policy formulation to elections in a virtual environment that models the real political process, which will contribute to improving political understanding and social participation, especially among young people.

[1256] The processing flow will be explained below.

[1257] Step 1:

[1258] The user inputs the policy into the device interface. The user inputs information such as the policy name, details, and target group into the device.

[1259] Step 2:

[1260] The terminal sends the policy data entered by the user to the server, and the terminal formats the policy data in an appropriate format and generates a request to send it to the server.

[1261] Step 3:

[1262] The server receives the policy data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[1263] Step 4:

[1264] The server stores the received policy data in a database, and assigns an ID to the database so that the stored policy data can be uniquely identified.

[1265] Step 5:

[1266] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[1267] Step 6:

[1268] The server generates a dataset for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[1269] Step 7:

[1270] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[1271] Step 8:

[1272] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[1273] Step 9:

[1274] The server transmits the generated simulation results to the user terminal, and the server generates a request to package the simulation results into an appropriate format and transmit them to the user terminal.

[1275] Step 10:

[1276] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[1277] Step 11:

[1278] The simulation results received by the user device are visually displayed, showing specific results such as "a 5% expected improvement in academic performance due to an increase in the education budget."

[1279] Step 12:

[1280] The server periodically holds election events and notifies the terminals of the information. The server generates notifications to inform users of the election event times and related information.

[1281] Step 13:

[1282] Users use their devices to participate in elections and promote their policies. Users input appeal information to present the benefits and data of their policies to other users.

[1283] Step 14:

[1284] The device sends the appeal information entered by the user to the server, where it is managed so that it can be displayed to other users.

[1285] Step 15:

[1286] Users use their devices to vote for policies of other users. Users evaluate and vote for policies formulated by other users.

[1287] Step 16:

[1288] The server tally the votes of all users and generate the election results. The server analyzes the voting data and identifies the most popular policy.

[1289] Step 17:

[1290] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[1291] Step 18:

[1292] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[1293] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The system aims to contribute to improving political understanding and social participation, especially among young people.

[1294] Example 1

[1295] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1296] In modern society, political education, especially for young people, offers few opportunities to experience the actual political process, resulting in low levels of political understanding and a sense of social participation. Furthermore, there is a lack of simulation tools to concretely understand the impact of policies, and there is no system that provides a consistent experience from policy formulation to electoral participation.

[1297] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1298] In this invention, the server includes a means for a user terminal to access and log in to the system via a browser or a dedicated application, a means for packetizing policy data and sending it to the server via HTTPS, a means for the server to receive the policy data at an API endpoint, and a means for visually displaying simulation results in graphs or text format. This allows users to learn through hands-on experience in a virtual environment the entire political process, from policy formulation to simulating its social impact, and even policy evaluation and voting in elections, thereby improving their understanding of politics and their sense of social participation.

[1299] A "user terminal" is a device used by a user to perform operations such as formulating policies, displaying simulation results, and participating in elections.

[1300] A "server" is a computer system that receives policy data sent from user terminals, stores it in a database, runs simulations based on correlation data, and performs other tasks such as holding election events and tallying voting results.

[1301] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[1302] A "database" is a collection of data managed on a server, and is an area where policy data, correlation data, etc. are stored.

[1303] "Correlation data" refers to past statistical data and related information necessary to simulate the social impact of policies.

[1304] The "AI simulation engine" is a system equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[1305] "Simulation results" are predictive data generated by an AI simulation engine that shows how a particular policy will affect society.

[1306] An "election event" is an event in which users vote in a virtual environment based on policies proposed by users to determine the most popular policy.

[1307] "Voting results" are the aggregated results of users' votes at election events, and are data showing which policies received how much support.

[1308] The "HTTPS protocol" is a communication method for securely sending and receiving data over the Internet.

[1309] An "API endpoint" is a URL on a server that can be accessed by external systems to provide a specific function.

[1310] This invention relates to an educational support system that allows users to formulate policies, manage a virtual government, and participate in elections. The system includes a user terminal, a server, a database, and an AI simulation engine.

[1311] The user terminal is a device used by users to formulate policies, view simulation results, participate in elections, and perform other operations. Specifically, users can access the system and log in to their own accounts using a browser or a dedicated application. Users enter the policy name, details, target group, etc. through the policy formulation interface and click the "Submit" button to send the policy data to the server. The policy data is packetized in JSON format and securely sent to the server via the HTTPS protocol.

[1312] The server is the central component that processes the received policy data. The server receives the policy data via the API endpoint, parses it, and stores it in a database. The stored policy data is later used for simulations. The server also retrieves correlation data from the database, which is necessary to simulate the social impact of policies. The correlation data includes historical statistical data and related information.

[1313] The AI ​​simulation engine is equipped with artificial intelligence to predict the social impact of policies based on policy data and correlation data. The server passes the acquired correlation data and policy data to the AI ​​simulation engine, which then runs the simulation. The resulting simulation results are returned to the server, converted back to JSON format, and sent to the user's device.

[1314] The user device has the function of visually displaying the simulation results. It parses the received simulation results and displays them visually in graphs and text format. For example, it displays specific results such as "An increase in the education budget is expected to result in a 5% improvement in academic performance in the next year."

[1315] The server also periodically holds election events. It uses a scheduler to set the timing of election events and sends notifications to all users. Users can view and evaluate the policies of other candidates, then vote for their choice. The server aggregates the voting results of all users and generates election results, such as "Policy 'Increase education budget' received the most votes." These election results are again notified to user devices and displayed visually.

[1316] As a concrete example, when a user formulates an "environmental protection policy," they input the policy details as "increasing the investment rate in renewable energy, strengthening forest conservation activities, and improving waste recycling rates." Simulation results are displayed such as "investment in renewable energy will increase the region's energy self-sufficiency rate by 15% and reduce carbon emissions by 10%." During the election process, the server notifies users of the results, such as "The environmental protection policy received the most votes in the user vote and will be adopted as the next policy."

[1317] An example of a prompt is as follows:

[1318] "Simulate how an increase in the education budget would affect society."

[1319] "You have proposed a policy to increase the share of investment in renewable energy to 50%. Simulate the social impact of this policy and display the results."

[1320] In this way, the present invention provides a system that allows users to experience the political process in a virtual environment through a series of processes including policy planning, simulation, and elections, thereby improving their understanding of politics and their sense of social participation.

[1321] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1322] Step 1:

[1323] The user starts up the device and logs in using a browser or a dedicated application. As input, the user enters their account information (username and password). The server executes the authentication process and outputs the success or failure of user authentication. Specifically, if authentication is successful, the policy formulation interface is displayed to the user.

[1324] Step 2:

[1325] The user inputs a new policy using the policy formulation interface. As input, the user enters the policy name, details, target group, etc. When the user clicks the "Submit" button, the user terminal packets the entered policy data into JSON format and sends it to the server via the HTTPS protocol. As output, the policy data is sent.

[1326] Step 3:

[1327] The server receives the policy data. Specifically, the server waits for POST requests at a specific API endpoint and parses the received data. It receives JSON-formatted policy data as input and obtains the parsed policy data as output.

[1328] Step 4:

[1329] The server stores the received policy data in the database. Specifically, the server executes an insert query to store the parsed policy data in the database. It receives the parsed policy data as input and adds a new record to the database as output.

[1330] Step 5:

[1331] The server retrieves correlation data from the database. Specifically, the server uses a SELECT query to retrieve the data needed to simulate the impact of policies from the "CorrelationData" table, which stores past statistical data. As input, the conditions for the correlation data to be retrieved are specified, and as output, the correlation data is obtained.

[1332] Step 6:

[1333] The server passes the acquired correlation data and policy data to the AI ​​simulation engine. Specifically, the server sends the policy data and correlation data to the AI ​​simulation engine's API. It receives the policy data and correlation data as input and sends the simulation prompt and data to the AI ​​simulation engine as output.

[1334] Step 7:

[1335] The AI ​​simulation engine simulates the social impact of policies and generates results. Specifically, the AI ​​simulation engine predicts the impact based on the data it receives and generates results. It receives policy data and correlation data as input and generates simulation results as output.

[1336] Step 8:

[1337] The server receives the simulation results from the AI ​​simulation engine and sends them to the user device. Specifically, the server converts the simulation results back into JSON format and sends them to the user device. The server receives the simulation results from the AI ​​simulation engine as input and sends them to the user device as output.

[1338] Step 9:

[1339] The user terminal visually displays the received simulation results. Specifically, the user terminal parses the JSON format data and displays it on the screen in graph or text format. It receives the simulation result data as input and visually displays it to the user as output.

[1340] Step 10:

[1341] The server periodically holds election events and notifies user terminals of the information. Specifically, the server sends election start notifications to all users based on a pre-set schedule. The server receives schedule information as input and sends notifications to user terminals as output.

[1342] Step 11:

[1343] Users participate in elections, advocate for their policies, and cast their votes. Specifically, users view and evaluate the policies of other users, and then vote. The system receives other users' policy information and voting options as input, and transmits the voting results as output.

[1344] Step 12:

[1345] The server tally the votes of all users and generate the final election results. Specifically, the server retrieves the voting data from the database and calculates the results using a tallying algorithm. It receives each user's voting data as input and obtains the tally results as output.

[1346] Step 13:

[1347] The server notifies the user device of the election results, which are then displayed visually. Specifically, the server converts the results into JSON format and sends them to the user device, which then displays them on the screen. The server receives the results as input and visually notifies the user as output.

[1348] (Application example 1)

[1349] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1350] One issue is the lack of systems that model the real political process and allow users to experience and learn about the entire process from policy formulation to elections. There is a particular lack of educational support systems aimed at improving young people's understanding of politics and their sense of social participation. Furthermore, there are no adequate mechanisms for evaluating policies through competition and cooperation among users.

[1351] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1352] In this invention, the server includes a means for allowing users to formulate policies as managers of a virtual city and simulate their impact, a means for holding elections among users and evaluating the policies, and a user terminal includes a means for formulating policies and receiving and displaying the results of the simulation, a means for notifying users of election information, and a means for participating in and voting in elections. This enables users to deepen their understanding of politics through policy formulation in a virtual environment, simulating its social impact, and the election process.

[1353] A "user terminal" is a device that provides functions such as formulating policies, receiving and displaying simulation results, notifying election information, and participating in and voting in elections.

[1354] A "server" is a device whose role is to receive policy data sent from user terminals, store it in a database, simulate the social impact of policies, hold election events, and notify the user terminals of that information.

[1355] "Policy data" is information about policies formulated by users, including policy names, details, target groups, etc.

[1356] A "database" is a storage device for storing policy and correlation data received by a server.

[1357] "Correlation data" refers to data that includes past statistical data and related information that is necessary to simulate the social impact of policies.

[1358] An "AI simulation engine" is an artificial intelligence engine used to predict the social impact of a policy based on policy data and correlation data.

[1359] "Simulation results" are predictive data generated by the AI ​​simulation engine about the impact of specific policies on society.

[1360] An "election event" is an election activity conducted by a user to receive evaluations from other users regarding policies formulated by the user.

[1361] "Voting results" refers to the aggregated results of votes cast by all users in the election event.

[1362] "Virtual city management" is a process in which users act as managers of a virtual city, drafting policies and simulating their social impact.

[1363] The invention is implemented as a virtual city management simulator application, in which users access the simulator and, as managers of a virtual city, formulate various policies, simulate their social impact, and participate in the election process.

[1364] System Configuration

[1365] The system mainly consists of the following components:

[1366] 1. User Device

[1367] Provide an interface for formulating policy.

[1368] Displays simulation results, election information, etc.

[1369] Providing a means for users to participate in elections and cast their votes.

[1370] 2. Server

[1371] Receives policy data sent by users and stores it in a database.

[1372] Obtain the necessary correlation data and simulate the social impact of policies using an AI simulation engine.

[1373] Simulation results are generated and sent to the user terminal.

[1374] Election events will be held periodically and information about them will be sent to users' devices.

[1375] The voting results for each election event will be tallied and the election results will be announced.

[1376] 3. Database

[1377] Stores policy and correlation data.

[1378] Correlated data includes historical statistical data and related information.

[1379] 4. AI Simulation Engine

[1380] It is used to predict the social impact of policies based on policy data and correlation data formulated by users.

[1381] The specific hardware and software used

[1382] Server: Web server using Flask

[1383] Database: SQLite

[1384] AI Simulation Engine: Linear Regression Models Using Scikit-learn

[1385] Program processing explanation

[1386] The server is operated using a web server framework called Flask and stores policy data and correlation data in an SQLite database. Policy data sent from user devices is received by the server and saved in the database. The server then uses the saved policy data and correlation data to run an AI simulation engine (here, a Linear Regression model from Scikit-learn) to predict the impact of policies on society.

[1387] Simulation results are generated by the server and sent to the user's device. The received simulation results are visually displayed on the user's device. The server also periodically holds election events and notifies the user's device. Users can participate in elections via their device, evaluate other users' policies, and cast their votes. The voting results are tallied by the server and notified to the user's device.

[1388] Specific examples

[1389] When a user proposes a policy such as "increasing the education budget," the device sends the policy data to the server. The server stores the policy data in a database and performs a simulation based on correlation data. The result is that "increasing the education budget is expected to improve academic performance by 5% in the next year," which is displayed on the user's device.

[1390] Example prompt sentence:

[1391] "Simulate the impact of increasing the education budget by 10%."

[1392] In this way, users can experience everything from policy formulation to simulation and the electoral process, virtually learning about the processes involved in the formation of politics and policies.

[1393] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1394] Step 1:

[1395] The user inputs the policy on the terminal and sends it to the server. The user uses the terminal interface to create a new policy and input its details. The input policy data (policy name, details, target group, etc.) is sent from the terminal to the server. The input data is the basic information of the policy.

[1396] Step 2:

[1397] The server receives the policy data and stores it in a database. The server receives the policy data sent from the terminal and stores the data in an SQLite database. The received data is detailed policy information, and the saving operation persists the data.

[1398] Step 3:

[1399] The server retrieves the necessary correlation data from the database. The server retrieves past statistical data and related information needed to simulate the social impact of policies from the database. The retrieved data is statistical data on the effects of past policies, etc.

[1400] Step 4:

[1401] The server runs a simulation based on policy data and correlation data. Using an AI simulation engine (using a Linear Regression model), the server inputs the acquired policy data and correlation data and performs data calculations to predict the social impact of the policy. The input data are policy data and correlation data, and the output is the simulation results for predicting the impact of the policy.

[1402] Step 5:

[1403] The server generates the simulation results and sends them to the user terminal. The simulation results (e.g., "An increase in the education budget is expected to improve academic performance by 5% in the next year") are generated by the server and sent to the user terminal. The output data are the simulation results.

[1404] Step 6:

[1405] The user terminal visually displays the simulation results received. The user terminal visually displays the simulation results received from the server in an easy-to-read manner. The display operation is the visualization of data.

[1406] Step 7:

[1407] The server periodically holds election events and notifies user terminals of the information. The server generates information about election events that are periodically held and notifies user terminals of the information. The notification data is detailed information about the election events.

[1408] Step 8:

[1409] Users participate in elections and vote through their devices. Users evaluate policies proposed by other users and cast their votes through their devices. The input data is the user's voting information.

[1410] Step 9:

[1411] The server tally the voting results and notify the election results. The server tally the voting data sent by all users and generate the election results. These election results are notified to the user terminals. The output data is the election results.

[1412] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1413] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections, and also combines it with an emotion recognition engine that recognizes user emotions. The system consists of the following components:

[1414] 1. User Device

[1415] The user terminal is a device used by users to input policies and display simulation results and election information. Users can formulate policies through the interface and send policy data directly to the server from the terminal. It also has an emotion recognition engine that analyzes the user's facial expressions and tone of voice to recognize their emotions.

[1416] 2. Server

[1417] The server receives policy data and emotion data sent from user devices and stores them in a database. It also obtains correlation data based on the policy data and simulates its social impact using an AI simulation engine. The server is also responsible for generating simulation results and sending them to user devices. In addition, the server periodically holds election events and notifies user devices of the information.

[1418] 3. Database

[1419] The database is intended to store policy data, correlation data, and sentiment data. The correlation data includes historical statistical data and related information necessary for simulating the social impact of policies, while the sentiment data records user reactions.

[1420] 4. AI Simulation Engine

[1421] The AI ​​simulation engine is installed on a server and is used to predict the social impact of policies based on policy data and correlation data formulated by users. Simulation results are automatically generated and sent to the user's device.

[1422] 5. Emotion Recognition Engine

[1423] The emotion recognition engine is installed on the user's device and recognizes emotions by analyzing the user's facial expressions and tone of voice. This data is used for policy simulations and election results analysis, and is used to customize the display of results.

[1424] Program processing

[1425] Policy formulation

[1426] The user inputs a new policy through the device interface and sends the policy data to the server. For example, if the user creates a policy called "Increase the education budget," the device sends this policy data to the server. The policy data includes the policy name, details, target group, etc.

[1427] Acquiring emotion data

[1428] The emotion recognition engine analyzes the user's facial expressions and tone of voice to generate emotion data. For example, it can recognize whether the user is feeling stressed when entering a policy. The generated emotion data is simultaneously sent to the server.

[1429] Receiving and storing data

[1430] The server receives the policy data and emotion data and stores them in a database for later use in simulations and result analysis.

[1431] Correlated Data Acquisition and Simulation

[1432] The server retrieves the correlation data needed to simulate the impact of policies from the database, such as data on the impact of past increases in education budgets on student academic performance and the national economy. Based on the correlation data and policy data, an AI simulation engine is used to predict the social impact of policies.

[1433] Notification and display of simulation results

[1434] Once the simulation is complete, the server generates results and sends them to the user's device in a format customized based on the user's emotional data. For example, if the user is feeling stressed, the results are displayed in an easy-to-understand format. The user's device visually displays the received simulation results to the user. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed.

[1435] The Election Process

[1436] The server periodically holds election events and notifies user devices of this information. Users use their devices to participate in elections and appeal their policies to other users. Users can present their policies while observing the reactions of other users through an emotion recognition engine. The device sends the appeal information entered by the user to the server, which other users can then evaluate and vote for. The server tallys the voting results of all users, generates the election results, and notifies the user devices. The user devices visually display the election results, providing information such as, "The policy 'Increase the education budget' received the most votes in the election."

[1437] Through this system, users can experience the process from policy formulation to elections and understand its impact on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, enhancing user understanding and engagement. This is expected to improve political understanding and social participation, especially among young people.

[1438] The processing flow will be explained below.

[1439] Step 1:

[1440] The user inputs the policy into the device interface. The user inputs information such as the policy name (e.g., "Increase the education budget"), details, and target group into the device.

[1441] Step 2:

[1442] The device analyzes the user's facial expressions and tone of voice to generate emotional data, and the emotion recognition engine determines whether the user is stressed or excited.

[1443] Step 3:

[1444] The terminal sends the input policy data and generated emotion data to the server, which then formats the data appropriately and generates a request to send to the server.

[1445] Step 4:

[1446] The server receives the policy data and emotion data sent from the terminal, checks the integrity of the received data, and converts it into the required format.

[1447] Step 5:

[1448] The server stores the received policy data and emotion data in a database, where IDs are assigned so that the policy data and emotion data can be uniquely identified.

[1449] Step 6:

[1450] The server retrieves the correlation data needed to simulate the impact of policies from the database, including historical statistics and related data.

[1451] Step 7:

[1452] The server generates a data set for running a simulation based on the correlation data and the received policy data, and organizes this data and converts it into a format that can be input into the AI ​​simulation engine.

[1453] Step 8:

[1454] The server uses an AI simulation engine to simulate the social impact of policies, for example, analyzing the impact of increasing education budgets on academic performance and the economy.

[1455] Step 9:

[1456] The server generates simulation results and stores them in a database, including details about the specific impacts of policies.

[1457] Step 10:

[1458] The server sends the generated simulation results to the user terminal, and the server packages the simulation results in an appropriate format and generates a request to send them to the user terminal.

[1459] Step 11:

[1460] The terminal receives the simulation results sent from the server, analyzes the received data, and prepares to visually display it to the user.

[1461] Step 12:

[1462] The simulation results received by the user's device are visually displayed. For example, specific results such as "Increasing the education budget is expected to improve academic performance by 5%" are displayed. The display is also customized to the user based on emotional data.

[1463] Step 13:

[1464] The server periodically holds election events and notifies the terminal of the information. The server generates notifications to inform users of the election event time and related information.

[1465] Step 14:

[1466] Users use their devices to participate in elections and promote their policies. Users input presentation information to promote their policies to other users.

[1467] Step 15:

[1468] The device sends the presentation information and emotion data entered by the user to the server, which stores the data and makes it available to other users.

[1469] Step 16:

[1470] Users use their devices to vote for other users' policies. Users evaluate the presented policy information and send their voting data from their devices.

[1471] Step 17:

[1472] The server aggregates the votes of all users and generates the election results. The server analyzes the aggregated voting data and identifies the policy that received the most support.

[1473] Step 18:

[1474] The server notifies the user device of the election results, including details about the number of votes and the winner's policies.

[1475] Step 19:

[1476] The device visually displays the election results received by the user, such as "The policy 'Increase the education budget' received the most votes in the election."

[1477] In this way, users can learn through the process from policy formulation to elections and understand the impact of policies on society in real time. The introduction of an emotion recognition engine also provides more personalized learning and feedback, improving user understanding and engagement. This is expected to improve young people's understanding of politics and their sense of social participation.

[1478] Example 2

[1479] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1480] In modern society, young people are expected to take an interest in politics and policy and to actively participate in it. However, understanding policy-making and its social impact is not easy, and many young people are reluctant to participate in politics. An educational support system is needed to solve this problem and improve young people's understanding of politics and their awareness of social participation.

[1481] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1482] In this invention, the server includes: means for formulating policies through a user terminal; means for transmitting policy data to the server; means for acquiring user emotion data in the user terminal and transmitting it to the server; means for storing the received policy data and emotion data in a database in the server; means for acquiring correlation data necessary for simulating the social impact of policies in the server; means for running a simulation based on the acquired correlation data and policy data in the server; means for generating simulation results in the server, customizing them based on the emotion data, and transmitting them to the user terminal; means for visually displaying the received simulation results in the user terminal; means for periodically holding an election event in the server and notifying the user terminal of the information; means for participating in elections and voting through the user terminal; and means for tallying vote results in the server and notifying the user of the election results. This allows young people to experience the process from policy formulation to elections in real time and receive feedback based on their emotions, thereby improving their understanding of politics and their sense of social participation.

[1483] A "user terminal" is a device used by a user to input policies and display simulation results and election information.

[1484] "Policy data" is data containing information about policies formulated by users, including policy names, details, target groups, etc.

[1485] "Emotion data" refers to data that includes information about emotions obtained by analyzing a user's facial expressions and tone of voice.

[1486] The "server" is a central computer that receives policy data and emotion data from user terminals, stores them in a database, obtains correlation data, and runs simulations.

[1487] "Database" is an information management system for storing policy data, emotion data, and correlation data.

[1488] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[1489] The "AI simulation engine" is a program equipped with artificial intelligence that predicts the social impact of policies based on policy data and correlation data.

[1490] "Simulation results" are predicted data on the social impact of policies generated by the AI ​​simulation engine.

[1491] An "election event" is an event that involves a user virtually participating in an election, promoting their own policies, and receiving votes from other users.

[1492] The present invention relates to an educational support system that allows users to formulate policies, manage virtual governments, and participate in elections. It also incorporates an emotion recognition engine that recognizes user emotions. The system is implemented by combining the following main components and operations:

[1493] System configuration and functions

[1494] 1. User Device

[1495] A user terminal is a device used by users to input policies and display simulation results and election information. Specifically, this includes PCs, smartphones, and tablets. The terminal is equipped with an emotion recognition engine that analyzes the user's facial expressions and tone of voice. This generates user emotion data.

[1496] 2. Server

[1497] The server receives policy data and emotion data sent from user devices and stores them in a database. The server then retrieves correlation data from the database to simulate the social impact of policies and runs the simulation using an AI simulation engine.

[1498] 3. Database

[1499] The database is an information management system that stores policy data, sentiment data, and correlation data. The correlation data includes historical statistical data and related information and is used to simulate the social impact of policies.

[1500] 4. AI Simulation Engine

[1501] The AI ​​simulation engine is a program that predicts the social impact of policies based on policy data and correlation data. The simulation results are customized based on the user's emotional data and sent to the user's device.

[1502] 5. Emotion Recognition Engine

[1503] The emotion recognition engine is installed on the user's device and generates emotional data by analyzing the user's facial expressions and tone of voice, which is used for policy simulations and election results analysis.

[1504] Use cases and specific steps

[1505] Below are the specific steps users can take to formulate new policies, simulate their impact, and participate in elections.

[1506] 1. Policy input

[1507] The user inputs a policy using the device interface. For example, to formulate a policy such as "increase the education budget by 10%," the user enters this into the device's text field and clicks the submit button.

[1508] 2. Acquiring Emotion Data

[1509] While entering the policy, the camera and microphone on the user's device capture the user's facial expressions and voice in real time, which are then analyzed by the emotion recognition engine to generate emotion data, such as "Stress level: High."

[1510] 3. Data transmission and storage

[1511] The device sends policy data and emotion data to the server, which receives them and stores them in a database.

[1512] 4. Running the Simulation

[1513] The server retrieves the necessary correlation data from the database and inputs it into the AI ​​simulation engine along with the policy data. The simulation is run and the social impact of the policy is predicted. For example, a result such as "Increasing the education budget will improve academic performance by 5%" is generated.

[1514] 5. Notification of simulation results

[1515] The simulation results are customized based on emotional data, for example, to be displayed in a more understandable format for users who are feeling stressed, and then sent to the user's device for visual display.

[1516] 6. Holding election events

[1517] The server periodically holds election events and sends information to user devices. Users appeal to other users about their policies and receive votes. They can also observe other users' reactions using an emotion recognition engine. Finally, the server tallys the votes and notifies users of the election results.

[1518] Prompt Sentence Examples

[1519] An example prompt might use the following text:

[1520] "Simulate how an increase in the education budget will affect student academic performance."

[1521] "Please provide data on the socio-economic impact of investments in the education sector over the past 10 years and analyze the correlations."

[1522] The system allows users to experience the process from policymaking to elections and understand its impact on society in real time. The system also incorporates an emotion recognition engine to provide personalized learning and feedback, helping users better understand politics and participate in society.

[1523] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1524] Step 1: Enter and submit policy data

[1525] The user inputs the policy using the terminal interface. The policy data includes the policy name, details, target group, etc. After inputting is complete, the user clicks the "Submit" button, which is sent to the terminal. The terminal then sends this policy data to the server.

[1526] Input: Policy data entered by the user into the interface.

[1527] Output: Policy data sent from the terminal to the server

[1528] Specific operation: For example, enter a policy such as "Increase the education budget by 10%" and click the send button. At this time, the policy data (the policy name "Increase the education budget by 10%" and details) is sent from the device to the server.

[1529] Step 2: Obtaining and sending emotion data

[1530] While the user is entering the policy, the device's camera and microphone capture the user's facial expressions and voice in real time. The emotion recognition engine analyzes this and generates the user's emotional data. The generated emotional data is then sent to the server along with the policy data.

[1531] Input: User facial expressions and tone of voice

[1532] Output: Emotion data sent to the server

[1533] Specific operation: During policy input, the camera and microphone capture the user's face and voice, and emotional data such as "stress level: high" and "happiness level: low" is generated and sent to the server.

[1534] Step 3: Receiving and storing data

[1535] The server receives the policy data and emotion data sent from the device and stores them in a database for later use in simulations and result analysis.

[1536] Input: Policy data and emotion data sent from the device

[1537] Output: Policy data and sentiment data stored in a database

[1538] Specific operation: The server checks the received policy data and emotion data and stores them appropriately in the database. This storage process allows for future reference.

[1539] Step 4: Obtain correlation data and run simulation

[1540] The server retrieves the correlation data needed to simulate the impact of policies from the database. This correlation data includes past statistical data and related information. The AI ​​simulation engine runs a simulation based on the retrieved correlation data to predict the social impact of policies.

[1541] Input: Correlation data and policy data retrieved from databases

[1542] Output: Simulation results

[1543] Specific operation: The server retrieves correlation data from the database, such as "the impact of past increases in education budgets on academic performance and the national economy," and based on this, the AI ​​simulation engine generates simulation results, such as "a 5% improvement in academic performance is expected."

[1544] Step 5: Generate and communicate simulation results

[1545] Once the simulation is complete, the server generates results and customizes them based on the user's emotional data. For example, if the user is feeling stressed, the results will be adjusted to be displayed in an easy-to-understand format. The generated results are sent to the user's device and displayed visually.

[1546] Input: Simulation results and emotion data

[1547] Output: Customized simulation results

[1548] How it works: The server generates simulation results and adjusts the display format based on emotional data (e.g., "Stress level: High"). The customized results are then sent to the user's device, where they are displayed, such as "Increasing the education budget will improve academic performance by 5%."

[1549] Step 6: Holding election events and announcing results

[1550] The server periodically holds election events and notifies users of the information on their devices. Users can use their devices to participate in elections and promote their policies to other users. During this process, the emotion recognition engine observes the reactions of other users and provides feedback. After the votes are cast, the server tallys the voting results of all users and notifies them of the results.

[1551] Input: Election information and user voting data

[1552] Output: Counted voting results

[1553] Specific operation: The server notifies the user that an election event has started, and the user creates and submits a policy appeal. The device analyzes other users' reactions in real time and provides feedback, such as "This policy is highly rated." Finally, the server tallies the voting results and notifies the user of the result, such as "Increasing the education budget received the most votes."

[1554] (Application example 2)

[1555] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1556] Current educational systems make it difficult for users to experience the entire political process, from policy formulation to the electoral process. Furthermore, the educational effectiveness is limited by the lack of ways for users to understand the social impact of policies in real time and receive individual feedback. Furthermore, systems that provide feedback tailored to the user's state through emotion recognition are also inadequate. Furthermore, when considering use in physical stores, creating an environment where a large number of users can use the system simultaneously presents a challenge.

[1557] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for formulating policies through a user terminal, means for transmitting policy data to the server, and means for storing the received policy data in a database. This enables users to formulate policies in physical stores and simulate their social impact in real time. In addition, by including means for acquiring user emotion data through an emotion recognition engine and customizing and displaying simulation results based on the emotion data, and means for the user to input policies through smart glasses and visually provide the displayed content, feedback can be provided according to the user's state, enhancing the effectiveness of education.

[1558] A "user terminal" is a device used by a user to input policies and display simulation results.

[1559] The "server" is a central processing unit that receives, stores, and processes policy data and emotion data, and generates and notifies the results of simulations.

[1560] "Policy data" is information about policies formulated by users, including details and target groups.

[1561] A "database" is an information storage system that stores policy data, sentiment data, and correlation data and makes them accessible when needed.

[1562] "Correlation data" refers to data that includes historical statistical data and related information necessary to simulate the social impact of policies.

[1563] The "AI simulation engine" is an artificial intelligence engine that predicts the social impact of policies based on policy data and correlation data, and generates simulation results.

[1564] An "emotion recognition engine" is software that analyzes a user's facial expressions and tone of voice and generates emotional data.

[1565] "Emotion data" is information about a user's emotions generated by an emotion recognition engine.

[1566] "Smart glasses" are wearable devices used to virtually provide policy formulation, display simulation results, and more.

[1567] An "election event" is an event that is periodically held by the server to allow users to evaluate and vote on policies formulated by users.

[1568] "Voting results" refers to information that compiles the voting results of users who participated in the election event.

[1569] "Customized display" is a display method that provides simulation results in an easy-to-understand manner based on the user's emotional data.

[1570] This invention relates to an educational support system that allows users to formulate policies in physical stores and simulate their social impact. It uses an emotion recognition engine and smart glasses to provide feedback according to the user's emotional state. The program and processing of this system are described below.

[1571] System Overview

[1572] The system consists of the following major components:

[1573] 1. User Device

[1574] 2. Server

[1575] 3. Database

[1576] 4. AI Simulation Engine

[1577] 5. Emotion Recognition Engine

[1578] 6. Smart Glasses

[1579] Hardware and software used

[1580] Smart glasses (e.g. Google Glass)

[1581] Emotion recognition API (e.g. Microsoft Azure Emotion API)

[1582] Front-end frameworks (React, Vue.js, etc.)

[1583] Server API (Node.js, Python Flask, etc.)

[1584] Database (MySQL, MongoDB, etc.)

[1585] AI simulation engines (TensorFlow, PyTorch, etc.)

[1586] Program processing overview

[1587] 1. Policy input and formulation:

[1588] Users input new policies using the touchpad or voice recognition function of the smart glasses. This policy data is sent to the server in real time. The user terminal (smart glasses) provides an interface where data such as the policy name, details, and target group can be entered.

[1589] 2. Acquiring emotion data:

[1590] The smart glasses' built-in camera and microphone are used to analyze the user's facial expressions and tone of voice. This data is sent to an emotion recognition API, which generates emotion data. The generated emotion data is then simultaneously sent to the server.

[1591] 3. Data storage and processing:

[1592] The server stores the received policy and emotion data in a database. These data are used for subsequent simulations and result analysis. The data is properly structured and stored, and can be accessed at any time.

[1593] 4. Simulation and Results Notification:

[1594] The server retrieves relevant correlation data from the database and uses an AI simulation engine to simulate the social impact of policies. The simulation results are customized based on the user's emotional data and displayed on the smart glasses. If the user is feeling stressed, the results will be presented in an easy-to-understand format.

[1595] 5. Visualization of results:

[1596] The smart glasses display visually displays the simulation results, such as "Increasing the education budget" as a policy that "is expected to improve academic performance by 5%." This allows users to intuitively understand the results.

[1597] Examples and prompts

[1598] Example: A user puts on smart glasses and inputs a policy of "increasing the education budget" via voice command. The camera in the glasses analyzes the user's facial expression, and the emotion recognition engine determines that the user is stressed. The server runs a simulation based on the data for the "increasing the education budget" policy, and displays a simple bar graph on the smart glasses showing the expected 5% improvement in student academic performance due to the increase in the education budget. The results are presented in an easy-to-understand format even when the user is stressed.

[1599] Example prompt sentence:

[1600] "A user has proposed a policy to 'increase the education budget.' Simulate the social impact of this policy and briefly explain the results."

[1601] Through this system, users can concretely experience the entire process, from policy formulation to the election process, and receive real-time feedback using emotion recognition, which is expected to improve political understanding and social participation.

[1602] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1603] Step 1:

[1604] The user inputs a new policy through the user terminal (smart glasses). The user inputs the policy data using voice recognition or the touchpad, and the data is sent to the server in real time. The input includes the policy name, details, and target group, and the server receives the policy data based on this. The input policy data is temporarily stored in memory and passed to the next step.

[1605] Step 2:

[1606] The camera and microphone built into the smart glasses capture the user's facial expressions and tone of voice. The emotion recognition engine analyzes this data and generates emotional data. The emotion recognition API (Microsoft Azure Emotion API) is called, and the emotion is output as numerical data as the analysis result. This generated emotional data is immediately sent to the server. The emotional data includes items such as stress level, joy, and surprise.

[1607] Step 3:

[1608] The server stores the received policy data and emotion data in a database. The data is stored using an appropriate data structure, using SQL queries or NoSQL document operations. Metadata is also stored for later retrieval and processing. The input data is stored in the database and prepared with the correlation data required for the next step.

[1609] Step 4:

[1610] The server retrieves the correlation data needed to simulate the social impact of policies from the database. This correlation data includes past policy data and related statistical information. It searches these using keys, loads the relevant data into main memory, and uses it in the next simulation step. All correlation data corresponding to the input policy is collected and passed to the AI ​​simulation engine.

[1611] Step 5:

[1612] The server runs a simulation using an AI simulation engine based on the acquired correlation data and policy data. The simulation engine (TensorFlow, PyTorch) is used to predict the social impact of policies. The simulation process involves preprocessing the data, applying models, generating results, and outputting the simulation results. The output results are passed on to the next step.

[1613] Step 6:

[1614] The server generates simulation results and sends them to the user's device in a format customized based on the user's emotional data. If the user is feeling stressed, the results are provided in a visually simple format, allowing the user to receive the simulation results in a format that is easy to understand. The results are output in a format that can be displayed on the smart glasses as simple graphs and charts.

[1615] Step 7:

[1616] The smart glasses visually display the received simulation results to the user. The results are optimized based on emotion recognition, providing information in a format that is easy for the user to understand. Specific results can be displayed, such as "a 5% expected improvement in academic performance" in response to the policy "increase in education budget." The displayed content is rendered on the screen and fed back to the user.

[1617] Through these steps, users can understand policy impacts in real time, enriching their in-store educational experience.

[1618] 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 control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1619] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1620] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1621] The emotion identification model 59 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 an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1622] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1623] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1624] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1625] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1626] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs 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 a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1627] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1628] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1629] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1630] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1631] 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.

[1632] It is not necessary to store all 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 all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1633] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1634] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with 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). Also, the hardware resource that executes the specific processing may be a single processor.

[1635] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1636] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1637] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1638] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1639] The following is further disclosed regarding the above embodiment.

[1640] (Claim 1)

[1641] a means of formulating policy through user terminals;

[1642] means for transmitting policy data to a server;

[1643] means for storing the received policy data in a database in the server;

[1644] means for acquiring correlation data necessary to simulate the social impact of policies in the server;

[1645] a means for executing a simulation based on the correlation data and policy data acquired in the server;

[1646] means for generating simulation results in the server and transmitting the results to a user terminal;

[1647] means for displaying the received simulation results at the user terminal;

[1648] A means for periodically holding an election event on the server and notifying the user terminal of the information;

[1649] A means to participate in elections and vote through user devices;

[1650] a means for tallying the vote results in the server and notifying the election results;

[1651] A system including:

[1652] (Claim 2)

[1653] 10. The system of claim 1, including an AI model for simulating policies.

[1654] (Claim 3)

[1655] 10. The system of claim 1, including means for visually displaying the impact of the policy at a user terminal.

[1656] "Example 1"

[1657] (Claim 1)

[1658] a means of formulating policy through user terminals;

[1659] means for transmitting policy data to a server;

[1660] means for storing the received policy data in a database in the server;

[1661] means for acquiring correlation data necessary to simulate the social impact of policies in the server;

[1662] a means for executing a simulation based on the correlation data and policy data acquired in the server;

[1663] means for generating simulation results in the server and transmitting the results to a user terminal;

[1664] means for displaying the received simulation results at the user terminal;

[1665] A means for periodically holding an election event on the server and notifying the user terminal of the information;

[1666] A means to participate in elections and vote through user devices;

[1667] a means for tallying the vote results in the server and notifying the election results;

[1668] A means for user terminals to access and log in to the system through a browser or dedicated application;

[1669] A means for packetizing policy data and transmitting it to a server via HTTPS protocol;

[1670] a means for the server to receive policy data at an API endpoint;

[1671] A means to visually display the simulation results in graphs and text format;

[1672] A system including:

[1673] (Claim 2)

[1674] 10. The system of claim 1, including an AI model for simulating policies.

[1675] (Claim 3)

[1676] 10. The system of claim 1, including means for visually displaying the impact of the policy at a user terminal.

[1677] "Application Example 1"

[1678] (Claim 1)

[1679] a means of formulating policy through user terminals;

[1680] means for transmitting policy data to a server;

[1681] means for storing the received policy data in a database in the server;

[1682] means for acquiring correlation data necessary to simulate the social impact of policies in the server;

[1683] a means for executing a simulation based on the correlation data and policy data acquired in the server;

[1684] means for generating simulation results in the server and transmitting the results to a user terminal;

[1685] means for displaying the received simulation results at the user terminal;

[1686] A means for periodically holding an election event on the server and notifying the user terminal of the information;

[1687] A means to participate in elections and vote through user devices;

[1688] a means for tallying the vote results in the server and notifying the election results;

[1689] A means for users to plan policies as operators of virtual cities and simulate their impact.

[1690] A means to hold elections among users and evaluate policies;

[1691] A system including:

[1692] (Claim 2)

[1693] 10. The system of claim 1, including an AI model for simulating policies.

[1694] (Claim 3)

[1695] 10. The system of claim 1, including means for visually displaying the impact of the policy at a user terminal.

[1696] "Example 2: Combining Emotion Engines"

[1697] (Claim 1)

[1698] a means of formulating policy through user terminals;

[1699] means for transmitting policy data to a server;

[1700] A means for acquiring user emotion data in a user terminal and transmitting the data to a server;

[1701] a means for storing the received policy data and emotion data in a database in the server;

[1702] means for acquiring correlation data necessary to simulate the social impact of policies in the server;

[1703] a means for executing a simulation based on the correlation data and policy data acquired in the server;

[1704] A means for generating a simulation result in the server, customizing the result based on emotion data, and transmitting the result to a user terminal;

[1705] means for visually displaying the received simulation results at the user terminal;

[1706] A means for periodically holding an el...

Claims

1. a means of formulating policy through user terminals; means for transmitting policy data to a server; means for storing the received policy data in a database in the server; means for acquiring correlation data necessary to simulate the social impact of policies in the server; a means for executing a simulation based on the correlation data and policy data acquired in the server; means for generating simulation results in the server and transmitting the results to a user terminal; means for displaying the received simulation results at the user terminal; A means for periodically holding an election event on the server and notifying the user terminal of the information; A means to participate in elections and vote through user devices; a means for tallying the vote results in the server and notifying the election results; A system including:

2. 10. The system of claim 1, including an AI model for simulating policies.

3. 10. The system of claim 1, further comprising means for visually displaying the impact of the policy at a user terminal.

Images