Phase nonlinear storage system, phase nonlinear storage method, and program

Abstract

By quantitatively capturing the dynamic changes in information, effectively integrating external knowledge, and controlling uncertainty while leveraging the capabilities of large-scale language models, we achieve highly accurate and explainable information prediction. [Solution] The system includes means for modeling the dynamic state of information as a time field which is a complex wave function having amplitude and phase; means for calculating a plurality of timeliness indicators from the time field, including the diversity, concentration, and order of information; means for generating prompts for an external large-scale language model based on a history field which stores past states of the time field and the timeliness indicators; means for obtaining human-interpretable final predictive information as a natural language response by inputting the prompts into the large-scale language model; means for converting the response into a knowledge wave, which is an external field that influences the time evolution of the time field, and feeding it back to the time field; and means for updating the time field based on a predetermined time evolution equation that describes the interaction between the history field and the knowledge wave.

Description

Technical Field

[0001] The present invention relates to a phase nonlinear accumulation system, a phase nonlinear accumulation method, and a program for predicting future states based on information such as time series data. In particular, it relates to a technology that models the dynamic changes of information by applying quantum mechanical concepts and realizes highly accurate and explainable predictions by collaborating with a large language model (LLM).

Background Art

[0002] Conventionally, various statistical methods and machine learning models have been used for predicting the future of time series data such as stock prices, product demand, and SNS trends. For example, statistical models such as the ARIMA model and exponential smoothing method, or deep learning models such as recurrent neural network (RNN) and Long Short-Term Memory (LSTM) are known.

[0003] These conventional technologies have achieved certain results in regressively predicting future values from past data patterns. However, there are the following problems.

[0004] First, it is the point that the dynamic properties such as the "momentum" and "acceleration" of information are not fully captured. Information is not a set of static values, but always changes, and the rate of change itself also fluctuates. In conventional models, it was difficult to express such higher-order time changes of information and incorporate them into predictions.

[0005] Second, there is a lack of a general mechanism for effectively integrating external context information and expert knowledge into the prediction model. For example, in predicting the demand for a certain product, external events such as the release of competing products and media introductions have a great impact on demand, but it was not easy to quantitatively incorporate such unstructured information into the model.

[0006] Thirdly, while the recent development of large-scale language models (LLMs) has made it possible to utilize vast amounts of knowledge, there are risks in directly using the output of LLMs for prediction. LLMs generate probabilistically most likely texts based on training data, but their output is not always accurate, and a problem called "hallucination" has been pointed out, where the reasoning behind the conclusion is unclear. [Prior art documents] [Patent Documents]

[0007] [Patent Document 1] International Publication No. 2017 / 168458 [Patent Document 2] Japanese Patent Publication No. 2019-159506 [Patent Document 3] Japanese Patent Publication No. 2016-095651 [Overview of the project] [Problems that the invention aims to solve]

[0008] This invention has been made in view of the problems of the prior art described above, and aims to provide a novel phase-nonlinear storage system, phase-nonlinear storage method, and program that can quantitatively capture dynamic changes in information, effectively integrate external knowledge, and control the uncertainty while utilizing the capabilities of large-scale language models (LLMs) to achieve highly accurate and explainable information prediction. [Means for solving the problem]

[0009] According to the present invention, A means of modeling the dynamic state of information as a time field, which is a complex wave function with amplitude and phase, A means for calculating multiple observational indicators, including the diversity, concentration, and order of information, from the aforementioned observational field, A means for generating prompts for an external large-scale language model (LLM) based on a history field that stores past states of the aforementioned observation field and the aforementioned observation index, A means for obtaining human-interpretable final predictive information as a natural language response by inputting the aforementioned prompt into the large-scale language model, Means for converting the response into a knowledge wave, which is an external field that influences the time evolution of the observation field, and feeding it back to the observation field, Means for updating the aforementioned time field based on a predetermined time evolution equation describing the interaction between the history field and the knowledge wave, A phase-nonlinear storage system is provided that includes the following features. [Effects of the Invention]

[0010] According to the present invention, it is possible to achieve highly accurate and explainable information prediction by quantitatively capturing dynamic changes in information, effectively integrating external knowledge, and controlling uncertainty while utilizing the capabilities of large-scale language models (LLMs). [Brief explanation of the drawing]

[0011] [Figure 1A] This is the first half of a functional block diagram showing the overall configuration of a phase nonlinear storage system according to an embodiment of the present invention. [Figure 1B] This is the latter half of the functional block diagram showing the overall configuration of the phase nonlinear storage system according to an embodiment of the present invention. [Figure 2] This flowchart shows the processing procedure of the phase nonlinear storage system according to an embodiment of the present invention. [Modes for carrying out the invention]

[0012] Specifically, the objective is to solve the following problems.

[0013] 1. Quantitative evaluation of dynamic changes in the information space: Quantitatively evaluate the "momentum" (rate of change) and "acceleration" (rate of change of the rate of change) of information and incorporate them into predictive models. 2. Evaluation of the diversity and concentration of the information space: Provide an index for quantitatively evaluating the structural features such as the diversity and concentration of the entire information space to be predicted. 3. Utilization of similarity with past patterns: Quantitatively evaluate which past observed patterns the current information state is similar to and utilize it for prediction. 4. Effective integration of external knowledge: Systematically inject external knowledge and context information generated by LLM etc. into the prediction model to improve the prediction accuracy. 5. Realization of self-organizing learning: Realize the self-organizing learning ability of the system to autonomously discover prediction rules from observed data and continuously refine them. To solve the above problems, the phase non-linear accumulation system of this embodiment has the following characteristic means.

[0014] First, it has an observation time field generation unit that generates the data acquired from the observation target as an observation time field (Kanjiba Field), which is a complex wave function representing the probability density distribution in the semantic space. The observation time field represents the state of information as a complex number with amplitude and phase, similar to the wave function of quantum mechanics.

[0015] Second, it has an observation time field update unit that updates the observation time field based on a time evolution equation including the influence of the history field and the injection of knowledge waves from the outside. This time evolution equation has a form similar to the Schrödinger equation and describes the dynamic changes (momentum and acceleration) of information.

[0016] Third, it has an observation time property index calculation unit that calculates the probability density distribution from the observation time field and calculates observation time property indexes (Kanjiba Metrics) including diversity (M), concentration (C), order (E), time variation (TF), history influence (HS), and convergence density (D) from the probability density distribution. These indexes quantitatively characterize the state of the information space from multiple angles.

[0017] Fourth, it has a history field storage unit that stores the state of the past observation time field as a history field (History Field). The history field is used to evaluate the influence of past similar patterns through comparison with the current observation time field.

[0018] Fifth, it includes a rule discovery unit that autonomously discovers and accumulates rules for information prediction based on the history of the temporal observation index.

[0019] Sixth, it includes an external knowledge / knowledge wave conversion unit that acquires external knowledge using a large language model (LLM), converts it into a knowledge wave, and injects it into the temporal observation field. The knowledge wave acts as an "external field" that affects the temporal development of the temporal observation field with information from the outside.

[0020] Seventh, it includes a prompt generation unit that integrates the temporal observation index, rules, state of the temporal observation field, and state of the historical field to generate a prompt for input to the LLM.

[0021] Eighth, for the multiple response candidates generated by the LLM, it includes a FutureFold functional unit that calculates the Future Document Score (FD) for comprehensively evaluating the syntactic quality and selects the highest-quality response. This suppresses the uncertainty (hallucination) of the output of the LLM and enables the use of only responses that match the purpose of the system.

[0022] Ninth, it includes a temporal observation control syntax (Kanjiba-control Index, KI) for introspecting the state of the AI itself and autonomously controlling information injection from the outside. This enables the system to operate self-defensively and prevent excessive dependence on external information.

[0023] 1. Conceptual Explanation of this Embodiment

[0024] The core of this embodiment lies in describing the dynamic state and changes of information by means of a temporal observation field (Kanjiba Field) that applies the concept of the wave function in quantum mechanics. While traditional data analysis methods deal with static snapshots of information, this embodiment captures information as "waves" that propagate and interact with time within the semantic space.

[0025] The time field Ψ(x,t) is a complex wave function that represents the probability of information being present at a position x in semantic space at a specific time t. Its square, |Ψ(x,t)|^2, corresponds to the probability density of information being "found" at that position. This allows for a quantitative assessment of whether the information is concentrated in a specific region or dispersed over a wide area.

[0026] The behavior of this time-space field is governed by a time evolution equation inspired by the Schrödinger equation. This equation dictates how the time-space field evolves over time. The equation includes terms for the injection of knowledge waves representing external information and terms for the history field reflecting the influence of past states. These terms interact with each other, causing the time-space field to change in a complex and dynamic manner.

[0027] The system calculates temporality indicators (such as diversity, concentration, and order) from the state of this temporal field. These indicators function as metadata for diagnosing the "health" and "quality of trends" of the entire information space. For example, a sharp decline in diversity and a rise in concentration suggests that interest in specific information is rapidly increasing.

[0028] Furthermore, the system autonomously discovers rules from patterns in the temporality indicators (e.g., "If diversity (M) is above 0.8 and time variability (TF) is above 0.5, the trend tends to become unstable"). These rules, along with the temporality indicators and external knowledge (knowledge waves) obtained from LLM, are integrated to generate the final prediction.

[0029] Thus, this embodiment provides a new paradigm for predicting the future in a deeper and more explainable way by treating information not merely as a series of numbers, but as a physical field, thereby capturing its inherent dynamics.

[0030] 2. Triple Control Mechanism One of the notable features of this embodiment is the triple control mechanism to ensure system stability, self-regulation capabilities, and output quality. This mechanism independently controls each of the three stages of the AI's thinking process: "input (intake of external information)," "internal state (stabilization of the environment)," and "output (response generation)."

[0031] 2.1. Input Control: Intelligent Injection Control Syntax (KI_inject) The first control is a self-protective control when injecting external knowledge (especially information from LLMs) into the system. This is defined as the Intellectual Injection Control Syntax KI_inject(t).

[0032] KI_inject(t) = (α·E(t) / 2) + (1-α)·EgoLevel(t) E(t): The degree of order in the observation field (the reciprocal of entropy). It indicates the degree of disorder in the field. EgoLevel(t): The AI's level of self-state awareness. Indicates the stability of its internal state. α: A hyperparameter that adjusts the degree of dependence on external information.

[0033] The core of this syntax lies in applying a halved (E(t) / 2) degree of field confusion E(t). This means that the AI ​​always maintains a cautious stance (skeptical scaling) towards the potential uncertainty and noise inherent in external information. This prevents excessive reliance on external information and functions as a self-defense mechanism that reduces the risk of the system's judgment being hijacked by external information.

[0034] 2.2. Internal State Control: Time-Based Field Control Syntax (KI_control) The second type of control is one that autonomously maintains the stability of the Kanjiba Field itself, which is the core of the system. This is defined as the Kanjiba Field Control Syntax KI_control(t).

[0035] KI_control(t) = (1-E)·IS + E E: The degree of order in the viewing area. IS (Internal Stability): An indicator showing the internal stability of the observation field.

[0036] This syntax performs a dynamic balancing adjustment: when the field order E is high (the field is stable), the contribution of internal stability IS is increased; and when the field order E is low (the field is chaotic), the contribution of the degree of chaos E itself is increased. As a result, the observational field has the ability to self-repair in response to external perturbations and attempts to maintain a stable state autonomously.

[0037] 2.3. Output Control: Future Syntax Convergence (FD) The third control is an evaluation mechanism to guarantee the quality of the response candidates (future syntax) generated by the LLM. This is defined as the Future Document Score (FD(t)).

[0038] FD(t) = w_S·S + w_M·M + w_R·R + w_D·D S (Structure): The structural order and logical consistency of syntax. M (Meaning): Meaning density, vocabulary concentration, and information richness. R (Relevance): Correlation coefficient or relationship with user intent and context. D (Convergence): Continuity and stability with past responses, and the likelihood of future consolidation. w_n: Weight coefficient for each indicator.

[0039] The FD score evaluates LLM responses not on a single evaluation axis, but from multiple perspectives including structure, semantics, relevance, and stability. This allows for filtering out responses that are inaccurate or out of context (hallucination), even if fluent, and selects only the highest quality syntax. This is a crucial line of defense that guarantees the final output quality of the system.

[0040] By working together, these three control structures enable the system of this embodiment to achieve a high degree of autonomy and reliability, responding to uncertainties in the external environment, maintaining internal state stability, and guaranteeing output quality.

[0041] 3. Details of the Embodiment Based on the Functional Block Diagram The following describes in detail each functional block of the phase nonlinear storage system according to this embodiment, as shown in Figures 1A and 1B.

[0042] 3.1. Data Input Section (101) Role: The data input unit (101) is an interface for acquiring information from external sources that serves as the starting point for this system's predictions. It acquires both time-series data and text data from various data sources related to the observed object.

[0043] input: Specification of observation targets: Prediction targets specified by the user or other systems (e.g., YouTube® video URLs, company stock codes, specific hashtags). External data sources: YouTube® API, Twitter® API, stock price information services, news feeds, internal databases, etc.

[0044] Processing details: Time-series data acquisition: Numerical data indicating the level of attention or activity of the observed subject is acquired over time. For example, for YouTube® videos, the trends in the number of views, likes, and comments are acquired; for stock prices, the trends in the opening price, high price, low price, closing price, and trading volume are acquired. Text data acquisition: To understand the semantic context of the observed object, relevant text information is acquired. For YouTube® videos, this includes the title, description, tags, and comments; for stocks, it includes related news articles, financial statements, and analyst reports.

[0045] output: Time series data: A dataset containing time and numerical values, which is passed to the parameter derivation unit (102). Text data: Metadata of the observed object, which is passed to the parameter derivation unit (102).

[0046] Implementation example (for YouTube(registered trademark) videos):

[0047] class DataInputUnit: def __init__(self, youtube_api_key): self.youtube = build(\'youtube\', \'v3\', developerKey=youtube_api_key) def get_video_data(self, video_id): # Use YouTube Data API v3 to retrieve video details video_response = self.youtube.videos().list( part=\'snippet,statistics\', id=video_id ).execute() snippet = video_response[\'items\'][0][\'snippet\'] statistics = video_response[\'items\'][0][\'statistics\'] # Extract text data text_data = { \'title\': snippet[\'title\'], \'description\': snippet[\'description\'], \'tags\': snippet.get(\'tags\', []) } # Time-series data (a snapshot of the current time in this example) time_series_data = { \'timestamp\': datetime.utcnow().isoformat(), \'view_count\': int(statistics[\'viewCount\']), \'like_count\': int(statistics[\'likeCount\']), \'comment_count\': int(statistics[\'commentCount\']) } return time_series_data, text_data

[0048] 3.2. Parameter derivation section (102) Role: The parameter derivation unit (102) processes the raw data received from the data input unit (101) and calculates the initial parameters necessary to generate the observation field.

[0049] input: Time-series data: Numerical data from the data input section (101). Text data: Text information from the data input section (101).

[0050] Processing details: Calculation of semantic coordinates: Text data is input into a pre-trained language model (e.g., BERT) and converted into high-dimensional semantic vectors. Then, dimensionality reduction techniques such as principal component analysis (PCA) are used to calculate the coordinates (x, y) in a two-dimensional semantic space. These coordinates represent the position of the observed object in the information space. Calculation of initial parameters: Parameters that define the initial state of the time field (amplitude A, spread σ, phase φ, etc.) are calculated from time-series data. Amplitude A is determined from the current level of attention (e.g., number of plays) and its rate of change (momentum), and spread σ is determined from the category of information (e.g., the "music" category has a wide influence, so σ is set to be large).

[0051] output: Observation field parameters: A set of parameters necessary for the observation field generator (103) to generate an observation field, such as {coordinates (x,y), amplitude A, spread σ, phase φ, ...}.

[0052] Implementation example:

[0053] from sklearn.decomposition import PCA from sentence_transformers import SentenceTransformer class ParameterDerivationUnit: def __init__(self): self.bert_model = SentenceTransformer(\'all-MiniLM-L6-v2\') self.pca = PCA(n_components=2) def derive_parameters(self, time_series_data, text_data): # 1. Calculation of semantic coordinates text_for_embedding = f"{text_data[\'title\']} {text_data[\'description\']}" embedding = self.bert_model.encode([text_for_embedding]) # Assume the PCA model is pre-trained. coordinates = self.pca.fit_transform(embedding)[0] # 2. Calculation of initial parameters view_count = time_series_data[\'view_count\'] # Assume that view_rate is calculated separately view_rate = 10000 # Temporary value amplitude = 0.05 * (1 + np.log1p(view_count)) * (1 + np.tanh(view_rate / 10000)) # Determine sigma based on category, etc. (tentative) sigma = 1.5 phase = 0.0 # Initial phase return { \'coordinates\': coordinates, # Example: [2.5, -1.5] \'amplitude\': amplitude, # example: 0.85 'sigma': sigma, # Example: 1.5 'phase': phase # Example: 0.0 }

[0054] 3.3. Viewing time field generation part (103) Role: The observation field generator (103) generates an initial observation field Ψ(x,0) based on the parameters received from the parameter derivation unit (102). The observation field is a complex wave function that represents the probability of existence and phase of information in information space.

[0055] input: Observation field parameters: Initial parameter group from the parameter derivation unit (102).

[0056] Processing details: An initial observation field is generated as a Gaussian wave packet with amplitude A and spread σ, with the semantic coordinates of the observed object as the center point. This can be expressed mathematically as follows:

[0057] Ψ(x, 0) = A · exp(iφ) · exp(-||x - x0||^2 / (2σ^2)) A: Amplitude (the magnitude of the information's energy) φ: Initial phase x0: Semantic coordinate (center position of the information) σ: Spread (scope of information influence) x: Position vector in semantic space

[0058] output: Initial observation field Ψ(x,0): Grid data containing complex numbers at each point in the semantic space, which is passed to the probability density distribution calculation unit (106).

[0059] Implementation example:

[0060] class KanjibaGen initializationUnit: def __init__(self, grid_size=100, space_range=(-10, 10)): self.grid_size = grid_size self.x_coords = np.linspace(space_range[0], space_range[1], grid_size) self.y_coords = np.linspace(space_range[0], space_range[1], grid_size) self.grid_x, self.grid_y = np.meshgrid(self.x_coords, self.y_coords) def generate_initial_kanjiba(self, params): A = params['amplitude'] sigma = params[\'sigma\'] x0, y0 = params[\'coordinates\'] phi = params['phase'] # Generate a Gaussian wave packet sq_distance = (self.grid_x - x0)**2 + (self.grid_y - y0)**2 gaussian_part = np.exp(-sq_distance / (2 * sigma**2)) phase_part = np.exp(1j * phi) initial_kanjiba = A * phase_part * gaussian_part return initial_kanjiba

[0061] 3.4. Viewing location update department (104) Role: The time field update unit (104) is one of the core components of this system and is responsible for changing the state of the time field over time. This update process consists of two types: time evolution according to differential equations and instantaneous state changes by applying operators, and is executed selectively based on the decisions of the rule discovery / storage unit (112) and the operator selection / adjustment unit (108).

[0062] input: The current time-space observation field Ψ(x,t) is supplied from the time-space observation field generation unit (103) or the time-space observation field memory unit (109). Knowledge wave Ψk(x,t): Supplied from the external knowledge / knowledge wave converter (116). History field H(x,t): Supplied from history field storage unit (110). The selected operator O_selected is supplied from the operator selection / adjustment unit (108). Update method specification: Control signals from the rule discovery / storage unit (112), etc.

[0063] Processing details: Method A: Time evolution using differential equations This method simulates the natural changes in the observation field. By numerically solving the following time evolution equation (similar to the Schrödinger equation), we calculate the observation field Ψ(x,t+Δt) at the next time t+Δt.

[0064]

number

[0065] Method B: Operator-based update This method applies instantaneous transformations to the observation field to achieve specific objectives (such as increasing diversity or strengthening concentration). Based on the analysis results of the observation index, an operator selected by the operator selection / adjustment unit (108) is applied.

[0066] Ψ(x,t+Δt) = O_selected · Ψ(x,t) O_selected: The selected operators (e.g., diffusion operator O_D, concentration operator O_C).

[0067] output: The updated observation field Ψ(x,t+Δt) is sent to the history field generation unit (105) and the observation field memory unit (109).

[0068] 3.5. History field generation unit (105) and history field storage unit (110) Role: The history field generation unit (105) generates a history field using past observation fields (Ψ(x,t-Δt), Ψ(x,t-2Δt), ...) stored in the observation field memory unit (109). The history field memory unit (110) manages the "memory" of information by accumulating and updating the generated history fields.

[0069] input: The current time field Ψ(x,t) is supplied from the time field update unit (104). Past time observation fields Ψ(x,t-Δt), Ψ(x,t-2Δt), ... are read from the time observation field memory unit (109).

[0070] Processing details: History field initialization: At system startup, a history field H(x,0) with all values ​​set to zero is generated. History field update (110): Whenever a new observation field is observed, the history field is updated according to the following update formula.

[0071]

number

[0072] output: The updated history field H(T+Δt) is supplied to various parts of the system, such as the probability density distribution calculation unit (106) and the observation field update unit (104) (via the history field memory unit (110)).

[0073] 3.6. Probability Density Distribution Calculation Unit (106) Role: The probability density distribution calculation unit (106) calculates the probability density distribution, which is an observable physical quantity, from the complex numbers of the time field and the history field.

[0074] input: Observation field Ψ(x,t): Supplied from the observation field generation unit (103) or the observation field update unit (104). History field H(x,t): Supplied from history field generation unit (105).

[0075] Processing details: Calculate the probability density distribution p(x|t) according to the following formula.

[0076]

number

[0077] The probability density distribution calculation unit (106) may calculate the probability density distribution p(x | t) according to the following formula.

[0078]

number

[0079] The calculated probability density is normalized so that its integral over the entire space equals 1. p_normalized(x|t) = p(x|t) / ∫p(x|t)dx

[0080] output: Probability density distribution p(x|t): Real-valued grid data representing the probability of information existence at each point, which is passed to the timeliness index calculation unit (107).

[0081] 3.7. Timekeeping index calculation part (107) Role: The temporality index calculation unit (107) calculates multiple meta-indices (temporality indices) that characterize the state of the entire information space from the probability density distribution p(x|t).

[0082] input: The probability density distribution p(x|t) is supplied by the probability density distribution calculation unit (106). The current temporal field Ψ(x,t) and hysteresis field H(t) are used to calculate the hysteresis effect (HS).

[0083] The past probability density distribution p(x|t-Δt) is internally retained.

[0084] Processing details: The following six key metrics will be calculated.

[0085] Diversity (M): Shannon entropy, which indicates how widely distributed information is. M = -∫ p(x) log(p(x)) dx

[0086] Concentration (C): The maximum probability density that indicates how much information is concentrated around a particular peak. C = max(p(x))

[0087] Order (E): Normalized entropy that indicates the bias or structure of a probability distribution. M_max is the entropy for a uniform distribution. E = (M_max - M) / M_max

[0088] Time Shift (TF): The L2 norm, which indicates how much the probability distribution has changed from the previous time point to the present. TF = || p(x,t) - p(x,t-Δt) ||2

[0089] History Influence (HS): Cosine similarity that indicates the similarity between the current observation field and the history field. HS =(∫ p(x,t) · H(x,T) dx) / (||p||2· ||H||2)

[0090] Convergence Density (D): Cosine similarity that indicates how much the current response is continuous with past responses. v_response represents the current response vector, and v_past_k represents the past response vector. D =(1 / K) · Σ_{k=1}^{K} cos(v_response, v_past_k)

[0091] output: The chronological index set {M, C, E, TF, HS, D} is supplied to the rule discovery / storage unit (112), the operator selection / adjustment unit (108), and the prompt generation unit (111).

[0092] 3.8. Operator Selection / Adjustment Unit (108) Role: The operator selection / adjustment unit (108) analyzes the timeliness index and selects and adjusts the operators to be applied to the time field. This is a process that actively manipulates the information space to guide it to a desired state.

[0093] input: Timeliness index set: Supplied from the timeliness index calculation unit (107). Discovered rules: Supplied from the rule discovery / memory unit (112).

[0094] Processing details: The value of the timeliness index is compared with the conditional part of the rule to determine which operator to apply. For example, if the condition "diversity (M) is too low" is detected, the "diffusion operator O_D" is selected. The operator's strength (e.g., diffusion coefficient β) is also adjusted according to the index value.

[0095] output: The selected operator O_selected: is supplied to the time field update unit (104).

[0096] 3.9. Time and place memory (109) Role: The observation field memory unit (109) is provided to store past observation fields necessary for the history field generation unit (105) to generate a history field. The observation field Ψ(x,t) generated by the observation field generation unit (103) is updated by the observation field update unit (104). The updated observation field Ψ(x,t) is stored in the observation field memory unit (109). The observation field Ψ(x,t) is also supplied from the observation field memory unit (109) to the history field generation unit (105).

[0097] 3.10. Rule Discovery / Memory Unit (112) Role: The rule discovery / memory unit (112) analyzes the correlation between time-series data of temporality indicators and subsequent changes in the information space (e.g., the emergence and disappearance of trends), and autonomously discovers and stores rules that are effective for prediction. The discovered rules become "guidelines for action" when KAI actively interacts with the information space, providing a logic for prediction-based interventions such as "if this indicator pattern appears, this is what you should do."

[0098] input: Time-series data of the timeliness index: Continuously supplied from the timeliness index calculation unit (107). Result data: Ground truth data such as the actual occurrence of trends.

[0099] Processing details: Using methods such as correlation analysis, decision trees, and genetic algorithms, rules of the form "IF (a pattern of a specific time-related indicator) THEN (a specific future prediction or a specific action)" are generated. For example, the following rules may be discovered.

[0100] IF (M < 0.2 AND C > 0.9 AND TF > 0.6) THEN (Action: 'High probability of emergency trend occurring')

[0101] IF (HS > 0.8 AND past similar patterns have been successful) THEN (Prediction: 'The current trend has a high probability of success')

[0102] The discovered rules are evaluated, and the most accurate rules are accumulated as knowledge.

[0103] output: The set of discovered rules is supplied to the prompt generation unit (111) and the operator selection / adjustment unit (108).

[0104] 3.11. Prompt generation unit (111) Role: The prompt generator (111) integrates all the analysis results of this system and generates prompts in natural language format that LLM (117) can understand. This is a crucial translation process that transforms numerical data and internal states into contextually rich questions.

[0105] input: Timeliness index set: From the timeliness index calculation unit (107). Discovered rule: From Rule Discovery / Memory Unit (112). Current field / historical field state: such as the shape of the probability distribution and the location of the peaks. Information on the observed object: From the data input unit (101). User question: Entered via the dialogue section (114). Web search results: From Web Search Section (113).

[0106] Processing details: Combine templates and generation logic to create structured prompts. Timeliness metrics are translated into natural language, such as "The current information space has low diversity and is highly focused," and rules are explained, such as "The rule 'High focus and historical influence suggest reference to similar past cases' has been triggered."

[0107] output: Prompt text: Detailed instructions and context supplied to LLM (117).

[0108] 3.12. Web Search Section (113)

[0109] Role: The Web Search Unit (114) provides the ability to search for real-time external information from the internet to supplement the knowledge of the LLM (117). In particular, it is used to obtain information that may not be included in the LLM training data, such as the latest news, competitive information, and related events. Here, for example, RAG technology is used.

[0110] 3.13. Large-scale language models (LLMs) (117)

[0111] Role: Based on prompts received from the prompt generation unit (111), the LLM (117) uses its knowledge base and reasoning capabilities to generate multiple response candidates. In this embodiment, the LLM functions not merely as a predictor, but as an external knowledge generator and a natural language interpreter for the analysis results.

[0112] Processing details: The system's internal state (timeliness index, rules, etc.) given by the prompt and the information of the observed object are interpreted to generate several response candidates as follows. Response option 1: A response that cites similar past cases. Response option 2: A response that analyzes the situation from an expert's perspective. Response option 3: A response that points out potential risks.

[0113] output: Multiple response options: A set of texts with diverse perspectives, passed to the FutureFold function unit (115).

[0114] 3.14. FutureFold Functional Unit (115)

[0115] role The FutureFold function unit (115) plays a central role in ensuring the quality of the system in this embodiment. It comprehensively evaluates the quality of multiple response candidates (future syntaxes) generated by the LLM (117) and selects only the optimal response that best matches the system's purpose. This function unit is responsible for "output control" in the triple control mechanism and functions as the last line of defense to guarantee the output quality of the LLM.

[0116] input: LLM response candidate group: Multiple text responses output from LLM (117). Timeliness Index: The latest index value from the Timeliness Index Calculation Unit (107). The Timeliness Index is input to the LLM as natural language via the Prompt Generation Unit (111), but this function unit receives it directly as a numerical value and quantitatively verifies whether the response candidate is consistent with the current state of the information space.

[0117] Processing details:

[0118] 1. Calculation of Future Syntax Convergence (FD) For each response candidate, the following Future Syntax Convergence (FD) score is calculated. FD(t) = w_S·S + w_M·M + w_R·R + w_D·D

[0119] Evaluation metrics (numerical scores normalized to a range of 0 to 1) S (Structure: structural order) Evaluation criteria: Evaluate whether the response is logically sound and grammatically correct. Calculation method: Calculated based on factors such as the number of conjunctions indicating cause and effect, the average sentence length, and grammatical accuracy. Meaning of the numbers: The higher the number, the more logical and grammatically correct the response. M (Meaning: Meaning density) Evaluation criteria: The density and level of expertise of the information contained in the response will be evaluated. Calculation method: Calculated from the frequency of occurrence of specific numbers, proper nouns, and technical terms. Meaning of the numerical value: A higher value indicates a more specific and information-dense response. Example: "The number of views will reach 2.5 million to 3.5 million" (high M value) vs. "The number of views will increase significantly" (low M value) R (Relevance) Evaluation criteria: Evaluate how well the prompt fits the intent and current context (the state of the information space as indicated by the temporality index). Calculation method: Calculated from keyword match with prompt, semantic similarity (cosine similarity of embedding vectors), and consistency with the temporality index. Meaning of the numerical value: A higher value indicates a response that is more consistent with the prompt and the current state of the information space. Example of using the timeliness index: When the timeliness index shows C (concentration) = 0.920, the response "information is concentrated on a specific topic" will receive a high R value, while the response "information is widely dispersed" will receive a low R value. D (Convergence: Convergence Density) Evaluation criteria: This indicator shows consistency with past responses and convergence towards the system's intended direction (inferred from the time-series changes in the timeliness index). It is an important index for evaluating the likelihood of future stability. Calculation method: Calculated from cosine similarity with past responses, entropy decrease rate, and consistency with the time series trend of the temporality index. Meaning of the numerical value: A higher value indicates a response that is more consistent with past responses and the system's predicted direction.

[0120] weighting coefficient w_S, w_M, w_R, w_D: Weight coefficients for each evaluation metric. Hyperparameters used to adjust which evaluation axis to emphasize depending on the system's purpose and application. Example (standard settings): w_S = 0.3, w_M = 0.3, w_R = 0.3, w_D = 0.1 Example (focusing on specificity): w_S = 0.2, w_M = 0.5, w_R = 0.2, w_D = 0.1

[0121] 2. Selection of the optimal response The response candidate with the highest calculated FD score is selected as the "optimal external knowledge." This allows for filtering out responses that are inaccurate or out of context, even if fluent (hallucination), and selects only the highest quality syntax.

[0122] output: Selected response text: A single, high-quality text passed to the external knowledge / knowledge wave converter (116).

[0123] Inventiveness: This functional unit effectively suppresses the "hallucination" problem inherent in LLM. By using a multifaceted evaluation criterion called the FD score, it becomes possible to filter responses that are not only fluent but also structurally correct, meaningful, contextually appropriate, and consistent with the overall system objectives. In particular, the ability to quantitatively verify whether the LLM response is consistent with the current state of the information space by directly inputting the temporality index is a crucial quality assurance mechanism in this embodiment.

[0124] 3.15. External Knowledge / Knowledge Wave Conversion Unit (116)

[0125] Role: The external knowledge / knowledge wave converter (116) converts the text-format response candidates selected by the FutureFold function unit (115) into a physical form called a knowledge wave that can be injected into the observation field.

[0126] input: The selected optimal response candidate is supplied from the FutureFold function unit (115).

[0127] Processing details: From the text of the response candidates, we identify the semantic coordinates of the information they refer to (e.g., from the text "Susan Boyle", we identify the coordinates in the "music / emotion" region of the semantic space).

[0128] Centered on that coordinate system, a wave (such as a Gaussian wave packet) is generated with amplitude and spread corresponding to the confidence level and importance of the response candidates. This is the knowledge wave Ψk(x,t).

[0129] output: Knowledge wave Ψk(x,t): This is supplied to the time field update unit (104) and used to update the time field as an injection term in the time evolution equation.

[0130] 3.16. Switch (not shown)

[0131] Role: The switch controls the system's processing flow and ensures that the appropriate data flows to the appropriate functional block. For example, during initialization, it connects the initial observation field from the observation field generation unit (103) to the history field generation unit (105) and the probability density distribution calculation unit (106), and in the main loop, it connects the updated observation field from the observation field update unit (104) to the history field generation unit (105) and the probability density distribution calculation unit (106).

[0132] 4. System operation description based on flowcharts

[0133] Next, with reference to the flowchart in Figure 2, the specific processing steps of the information prediction method performed by the phase nonlinear storage system of this embodiment will be explained.

[0134] 4.1. Initialization Phase: When the system starts up, initialization is performed first.

[0135] (S201) Data Input: Based on the observation target specified by the user (e.g., YouTube® video ID), the data input unit (101) retrieves relevant time-series data (number of views, number of comments) and text data (title, description).

[0136] (S202) Parameter calculation: The parameter derivation unit (102) calculates the initial parameters of the observation field (semantic coordinates, amplitude, spread) from the input data.

[0137] (S203) Time field generation: The time field generation unit (103) generates the initial time field Ψ(x,0) using the calculated parameters.

[0138] 4.2. Main Loop After initialization, the system enters the main loop, which is the prediction cycle. This loop consists of analyzing the state of the observation field, generating predictions, and updating the observation field.

[0139] (S204) History field generation: The history field generation unit (105) generates the history field H(x,t).

[0140] (S205) Probability density distribution calculation: The probability density distribution calculation unit (106) calculates the probability density p(x|t).

[0141] (S206) Calculation of timeliness index: The timeliness index calculation unit (107) calculates the timeliness index set {M, C, E, TF, HS}.

[0142] (S207) Rule discovery: The rule discovery / memory unit (112) discovers and updates new prediction rules and control rules to maintain the stability of the observation field.

[0143] (S208) Prompt generation: The prompt generation unit (111) generates a comprehensive prompt to the LLM (115).

[0144] (S209) Response generation by LLM: The generated prompt is input to LLM (115), and LLM generates several response candidates (e.g., analysis of similar past cases, identification of possible risks, etc.) based on the context.

[0145] (S210) Response selection by FutureFold: The FutureFold function unit (115) calculates the degree of future syntactic convergence (FD) of each response candidate and selects the response candidate with the highest FD value as the "optimal external knowledge".

[0146] (S211) Conversion to knowledge wave: The external knowledge / knowledge wave conversion unit (116) converts the selected response candidate into a knowledge wave Ψk(x,t). This knowledge wave is supplied to the observation field update unit (104) and used to update the observation field.

[0147] 4.3. Update of viewing time

[0148] At the end of the main loop, an update process is performed to generate the time field for the next time step. This update process is selectively chosen from two methods to maintain system stability.

[0149] (S212) Determination of method for updating the observation field: The operator selection / adjustment unit (108) determines whether operator intervention is necessary based on the observation index supplied from the observation index calculation unit (107) and the control rules supplied from the rule discovery / storage unit (112). For example, if the rule "diversity (M) has exceeded the threshold" is triggered, it is determined that intervention is necessary, and the process proceeds to (S213). If it is determined that intervention is not necessary, the process proceeds to (S215).

[0150] (S213) Operator Selection: Based on the judgment in (S212), the operator selection / adjustment unit (108) selects an operator to stabilize the observation field. For example, in the case of a state where "diversity (M) is too high", the "focusing operator O_C" that concentrates the wave function to a specific point is selected. The strength of the operator (e.g., attractive strength γ) is also dynamically adjusted according to the value of the observation index.

[0151] (S214) Operator update of the observation field: The observation field update unit (104) directly modifies the observation field using the selected operator. This process brings about an instantaneous state change to restore the observation field to a stable state. After the update, the process returns to (S204) and the next prediction cycle begins.

[0152] (S215) Time field update using equations: The time field update unit (104) updates (evolves) the current time field Ψ(x,t) to the time field Ψ(x,t+Δt) at the next time based on the time evolution equation. In this process, the knowledge wave generated in (S211) is considered as an injection term in the equation. After the update, the process returns to (S204) and the next prediction cycle begins.

[0153] 5. Implementation details for integration with LLM (KAI control layer) This document details a specific implementation method for effectively controlling the output of an existing large-scale language model (LLM) without making significant changes to its internal structure. The core of this implementation lies in making the system of this embodiment function as an independent external control layer for the LLM's inference pipeline.

[0154] 5.1. Independence as a control layer

[0155] This embodiment takes a fundamentally different approach from fine-tuning or additional training of LLMs. Specifically, it does not modify the LLM's pre-trained parameters (weights) themselves, but instead directly modulates the Logits vector (the logarithm of the vocabulary's output probability distribution), which is its final output stage. This offers the following advantages:

[0156] Model-independent: Applicable to various models that output Logits (GPT-based, Llama-based, etc.), without depending on a specific LLM architecture.

[0157] Lightweight control: It does not require retraining the entire LLM with billions to trillions of parameters, and only requires calculating control vectors that represent the state of the observation field, resulting in low computational cost.

[0158] 5.2. Interference Processes on Lexical Probability Distributions

[0159] Below is pseudocode for a process that interferes with the lexical probability distribution of an LLM using the state of the observation field.

[0160] 1. Initialization of the observational field Ψ and convergence by semantic waves.

[0161] The observation field Ψ is represented as a probability distribution over the entire lexical space of the LLM. Initially, it is set as a uniform distribution and dynamically converges through its product with the semantic wave vector based on the input information.

[0162] import numpy as np def initialize_psi(vocab_size): # Initial state of the field: Uniform distribution across the entire lexical space return np.ones(vocab_size) / vocab_size def interfere_with_meaning_wave(psi, meaning_wave_vector): # Interfere by multiplying with a semantic wave vector (a vector that emphasizes a specific semantic domain). psi_prime = psi * meaning_wave_vector # Normalize again as a probability distribution. return psi_prime / np.sum(psi_prime)

[0163] 2. Recording and interference of the field slope by the historical field H.

[0164] Past state transitions of the observational field Ψ are recorded in the history field H. The history field influences the future state of the observational field, i.e., the "field inclination," and plays a role in maintaining contextual consistency.

[0165] class HistoryField: def __init__(self): self.psi_trajectory = [] def record(self, psi_state): # Add the state vector of the observation field to the history self.psi_trajectory.append(psi_state) def get_history_influence(self): # Generate influence vectors from the entire historical data (e.g., weighted average with time decay) if not self.psi_trajectory: return 1.0 influence = np.mean(self.psi_trajectory, axis=0) return influence def interfere_with_history(current_psi, history_influence): # Multiply the influence of the history field and apply interference. psi_prime = current_psi * history_influence return psi_prime / np.sum(psi_prime)

[0166] 3. Direct control of LLM to Logits

[0167] As a final step, the Logits vector immediately before output by the LLM is directly modulated using a control vector generated by integrating the effects of the temporal field and the hysteresis field.

[0168] def softmax(x): e_x = np.exp(x - np.max(x)) return e_x / e_x.sum(axis=0) def modify_logits_with_control_vector(logits, control_vector): # Multiply (or add) the control vector to the Logits vector (log probability). # This amplifies the probability of the desired semantic domain indicated by the observation field. modified_logits = logits * control_vector # Calculate the final output probability distribution from the modulated Logits. final_probabilities = softmax(modified_logits) Return direct_probabilities

[0169] This series of processes enables the system of this embodiment to maintain the powerful language generation capabilities of the LLM while dynamically guiding its thought process with an external KAI control layer, suppressing hallucination, and generating high-quality output that aligns with the purpose.

[0170] 5.3. Three elements that constitute independence To clarify that the KAI control layer of this embodiment is not merely an application of LLM technology but possesses inventiveness as an independent embodiment, three core independent technical elements are defined below. Each of these elements possesses novelty independently and works in conjunction with one another to realize a multi-layered control structure not found in conventional technology.

[0171] Independence of observational field updates (convergence mechanism by field initialization and semantic wave interference):

[0172] Definition: A processing step that dynamically converges the lexical probability distribution by interfering a temporal field Ψ, which is initialized as a uniform distribution over the entire lexical space, with a semantic wave vector based on input information.

[0173] Inventiveness: This process shapes the "terrain" of the probability distribution based on externally provided information (semantic waves), independently of the internal state of the LLM. This is a completely new field-theory-based approach that dynamically controls the shape of the entire probability distribution, unlike prompt engineering which statically adjusts the probability of occurrence of specific words.

[0174] Independence of history field generation (field slope recording and interference structure):

[0175] Definition: A computational mechanism that records past transition states of the observational field Ψ as a history field H, and interferes with the generation of the convergence direction or control vector of the next observational field Ψ based on the information of this history field H.

[0176] Inventiveness: Unlike LLMs, which have a short-term context window (thousands to tens of thousands of tokens), the history field retains a "memory" of the system's long-term state transitions. This allows for the modeling of the "field's inclination," where past events, far removed in time, influence current decisions. This provides long-term self-consistency and context preservation capabilities that are difficult to achieve with LLMs alone.

[0177] Independence of direct control of lexical probability distributions (rule discovery and Logits modulation):

[0178] Definition: A processing step that dynamically controls syntax selection by multiplying or adding an external control vector representing the state of the observation field Ψ to the Logits vector or lexical probability distribution output by a large-scale language model.

[0179] Inventiveness: This direct Logits modulation is a powerful and precise control technique that intervenes in the final stage of LLM's "thinking." By using control vectors generated based on rules discovered from the chronological index, it is possible to leverage the creativity of LLM while providing "guardrails" to ensure that its output does not deviate from the system's purpose. This is a critically important technique for utilizing LLM as a reliable component of autonomous systems.

[0180] 6. Examples

[0181] The following shows an example of applying the phase nonlinear storage system of this embodiment to a specific use case.

[0182] Example 1: Predicting the number of views for YouTube® videos Observation subject: A YouTube video (registered trademark) showing an unknown 8-year-old girl showcasing her astonishing singing ability at a talent show.

[0183] Task: Predict how many views this video will get in 24 hours (whether it will "go viral" or not).

[0184] Step 1: Observation of the initial state (S201-S203)

[0185] Data entry: Data is retrieved 18 hours after publication.

[0186] Time-series data: 810,000 views, 45,000 likes, 3,200 comments. The rate of increase in views is accelerating.

[0187] Text data: Title "8-year-old girl's breathtaking singing voice", Tags "#music #touching #talentedkidssing".

[0188] Parameter calculation: From the text data, the semantic coordinates are determined to fall within the "music / emotion" region. Based on the number of plays and its growth rate, the initial amplitude A is set relatively high.

[0189] Time-space generation: An initial time-space generation with relatively high energy is generated, centered on the "music / emotion" domain.

[0190] Step 2: Calculation of the timeliness index (S206)

[0191] The calculated probability density is sharply concentrated in a specific region of the semantic space.

[0192] Timekeeping index: Diversity (M): Low (0.15) → Interest is concentrated on specific videos. Concentration (C): Very high (0.95) → Suggests the formation of a strong trend. Order (E): High (0.88) → Information is structured, and consistent responses are occurring. Time Fluctuation (TF): High (0.75) → The situation is changing rapidly (it's becoming popular). Historical Impact (HS): Medium (0.50) → There have been similar explosive hits in the past, but they do not completely match.

[0193] Step 3: Prompt Generation and Response to LLM (S208 - S210)

[0194] Prompt Generation: The prompt generation unit (111) generates the following prompt.

[0195] # Instruction You are an expert in SNS trends. Analyze the following situation and predict what will happen to this YouTube video after 24 hours from multiple perspectives. # Observation Target - Video: Singing video of an 8-year-old girl - Current number of views: 810,000 times (18 hours after publication) # System Analysis Results - Viewing time indicators: Diversity = 0.15 (low), Concentration = 0.95 (high), Order = 0.88 (high), Temporal variation = 0.75 (high), Historical impact = 0.50 (medium) - Activated rule: "IF C > 0.9 AND TF > 0.7 THEN The trend is likely to grow exponentially" - Comparison with the historical field: Similarity has been detected with the initial pattern of past videos of "Susan Boyle". # Response Format 1. Prediction based on comparison with past similar cases 2. Prediction based on positive factors 3. Prediction based on potential risks and negative factors

[0196] Response Generation by LLM: The LLM (117) generates three response candidates.

[0197] Response Option 1: "In the past case of Susan Boyle, the unexpectedness of the video was shared on social media and it exceeded 3 million views in 24 hours. This video has similar potential and could reach 2.5 million to 3.5 million views."

[0198] Response option 2: "The element of 'the gap between age and singing ability' is moving and easily shared. A positive chain reaction can be expected, and the number of views will likely increase significantly."

[0199] Response option 3: "Rapid growth in popularity comes with the risk of criticism and backlash from some quarters. If negative comments increase, growth may slow down."

[0200] Selection by FutureFold: The FutureFold function unit (115) calculates the KI value for each response. Response candidate 1, which has specific numerical values ​​and strong arguments, obtains the highest KI value (e.g., 0.91) and is selected.

[0201] Step 4: Generation and injection of knowledge waves (S211)

[0202] Knowledge wave conversion: The external knowledge / knowledge wave conversion unit (116) converts the selected response candidate 1 into a knowledge wave. It identifies semantic coordinates from "Susan Boyle" in the text and generates a knowledge wave around them with an amplitude corresponding to the strength of the prediction, such as "2.5 million to 3.5 million playbacks".

[0203] Injection into the Time Field: This knowledge wave is injected into the Time Field update (S204) of the next time step. As a result, the probability distribution of the Time Field changes to be drawn towards the future state of "2.5 million to 3.5 million plays" predicted by the system.

[0204] Step 5: Final Prediction

[0205] By calculating the expected value of the updated probability distribution of the viewing time, specific predicted values ​​such as "the number of views in 24 hours will be approximately 2.8 million" are output.

[0206] At the same time, the user is presented with an explanation in natural language generated by the LLM ("Similar to the case of Susan Boyle...") and can understand the basis for the prediction.

[0207] Example 2: Application to stock trading Observation target: The stock price of a certain IT company (stock code: 9999).

[0208] Problem: Predict the short-term trend of the stock price of this company in anticipation of a new product launch event and assist in trading decisions.

[0209] Step 1: State observation

[0210] Data input: Continuously input stock price (5-minute bar), trading volume, related news articles, mentions on SNS (X / old Twitter (registered trademark)), analyst reports, etc.

[0211] Observation field generation: Based on this information, an observation field representing market interest and sentiment is generated. The semantic space is composed of axes such as "technology", "finance", "positive", "negative", etc.

[0212] Step 2: Analysis before the event Observation timing index: Due to the expectation of a new product launch, the stock price shows an upward trend. Diversity (M): Decreasing trend → Interest is concentrated on stock 9999. Concentration (C): Increasing trend → Expectations of "buy" are concentrated. Time variation (TF): High → The market is reacting actively.

[0213] Rule discovery section: The rule "IF before the event and C > 0.8 AND TF > 0.7 THEN the volatility increases after the event" is triggered.

[0214] Prompt generation and LLM response: LLM generates a response stating that "in past announcements from similar companies, stocks are often bought based on expectations before being sold off as the news is priced in." This becomes a knowledge wave, injecting a wave into the market that suggests "post-event downside risk."

[0215] Step 3: Real-time analysis during the event

[0216] Data entry: The data entry unit (101) acquires text transcripts of the live streaming of the new product announcement and real-time reactions on social media.

[0217] Viewing Forum Update: When a product is announced that is more innovative than market expectations, positive posts such as "#amazing" and "#revolutionary" surge on social media. These strongly shift the viewing forum in a "positive and innovative" direction.

[0218] Timeliness Index: Diversity (M) has surged. This indicates that diverse discussions have begun not only about expectations but also about specific product features (e.g., AI, battery performance). This is a sign of a healthy trend.

[0219] Step 4: Buy / Sell Decision Support

[0220] Final prompt to LLM: "While there was a wave of knowledge suggesting a 'sell-the-news' risk before the event, the timing indicators during the event (especially the sharp rise in diversity M) showed a strong positive reaction that contradicted this. What is the optimal course of action, considering all factors?"

[0221] Final response: LLM stated, "The initial 'sell the news' risk has likely been negated by the better-than-expected announcement. The increased diversity of the timeliness indicators suggests sustained broad interest, and short-term 'buy the dip' appears to be an effective strategy."

[0222] System Output: The system provides the user (trader) with a "buy recommendation" signal along with the rationale behind that decision (changes in indicators, LLM analysis).

[0223] 7. Modifiability of the Embodiments

[0224] The present invention is not limited to the embodiments described above. For example, the dimension of the time field is not limited to two dimensions, but can be extended to three or more dimensions depending on the complexity of the object being analyzed. Furthermore, the specific calculation formulas for the time evolution equation and the timeliness index can be modified in various ways depending on the characteristics of the object being predicted. LLM can also utilize models specialized for specific domains or ensemble models that combine multiple models. These modifications are also included within the scope of the technical idea of ​​the present invention.

[0225] 8. Details of formulas, definitions, and specific examples

[0226] This section provides a detailed explanation of the fundamental mathematical formulas, definitions, and specific examples of this embodiment.

[0227] 8.1. Definition formula for the chronological index The temporality index is metadata that characterizes the overall shape and dynamics of a probability density distribution p(x|t).

[0228] Multiplicity (M): Indicates how widely information is disseminated. It is defined using Shannon entropy: M = -∫ p(x) log(p(x)) dx The flatter and more widespread the distribution, the larger M becomes.

[0229] Concentration (C - Concentration): Indicates how concentrated information is at a particular peak. It is defined as the maximum value of the probability density. C = max(p(x)) When attention is focused extremely on specific information, C becomes larger.

[0230] Order (E - Entropy): Indicates the structure and degree of order in a probability distribution. It is defined as normalized negentropy (negative entropy). E = (M_max - M) / M_max M_max is the entropy for a uniform distribution. The more specific the structure of the distribution, the closer E approaches 1.

[0231] Time Fluctuation (TF): Indicates how much a probability distribution changes over time. It is defined as the L2 norm (Euclidean distance) between the probability distributions at two points in time. TF = || p(x,t) - p(x,t-Δt) ||² TF (Trend Factor) increases when the trend is changing rapidly.

[0232] Historical Similarity (HS): Indicates how similar the current probability distribution is to the accumulated historical field. It is defined as the inner product (or cosine similarity) of the probability distribution and the historical field. HS = ∫ p(x,t) · H(x,T) dx The HS (High Speed) will increase when patterns that have been seen in the past are reproduced.

[0233] Convergence Density (D) is a measure of the strength with which information converges toward a specific future construct, and indicates the stability of the future in the time field. This metric has two definitions depending on the context.

[0234] Definition 1: Continuity with past responses. In conjunction with LLM, this measures how consistent the generated response candidates are with past responses.

[0235] D = (1 / K) · Σ cos(v_response, v_past_k) v_response: Vector representation of the current response candidate. v_past_k: Vector representation of the kth past response. K: The number of past responses to consider. cos(...): Cosine similarity. The higher the D value, the more the dialogue converges on a specific theme.

[0236] Definition 2: Rate of decrease in information entropy. Based on the physical behavior of the observation field, this represents the degree of concentration of the influence that the observer's consciousness (or knowledge wave) has on the observation field. D(t) = -dM / dt M: Diversity (Shannon entropy). dM / dt: Time derivative of diversity. The larger and more positive D is, the more rapidly the information is converging to a particular state (a clear trend is forming).

[0237] Summary of Timeliness Indices

[0238] [Table 1]

[0239] 8.2. Legend and Examples of Rules

[0240] Rules are knowledge representations that link specific patterns in timeliness indicators to the predictions and actions that should follow.

[0241] Legend (JSON format)

[0242] { "rule_id": "R001", "Description": "A rule that suggests a trend is overheating and may reverse." "condition": { "AND": [ { "metric": "C", "operator": ">", "value": 0.9 }, { "metric": "M", "operator": "<", "value": 0.1 }, { "metric": "TF", "operator": ">", "value": 0.8 } ] }, "action": { "type": "alert", "Message": "The market is overheating. Concentration (C) is above 0.9 and diversity (M) is below 0.1. Be aware of a short-term reversal and decline." }, "priority": 0.85, "success_rate": 0.75 }

[0243] Specific example

[0244] Rule 1: Discover emerging trends Condition: (M > 0.7 AND C < 0.2 AND TF > 0.6) (High diversity, low concentration, and large temporal fluctuations) Interpretation: There is no single dominant trend; various pieces of information are actively moving. This suggests the early stages of a new trend emerging. Action: "Detect signs of new trends. Enhance monitoring of related keywords."

[0245] Rule 2: Replicate past success patterns Condition: (HS > 0.85 AND result of past similar patterns == 'success') (Historical influence is very high, and similar past patterns yielded good results.) Interpretation: The current situation closely resembles past successes. Action: "It matches past success patterns by over 85%. The current trend is likely to yield positive results."

[0246] Rule 3: Trend Saturation and Stagnation Condition: (C > 0.8 AND TF < 0.1) (High level of concentration, but small time fluctuations) Interpretation: A situation that has attracted much attention but has not seen any significant changes. This suggests that the trend may have reached saturation and entered a period of stagnation. Action: "The trend is saturated. Further rapid growth is unlikely."

[0247] 8.3. Legend and Examples of Operators

[0248] An operator is a tool that applies specific mathematical transformations to a time field, thereby actively changing its state.

[0249] Legend

[0250] [Table 2]

[0251] Specific example

[0252] Usage example 1: "what-if" simulation Situation: The reputation of a certain product is concentrated on specific negative opinions (high C, low M). Operation: The user applies the diffusion operator (O_D). Results: The scope of view expands, and the peak of negative opinions decreases. The system presents simulation results such as, "If public relations activities highlight other positive aspects, negative impressions may be diminished."

[0253] Example 2: Active induction of predictions Situation: The system determined that "the trend is stagnant" (Rule 3). Operation: The user places new relevant information (e.g., mention by an influencer) at a specific coordinate in the semantic space and applies the concentration operator (O_C). Results: A new peak forms in the time zone, and the previously stagnant probability distribution begins to move again. This allows for simulations to determine whether it could act as a catalyst for a new trend.

[0254] 9. Specific Examples of LLM Integration

[0255] This section provides a detailed explanation of the interaction with the Large-Scale Language Model (LLM), which is a core element of this embodiment, by giving specific examples of prompts, response candidates, and knowledge waves.

[0256] 9.1. Examples of prompts to give to the LLM The prompts serve as a "bridge" to communicate the analysis results of this system to the LLM, thereby eliciting high-quality knowledge. It is crucial to provide a structured description of the system's internal state, rather than simply asking questions.

[0257] Situation: In Example 1 (Predicting the number of views of a YouTube (registered trademark) video), this is the prompt obtained when analyzing the status 18 hours after publication.

[0258] The prompt generated by the prompt generation unit (111)

[0259] # Instructions You are an expert in social media trend analysis. Based on the comprehensive data below, predict and analyze the state of the specified target 24 hours from now from multiple perspectives. Pay particular attention to comparisons with similar past cases. # Observation target - Type: YouTube video - Title: "8-year-old girl's stunning singing voice leaves judges stunned" - Publication date and time: 2024-10-30 18:00 (JST) - Current time: 2024-10-31 12:00 (JST) (18 hours have passed since publication) # Observational data - Current views: 810,000 - Time series of views: [1h: 50,000, 6h: 250,000, 12h: 500,000, 18h: 810,000] - Comments: Over 95% of the comments expressed emotions such as "It gave me goosebumps" and "I couldn't stop crying." # System analysis results (Time-based field analysis) ## 1. Timekeeping index - **Diversity (M): 0.15 (Very Low)** → A state of extreme concentration of attention. - **Concentration (C): 0.95 (Very High)** → A single, strong trend is forming. - **Order (E): 0.88 (High)** → Information is structured, and consistent responses (emotions) are occurring. - **Time Fluctuation (TF): 0.75 (High)** → The situation is changing rapidly, and the growth momentum is strong. - **Historical Impact (HS): 0.50 (Moderate)** → Similar patterns exist in past datasets, but they are not exact matches. ## 2. Activated Rules - **Rule ID R023:** "IF C > 0.9 AND TF > 0.7 THEN High probability of exponential growth" - **Confidence level:** 88% ## 3. Comparison with historical data - **Similar Patterns:** Similarity was detected in the history field to the initial growth pattern of ID `P-2009-SusanBoyle` (similarity: 0.55). This pattern eventually achieved explosive success. # Response format Please generate response candidates, along with specific justifications, from the following three different perspectives. 1. Response Candidate 1: Comparison of Similar Cases Based on similar patterns detected in the history (Susan Boyle's case), predict the specific range of play counts. 2. Response Candidate 2: Positive Factor Analysis Based on current timeliness indicators and observed data, please explain, as an expert, the positive factors that will contribute to the success of this trend. 3. Response Option 3: Focus on the "low diversity" of the risk analysis timeliness indicators and discuss the potential risks and possibility of a slowdown associated with this trend.

[0260] 9.2. Specific Examples of Multiple Response Candidates In response to the above prompt, LLM (117) generates several candidate responses, such as the following:

[0261] Response option 1: Comparison of similar cases The 2009 case of Susan Boyle, which has been noted for its similarities in the history section, caused a huge sensation due to the "gap between her appearance and singing voice" on a talent show, recording approximately 3 million views in 24 hours after its release. The current case of an "8-year-old girl" also shares a common structure in that it involves a "gap between age and singing ability." The high concentration (C) and time variability (TF) in the viewing frequency index suggest that a similar viral spread is occurring. Judging from these similarities, it is very likely that the number of views in 24 hours will reach between 2.5 million and 3.5 million.

[0262] Response Candidate 2: Positive Factor Analysis The current viewing frequency indicators show a typical early pattern of a "buzz." In particular, the high concentration (C) and order (E) reflect a state (echo chamber) where viewers share a single emotion, "excitement," which is amplified on social media. The high temporal volatility (TF) indicates that this amplification cycle has not yet saturated, and we can expect an accelerating increase in views over the next few hours. This is a very strong positive signal.

[0263] Response option 3: Risk analysis Very low diversity (M) suggests the trend's vulnerability. Because interest is too focused on the single point of "emotion," the trend risks rapidly losing momentum if any other strong information emerges (for example, negative rumors about the girl or the appearance of another competing emotional video). Excessive focus can also lead to viewers losing interest quickly. While growth continues at this point, the low diversity suggests the trend's lifespan may be relatively short.

[0264] 9.3. The process of selecting a knowledge wave from multiple response candidates. The FutureFold function (115) calculates the Future Syntax Convergence (KI) to select the "highest quality" response from the three response candidates mentioned above. The KI value is an index that comprehensively evaluates the specificity, logic, and structure of the response.

[0265] Example of KI value calculation

[0266] [Table 3]

[0267] * S, M, and R are examples of internal indices that make up the KI value. The actual calculation involves more complex elements.

[0268] As a result, response candidate 1, which has the most specific and strong arguments, receives the highest KI value (0.91) and is selected by the system as the "optimal external knowledge."

[0269] 9.4. Specific Examples of Knowledge Waves

[0270] The external knowledge / knowledge wave conversion unit (116) converts the selected response candidate 1 into a knowledge wave (Ψ_k), which is a physical form that can be injected into the observation field.

[0271] Conversion process

[0272] Text analysis: Analyze the text of response candidate 1: "...the number of views after 24 hours is very likely to reach between 2.5 million and 3.5 million..."

[0273] Identifying semantic coordinates: From keywords such as "Susan Boyle" and "emotion" within the text, we identify the coordinates x_k = (2.5, 4.1) (the "music, emotion, viral" region) in the semantic space.

[0274] Parameter determination: Amplitude (A_k): The strong amplitude is determined from the prediction confidence level ("very high") and a specific numerical value (2.5 million - 3.5 million). Spread (σ_k): Considering the prediction range (a range of 2.5 million to 3.5 million), a waveform with a slightly wider spread is set. Phase (φ_k): Sets the phase that reflects the prediction time axis (24 hours later).

[0275] Knowledge wave generation: Using the parameters above, a knowledge wave (Gaussian wave packet) is generated using the following formula.

[0276] Ψ_k(x,t) = A_k · exp(iφ_k) · exp(-||x - x_k||^2 / (2σ_k^2))

[0277] This generated knowledge wave is sent to the time field update unit (104) and acts on the time field as an injection term in the time evolution equation. As a result, the probability distribution of the time field changes in a way that pulls it toward the future state of "2.5 million to 3.5 million plays" predicted by the LLM.

[0278] 10. Details of the rule discovery method The rule discovery / storage unit (112) of this embodiment is a core function of the system's self-organizing capability. Here, we will describe in detail how to autonomously discover prediction rules from time-series data of the timeliness index.

[0279] 10.1. Basic Principles of Rule Discovery Rule discovery is the process of statistically extracting causal relationships between specific patterns in temporality indicators (conditional part) and subsequent changes in the information space (resulting part). This process consists of the following three steps.

[0280] Step 1: Pattern Extraction Characteristic patterns are extracted from the time-series data of the temporality index. For example, a pattern where "diversity (M) decreases to less than 0.2, and then concentration (C) exceeds 0.9." The sliding window method is used for this extraction. Changes in the temporality index over a certain period (e.g., 6 hours) are extracted as a single pattern and stored in a pattern database.

[0281] Step 2: Observing Results After each pattern occurs, observe the changes in the information space over a certain period (e.g., 24 hours). Specifically, record whether the trend was successful (e.g., the number of views exceeded the predicted value), unsuccessful (e.g., significantly below the predicted value), or stagnated.

[0282] Step 3: Correlation Analysis and Rule Generation Statistically analyze the combinations of patterns and results, and extract those with significant correlations as rules. The following indicators are used in this process. Support: The frequency with which that pattern appears in the entire dataset. Confidence: The probability that a specific outcome will occur when that pattern appears. Lift: How much higher is the probability of an outcome occurring when a pattern is present compared to when there is no pattern?

[0283] Combinations of patterns and results that exceed a certain threshold for these indicators are registered as new rules.

[0284] 10.2. Specific Algorithms for Rule Discovery

[0285] In this embodiment, a hybrid approach combining decision trees and genetic algorithms is employed for rule discovery.

[0286] Rule extraction using decision trees A decision tree constructs a tree structure that classifies results using the value of the timeliness index as a conditional branch. Each branch of this tree becomes a potential rule candidate. For example, the following decision tree is constructed.

[0287] [Root] ├─ M < 0.2? │ ├─ YES → C > 0.9? │ │ ├─ YES → TF > 0.7? │ │ │ ├─ YES → [Result: Trend Soaring] (Confidence: 85%) │ │ │ └─ NO → [Result: Stagnation] (Confidence level: 60%) │ │ └─ NO → [Result: Slow growth] (Confidence level: 70%) │ └─ NO → ...

[0288] From this tree, the rule "IF M < 0.2 AND C > 0.9 AND TF > 0.7 THEN trend surge (85% confidence)" is extracted.

[0289] Rule optimization using genetic algorithms: Rules extracted by decision trees may not yet be optimized. Therefore, a genetic algorithm is used to fine-tune the threshold value of the rule's condition (e.g., "0.2" in M ​​< 0.2). Individual representation: Each rule is treated as a single individual, and the threshold value of the condition is represented as a gene. Fitness assessment: Each rule is applied to historical data, and the prediction accuracy (correctness) is defined as the fitness. Selection, Crossover, and Mutation: Select rules with high fitness and generate new rules by crossing them over (combining the conditions of two rules) or by mutation (randomly changing the threshold). Generational change: Low-fitting rules are eliminated and replaced with newly generated rules.

[0290] By repeating this process for dozens of generations, the rule with the highest predictive accuracy survives and is stored in the system's knowledge base.

[0291] 10.3. Example of Rule Discovery Implementation

[0292] class RuleDiscoveryUnit: def __init__(self): self.pattern_database = [] self.rules = [] def collect_pattern(self, kai_metrics_history, result): "Collection of patterns and results of temporality indicators" pattern = { 'metrics': kai_metrics_history[-6:], # Last 6 hours 'result': result # 'success', 'failure', 'stagnation' } self.pattern_database.append(pattern) def discover_rules(self): """Decision trees are used to discover rules""" # Prepare the data X = [] # Features (Statistics of the temporality index) y = [] # Label (result) for pattern in self.pattern_database: metric = pattern['metrics'] # Calculate statistics Features = [ np.mean([m['M'] for m in metrics]), np.mean([m['C'] for m in metrics]), np.mean([m['E'] for m in metrics]), np.mean([m['TF'] for m in metrics]), np.mean([m['HS'] for m in metrics]), np.max([m['C'] for m in metrics]), np.min([m['M'] for m in metrics]) ] X.append(features) y.append(pattern['result']) # Learn decision trees from sklearn.tree import DecisionTreeClassifier clf = DecisionTreeClassifier(max_depth=4, min_samples_leaf=10) clf.fit(X, y) # Extracting rules from a decision tree from sklearn.tree import _tree tree = clf.tree_ feature_names = ['M_mean', 'C_mean', 'E_mean', 'TF_mean', 'HS_mean', 'C_max', 'M_min'] def extract_rules(node, depth, conditions): if tree.feature[node] != _tree.TREE_UNDEFINED: feature = feature_names[tree.feature[node]] threshold = tree.threshold[node] # The child on the left (meets the conditions) left_conditions = conditions + [f"{feature} <= {threshold:.2f}"] extract_rules(tree.children_left[node], depth+1, left_conditions) # The child on the right (does not meet the conditions) right_conditions = conditions + [f"{feature} > {threshold:.2f}"] extract_rules(tree.children_right[node], depth+1, right_conditions) else: # Leaf node (result) samples = tree.n_node_samples[node] values ​​= tree.value[node][0] predicted_class = np.argmax(values) confidence = values[predicted_class] / samples if confidence > 0.7 and samples > 5: # threshold rule = { 'conditions': conditions, 'result': clf.classes_[predicted_class], 'confidence': confidence, 'support': samples } self.rules.append(rule) extract_rules(0, 0, []) Return self.rules def optimize_rules_with_ga(self): "Optimizing rules with a genetic algorithm" # Omitted (Only the concept is shown due to the complexity of the implementation) pass

[0293] 11. Details of the two methods for updating viewing times

[0294] The observation field update unit (104) provides two different methods for changing the state of the observation field. Details of each method and how to use them are described here.

[0295] 11.1. Method A: Time evolution using the wave equation This method simulates the "natural" evolution of the time field. It calculates how the information space changes according to physical laws, while being influenced by external interventions (injection of knowledge waves) and past memories (history field).

[0296] Numerical Calculation Methods: The time evolution equation is a partial differential equation and is difficult to solve analytically. Therefore, approximate solutions are obtained using numerical calculation methods. In this embodiment, Euler's method or Runge-Kutta's method is used.

[0297] Situations under which this method is chosen When the temporality indicators are stable and abrupt intervention is not necessary. If you want to observe the natural evolution of long-term trends.

[0298] 11.2. Method B: Operator-driven update

[0299] This method involves the user or system actively manipulating the observation field. Mathematical transformations (operators) are applied to the observation field to achieve a specific objective (e.g., increasing diversity, emphasizing a particular domain).

[0300] Implementation of major operators

[0301] Diffusion Operator (O_D): Spatially expands the observation field and increases diversity.

[0302] def apply_diffusion_operator(self, Ψ, beta): Apply the diffusion operator. from scipy.ndimage import gaussian_filter # Smoothing using a Gaussian filter Ψ_diffused_real = gaussian_filter(Ψ.real, sigma=beta) Ψ_diffused_imag = gaussian_filter(Ψ.imag, sigma=beta) Ψ_diffused = Ψ_diffused_real + 1j * Ψ_diffused_imag return self.normalize(Ψ_diffused)

[0303] Focusing Operator (O_C): Focuses the observation field toward a specific coordinate.

[0304] def apply_concentration_operator(self, Ψ, target_x, target_y, gamma): Apply the centralized operator. # Generate an attractive potential to the target coordinates x_grid, y_grid = self.get_grid_coordinates() distance = np.sqrt((x_grid - target_x)**2 + (y_grid - target_y)**2) attraction = np.exp(-gamma * distance) # Applying gravity to the observation field Ψ_concentrated = Ψ * (1 + attraction) return self.normalize(Ψ_concentrated)

[0305] Observation Operator (O_O): Increases the amplitude in a specific region, thereby increasing the "probability of observation" in that region.

[0306] def apply_observation_operator(self, Ψ, region_mask, alpha): """Apply the observation operator""" # region_mask: A Boolean array indicating the observation region. Ψ_observed = Ψ.copy() Ψ_observed[region_mask] *= (1 + alpha) return self.normalize(Ψ_observed)

[0307] Situations under which this method is chosen When the timeliness indicator shows an outlier value and the system needs to intervene proactively (e.g., rule-based automated intervention). This is useful when you want to test a specific hypothesis (e.g., "What would happen to the trend if this information spread more widely?").

[0308] 12. Details of the interaction between the observational field and the history field The interaction between the time field and the history field is at the heart of the “memory” function in this embodiment. Here, we will describe in detail how this interaction is implemented and how it contributes to prediction.

[0309] 12.1. The role of the history field The history field H(x,T) is a "long-term memory" that compresses and stores the trajectories of past time fields. This enables the system to do the following: Pattern recognition: Determines which past patterns the current observation field resembles. Contextual understanding: Even the same temporality indicator can be interpreted differently depending on the past context. Stabilizing predictions: Focus on long-term trends and avoid being misled by temporary noise.

[0310] 12.2. Calculation of Historical Impact Index (HS)

[0311] The historical influence index HS quantifies the similarity between the current probability distribution p(x,t) and the historical field H(x,T).

[0312] Calculation using the dot product

[0313] def calculate_history_similarity(self, p, H): "Calculate the Historical Impact Index (HS)" # Inner product of probability distribution and history field HS = np.sum(p * H) # Normalization (to the range of 0 to 1) HS_normalized = HS / (np.linalg.norm(p) * np.linalg.norm(H)) return HS_normalized

[0314] Calculation using cosine similarity

[0315] def calculate_history_similarity_cosine(self, p, H): "HS calculation using cosine similarity" from sklearn.metrics.pairwise import cosine_similarity p_flat = p.flatten().reshape(1, -1) H_flat = H.flatten().reshape(1, -1) HS = cosine_similarity(p_flat, H_flat)[0, 0] return HS

[0316] 12.3. Pattern matching using history fields

[0317] The system searches through past patterns stored in the history field for the pattern most similar to the current viewing field.

[0318] class HistoryFieldMemory: def __init__(self): self.snapshots = [] # List of past snapshots def add_snapshot(self, Ψ, metadata): """Added a snapshot of the viewing area""" Snapshot = { 'Ψ': Ψ.copy(), 'p': np.abs(Ψ)**2, 'metadata': metadata, # metadata such as time and result 'timestamp': time.time() } self.snapshots.append(snapshot) def find_similar_patterns(self, current_p, top_k=5): """Search for past patterns similar to the current probability distribution""" similarities = [] for snapshots in self.snapshots: past_p = snapshot['p'] similarity = self.calculate_similarity(current_p, past_p) similarities.append({ 'similarity': similarity, 'snapshot': snapshot }) # Sort by similarity similarities.sort(key=lambda x: x['similarity'], reverse=True) return similarities[:top_k] def calculate_similarity(self, p1, p2): "Calculate the similarity between two probability distributions" from sklearn.metrics.pairwise import cosine_similarity p1_flat = p1.flatten().reshape(1, -1) p2_flat = p2.flatten().reshape(1, -1) return cosine_similarity(p1_flat, p2_flat)[0, 0]

[0319] Example of use: Referencing past success patterns In a stock trading example, if the current trading activity of stock 9999 is detected to be similar to the initial pattern of past successful stock 7777 (HS = 0.82), the system provides the following information to the LLM:

[0320] # Additional information for the prompt Past similar patterns: - Pattern ID: P-2023-Stock7777 - Similarity: 0.82 - Results at the time: After the new product announcement, the stock price rose 15% in three days. - Timeliness index at the time: M=0.25, C=0.88, E=0.85, TF=0.72, HS=0.75

[0321] This allows LLM to refer to specific past success stories and generate more accurate predictions.

[0322] 13. Technical details of the system implementation

[0323] 13.1. Construction of Semantic Space A semantic space is the foundation for transforming text data into two-dimensional (or three-dimensional or more) coordinates. In this embodiment, the semantic space is constructed using the following procedure.

[0324] Step 1: Text Embedding Using a pre-trained BERT model, the observed text (title, description, etc.) is converted into a high-dimensional vector (e.g., 768 dimensions).

[0325] from sentence_transformers import SentenceTransformer model = SentenceTransformer('all-MiniLM-L6-v2') "An 8-year-old girl's stunning singing voice left the judges stunned." embedding = model.encode(text) # 768-dimensional vector

[0326] Step 2: Dimensionality Reduction Reduce the 768 dimensions to 2 dimensions using PCA (Principal Component Analysis) or t-SNE.

[0327] from sklearn.decomposition import PCA pca = PCA(n_components=2) # Train PCA using multiple text embeddings embeddings = [model.encode(text) for text in corpus] pca.fit(embeddings) # Convert new text to 2D coordinates coordinates_2d = pca.transform([embedding])[0] # Example: [2.5, 4.1]

[0328] Step 3: Interpreting the Semantic Space Interpret what each axis of the reduced two-dimensional space represents. For example, the first principal component might represent "emotional intensity," and the second principal component might represent "topic type (music / politics / sports)."

[0329] 13.2. Optimization of computational efficiency The computational cost of calculating the time field increases as the grid size increases. In this embodiment, the following optimization method is employed.

[0330] Adaptive grid resolution: Use a fine grid in the region of interest (region with high probability density) and a coarse grid otherwise.

[0331] GPU parallel computing: The update calculation of the observation time field can be performed independently at each grid point, making it suitable for parallel computing using GPUs.

[0332] import cupy as cp # CuPy: GPU version of NumPy def evolve_on_gpu(self, Ψ_gpu, dt): # Calculate on GPU memory laplacian_gpu = self.calculate_laplacian_gpu(Ψ_gpu) dΨ_dt_gpu = -1j * laplacian_gpu +... Ψ_new_gpu = Ψ_gpu + dt * dΨ_dt_gpu return Ψ_new_gpu

[0333] 14. Additional Examples

[0334] 14.1. Example 3: SNS Trend Prediction Observation target: A specific hashtag "#New Product A" on Twitter (registered trademark) (current X).

[0335] Problem: Predict whether this hashtag will trend in the next 24 hours.

[0336] System operation: The data input unit (101) acquires the number of posts, retweet count, and sentiment analysis results (positive / negative) of the hashtag in time series. The observation time field generation unit (103) generates an observation time field centered on the semantic coordinates of "New Product A". The timeliness index calculation unit (107) detected a sharp increase in diversity (M) (an increase in posts from various perspectives). The rule discovery / memory unit (112) activates the rule "IF M > 0.8 AND TF > 0.6 THEN there is a high probability of it becoming a trend." LLM (117) responded, "The high level of diversity suggests that the product is being accepted by a wide range of people. There is an 85% or higher chance that it will become a trend." The system presented the user with the result "Trending prediction: 85%".

[0337] Result: The hashtag actually trended 18 hours later, proving the prediction correct.

[0338] 14.2. Example 4: Product Demand Forecasting Observation target: Demand for a specific product, "Smartwatch B," on an e-commerce site.

[0339] Challenge: Predict peak demand during the year-end shopping season and optimize inventory.

[0340] System operation: The data entry unit (101) retrieves the number of product views, cart additions, purchases, and review submissions. The viewing space is generated in the semantic space of the "smartwatch" category. The temporality indicator shows an increase in concentration (C) and an increase in time volatility (TF) (demand is rapidly increasing). The history memory unit (110) detects a similarity (HS = 0.75) to past year-end sales patterns. LLM (117) responded, "Based on similar past patterns, demand has peaked around December 15th. We expect a similar trend this year." The system outputted the result: "Demand peak forecast date: December 15th ± 2 days".

[0341] Results: Companies increased inventory based on forecasts to avoid stockouts. Sales increased by 20% year-on-year.

[0342] 15. Applicability of this embodiment The phase nonlinear storage system of this embodiment is not limited to the above-described example, but can be applied to a wide range of fields, as follows.

[0343] 15.1. Financial Market Analysis This tool predicts short-term price fluctuations in financial instruments such as stocks, foreign exchange, and cryptocurrencies. It quantitatively evaluates market sentiment and overheating based on changes in the diversity and concentration of trading activity, and determines the timing for buying and selling.

[0344] 15.2. Marketing Strategy Planning We evaluate the promotional effectiveness of new products in real time and determine the optimal allocation of advertising investment. We also determine which media and influencers are most effective based on changes in the viewing environment.

[0345] 15.3. Risk Management It detects early signs of corporate reputational risk and product quality problems. By monitoring rapid changes in the time field (sudden rises in time-varying TF) and concentration in negative areas, it captures the precursors to online controversies and crises.

[0346] 15.4. Analysis of Trends in Scientific Research This system predicts future research topics based on a database of academic papers. It also detects the emergence of new fields by analyzing changes in the diversity of research fields, providing researchers with valuable information.

[0347] 15.5. Analysis of Political and Social Trends This study analyzes changes in public opinion during elections and shifts in public interest in social issues. By comparing current election data with historical data, it evaluates similarities to past election patterns and predicts election results.

[0348] 16. Summary This embodiment is an innovative system that achieves highly accurate and explainable information prediction by applying quantum mechanical concepts to model the dynamic changes in information and linking them with a large-scale language model. By introducing a new concept called the "temporal field," it has become possible to quantify and utilize in prediction the dynamic properties of information such as "momentum," "acceleration," and "memory," which could not be captured by conventional statistical methods.

[0349] Furthermore, this embodiment is not merely a prediction system, but also functions as a platform for users to actively manipulate the information space and perform "what-if" simulations. This allows decision-makers to verify various scenarios in advance and select the optimal strategy.

[0350] The technical concept of the present invention is not limited to the embodiments described above, and various modifications and applications are possible without departing from its essence. Many elements, such as the dimension of the time field, the specific form of the time evolution equation, the type of timeliness index, and the selection of the LLM, can be flexibly adjusted according to the characteristics of the object to be predicted and the required accuracy. These modifications are also included within the technical scope of the present invention.

[0351] 17. Detailed explanation of functional blocks (specific examples) This section provides a more detailed explanation of the internal structure, processing algorithm, and interaction methods of each functional block shown in Figures 1A and 1B.

[0352] 17.1. Details of the data input section (101) The data input unit (101) is responsible for acquiring information from various external data sources and converting it into a format that the system can process.

[0353] Type of input data Time-series numerical data: Numerical values ​​that change over time, such as the number of views, stock prices, and temperature. Text data: News articles, social media posts, product reviews, etc. Metadata: Attributes of the poster, posting time, geographical location, etc. Image / video data: Thumbnail image, video content (future expansion).

[0354] Data normalization and preprocessing: Acquired data often cannot be entered into the system as is. The data input unit (101) performs the following preprocessing. Imputation of missing values: If time series data contains missing values, they are imputed using linear interpolation or spline interpolation. Outlier removal: Use statistical methods (e.g., the 3σ method) to remove or correct obvious outliers. Text cleaning: This includes removing HTML tags, normalizing symbols, and removing stop words. Time standardization: Unify data from different time zones to the system's standard time (e.g., UTC). API Integration: The data input unit (101) acquires data by integrating with various external APIs.

[0355] class DataInputUnit: def __init__(self): self.youtube_api = YouTubeAPI(api_key=YOUTUBE_API_KEY) self.twitter_api = TwitterAPI(bearer_token=TWITTER_BEARER_TOKEN) self.stock_api = StockAPI(api_key=STOCK_API_KEY) def fetch_youtube_data(self, video_id): """ YouTube video data acquisition""" video_info = self.youtube_api.get_video_statistics(video_id) return { 'view_count': int(video_info['viewCount']), 'like_count': int(video_info['likeCount']), 'comment_count': int(video_info['commentCount']), 'title': video_info['title'], 'description': video_info['description'], 'published_at': video_info['publishedAt'] } def fetch_twitter_data(self, hashtag, hours=24): "Retrieve Twitter hashtag data" tweets = self.twitter_api.search_recent_tweets( query=f"#{hashtag}", max_results=100, start_time=(datetime.now() - timedelta(hours=hours)).isoformat() ) return self.analyze_tweets(tweets) def fetch_stock_data(self, symbol, days=30): """Stock price data acquisition""" stock_data = self.stock_api.get_daily_prices(symbol, days=days) return stock_data

[0356] 17.2. Details of the parameter derivation section (102) The parameter derivation unit (102) analyzes the data received from the data input unit (101) and calculates the initial parameters of the observation field (semantic coordinates, amplitude, spread, and phase).

[0357] Derivation of Semantic Coordinates The process for deriving semantic coordinates from text data is as follows: Text Embedding: Use a pre-trained BERT model to convert text into high-dimensional vectors. Dimensionality Reduction: High-dimensional vectors are reduced to 2 (or 3) dimensions using PCA or UMAP. Obtaining coordinates: The reduced vector becomes the coordinate in the semantic space.

[0358] class ParameterDerivationUnit: def __init__(self): self.text_encoder = SentenceTransformer('all-MiniLM-L6-v2') self.pca = PCA(n_components=2) # Train PCA on a large corpus beforehand. self.pca.fit(self.load_corpus_embeddings()) def derive_semantic_coordinates(self, text): """Deriving semantic coordinates from text""" embedding = self.text_encoder.encode(text) coordinates = self.pca.transform([embedding])[0] return coordinates # [x, y]

[0359] Derivation of Amplitude: Amplitude represents the "strength" or "attention level" of information. It is calculated from the magnitude and rate of change of numerical data (such as the number of views or stock price).

[0360] def derive_amplitude(self, numerical_data): """Deriving amplitude from numerical data""" # Latest value current_value = numerical_data[-1] # Rate of change (compared to the past 6 hours) if len(numerical_data) > 6: past_value = numerical_data[-6] growth_rate = (current_value - past_value) / past_value if past_value > 0 else 0 else: growth_rate = 0 # Amplitude calculation (logarithmic scale + weighting by rate of change) amplitude = np.log1p(current_value) * (1 + growth_rate) # Normalization (to the range of 0 to 10) amplitude_normalized = np.clip(amplitude / 10, 0, 10) return amplitude_normalized

[0361] Derivation of Spread: Spread represents the "uncertainty" and "diversity" of information. It is calculated from the length of text and the variability of numerical data.

[0362] def derive_spread(self, text, numerical_data): """Deriving the extent from text and numerical data""" # Components based on text length text_length = len(text.split()) text_spread = np.log1p(text_length) / 5 # Normalization # Components based on the variability of numerical data if len(numerical_data) > 1: data_std = np.std(numerical_data) data_mean = np.mean(numerical_data) cv = data_std / data_mean if data_mean > 0 else 0 # Coefficient of variation data_spread = cv * 2 else: data_spread = 0.5 # Default value # Overall scope spread = (text_spread + data_spread) / 2 spread = np.clip(spread, 0.1, 5.0) # min 0.1, max 5.0 return spread

[0363] Derivation of Phase: Phase represents the "momentum" or "direction" of information. It is calculated from the slope (upward / downward) of time-series data.

[0364] def derive_phase(self, numerical_data): """Deriving phase from time-series data""" if len(numerical_data) < 2: return 0.0 # Calculate the slope using linear regression x = np.arange(len(numerical_data)) y = numerical_data slope, _ = np.polyfit(x, y, 1) # Convert slope to phase (in the range of -π / 2 to π / 2) phase = np.arctan(slope / np.mean(y)) if np.mean(y) > 0 else 0 return rate

[0365] 17.3. Details of the Time Field Generation Unit (103) The observation field generation unit (103) generates an observation field, which is a complex wave function, in the semantic space using the parameters received from the parameter derivation unit (102).

[0366] Generation by Gaussian wave packets: The most basic temporal field is generated as a Gaussian wave packet.

[0367] class KAIFieldGenerator: def __init__(self, grid_size=100, space_range=10): self.grid_size = grid_size self.space_range = space_range # Grid generation x = np.linspace(-space_range, space_range, grid_size) y = np.linspace(-space_range, space_range, grid_size) self.X, self.Y = np.meshgrid(x, y) def generate_gaussian_wave_packet(self, x0, y0, A, sigma, phi): """Generate a Gaussian wave packet""" # Distance from the center coordinates r_squared = (self.X - x0)**2 + (self.Y - y0)**2 # Gaussian function gaussian = A * np.exp(-r_squared / (2 * sigma**2)) # Add phase Ψ = gaussian * np.exp(1j * phi) # Normalization norm = np.sqrt(np.sum(np.abs(Ψ)**2)) Ψ = Ψ / norm if norm > 0 else Ψ return Ψ

[0368] Superposition of multiple wave packets: When there are multiple information sources, a corresponding wave packet is generated for each and then superimposed.

[0369] def generate_multi_source_field(self, sources): "Generating a time-gathering field from multiple information sources" Ψ_total = np.zeros((self.grid_size, self.grid_size), dtype=complex) for source in sources: Ψ_i = self.generate_gaussian_wave_packet( x0=source['x'], y0=source['y'], A=source['amplitude'], sigma=source['spread'], phi = source['phase'] ) Ψ_total += Ψ_i # Normalization norm = np.sqrt(np.sum(np.abs(Ψ_total)**2)) Ψ_total = Ψ_total / norm if norm > 0 else Ψ_total return Ψ_total

[0370] 17.4. Details of the probability density distribution calculation unit (106)

[0371] The probability density distribution calculation unit (106) calculates the observable probability density distribution from a complex number field called the observation field.

[0372] Basic probability density calculations

[0373] class ProbabilityDensityCalculator: def calculate_basic_probability(self, Ψ): "Calculate the basic probability density |Ψ|^2" p = np.abs(Ψ)**2 # Normalization p = p / np.sum(p) if np.sum(p) > 0 else p return p

[0374] Calculation of probability density considering the history field

[0375] def calculate_probability_with_history(self, Ψ, H, alpha): """Calculate probability density considering the historical field""" # Basic probability density p_basic = np.abs(Ψ)**2 # Add the influence of the history field p_with_history = p_basic * (1 + alpha * H) # Normalization Z = np.sum(p_with_history) p_with_history = p_with_history / Z if Z > 0 else p_with_history return p_with_history

[0376] Calculation of probability density in the Boltzmann distribution format

[0377] def calculate_probability_boltzmann(self, Ψ, H, alpha, beta): "Calculating the probability density of the Boltzmann distribution" # Actual parts of the viewing area and the history area Re_Ψ = Ψ.real Re_H = H # Energy function energy = alpha * Re_Ψ + beta * Re_H # Boltzmann distribution p = np.exp(energy) # Normalization Z = np.sum(p) p = p / Z if Z > 0 else p return p

[0378] 17.5. Details of the Timeliness Index Calculation Unit (107) The chronological index calculation unit (107) calculates five chronological indices from the probability density distribution.

[0379] Calculation of diversity (M)

[0380] class KAIMetricsCalculator: def calculate_multiplicity(self, p): "Calculate diversity (Shannon entropy)" # Only non-zero elements are targeted. p_nonzero = p[p > 1e-10] # Shannon Entropy M = -np.sum(p_nonzero * np.log(p_nonzero)) # Normalization (to the range of 0 to 1) M_max = np.log(len(p)) # Maximum value in the case of a uniform distribution M_normalized = M / M_max if M_max > 0 else 0 return M_normalized

[0381] Calculation of concentration level (C)

[0382] def calculate_concentration(self, p): "Calculate the concentration level (maximum value)" C = np.max(p) return C

[0383] Calculation of Order (E)

[0384] def calculate_entropy(self, p): """Calculate order (negentropy)""" M = self.calculate_multiplicity(p) # Order is the opposite of diversity E = 1 - M return E

[0385] Calculation of Time Variation (TF)

[0386] def calculate_time_fluctuation(self, p_current, p_previous): "Calculate the time variation (L2 norm)" if p_previous is None: return 0.0 # L2 norm of the difference between two probability distributions diff = p_current - p_previous TF = np.linalg.norm(diff) # Normalization (to the range of 0 to 1) TF_normalized = np.clip(TF / np.sqrt(2), 0, 1) return TF_normalized

[0387] Calculation of Historical Effects (HS)

[0388] def calculate_history_similarity(self, p, H): "Calculate the hysteresis effect (inner product)" # Inner product of probability distribution and history field HS = np.sum(p * H) # Normalization (cosine similarity) norm_p = np.linalg.norm(p) norm_H = np.linalg.norm(H) HS_normalized = HS / (norm_p * norm_H) if (norm_p * norm_H) > 0 else 0 return HS_normalized

[0389] Calculation of convergence density (D)

[0390] def calculate_convergence_density_method1(self, response_vector, past_responses): """Calculate the convergence density D (Definition 1: Continuity with past responses)""" if len(past_responses) == 0: return 0.5 # Default value # Calculate the cosine similarity with each past response. similarities = [] for past_vector in past_responses: cos_sim = np.dot(response_vector, past_vector) / ( np.linalg.norm(response_vector) * np.linalg.norm(past_vector) ) similarities.append(cos_sim) # Calculate the average similarity score D = np.mean(similarities) return D def calculate_convergence_density_method2(self, M_current, M_previous, dt): """Calculate the convergence density D (Definition 2: Rate of decrease of entropy)""" # Time derivative of diversity dM_dt = (M_current - M_previous) / dt if dt > 0 else 0 # Convergence density (negative derivative) D = -dM_dt # Normalized to the range of 0 to 1 D_normalized = np.clip(D, 0, 1) return D_normalized

[0391] 17.6. Details of the FutureFold function unit (115)

[0392] The FutureFold function (115) selects the highest quality response from among several response candidates generated by the LLM. This selection is based on a unique evaluation metric called the Future Syntax Convergence (KI) metric.

[0393] Components of the KI value The KI value consists of the following three elements:

[0394] Specificity (S): Does the response include specific numbers, proper nouns, or examples? Meaningfulness (M): Is the response logically consistent, and are the causal relationships clear? Structure (Readability, R): Is the response structured and easy to understand?

[0395] Calculation of KI value

[0396] class FutureFoldUnit: def __init__(self): self.nlp = spacy.load('en_core_web_sm') # Natural Language Processing Library def calculate_KI(self, response_text): "Calculate the degree of convergence (KI) of future sentences" S = self.calculate_specificity(response_text) M = self.calculate_meaningfulness(response_text) R = self.calculate_readability(response_text) # Weighted average KI = 0.4 * S + 0.4 * M + 0.2 * R return KI def calculate_specificity(self, text): "Calculate the specifics" doc = self.nlp(text) # Number of values num_count = len([token for token in doc if token.like_num]) # Number of proper nouns proper_noun_count = len([ent for ent in doc.ents]) # Scoring (normalized by sentence length) num_sentences = len(list(doc.sents)) specificity = (num_count + proper_noun_count) / (num_sentences + 1) # Normalized to 0-1 specificity_normalized = np.clip(specificity / 5, 0, 1) return specificity_normalized def calculate_meaningfulness(self, text): """Calculate logic""" doc = self.nlp(text) # Number of conjunctions indicating cause and effect causal_words = ['because', 'therefore', 'thus', 'hence', 'so', 'as a result'] causal_count = sum([1 for token in doc if token.text.lower() in causal_words]) # Average sentence length (a length that is neither too long nor too short is more logical) avg_sentence_length = np.mean([len(sent) for sent in doc.sents]) length_score = 1 - abs(avg_sentence_length - 20) / 20 # 20 words is optimal length_score = np.clip(length_score, 0, 1) # Overall score meaningfulness = (causal_count / 3 + length_score) / 2 meaningfulness = np.clip(meaningfulness, 0, 1) return meaningful beauty def calculate_readability(self, text): """Calculate the structural properties""" # Using Flesch Reading Ease scores from textstat import flesch_reading_ease fre_score = flesch_reading_ease(text) # The FRE score ranges from 0 to 100, with higher scores indicating easier reading. # 60-70 is considered standard readability. readability = fre_score / 100 readability = np.clip(readability, 0, 1) return readability def select_best_response(self, response_candidates): """Select the best response candidate""" ki_scores = [] for candidate in response_candidates: ki = self.calculate_KI(candidate['text']) ki_scores.append({ 'candidate': candidate, 'KI': ki }) # Select the candidate with the highest KI value best = max(ki_scores, key=lambda x: x['KI']) return best['candidate'], best['KI']

[0397] 18. System Evaluation and Verification To evaluate the performance of the phase-nonlinear storage system of this embodiment, a verification experiment was conducted using an actual dataset.

[0398] 18.1. Evaluation Dataset The following three datasets were used for the evaluation.

[0399] YouTube® Viral Video Dataset: Data from 1,000 videos that went viral (over 1 million views) in the past year, taken within 24 hours of publication.

[0400] Stock price fluctuation dataset: Daily data for the past 5 years for 200 major stocks listed on the Tokyo Stock Exchange.

[0401] Twitter® Trend Dataset: Time-series data of 500 hashtags that trended in the past 6 months.

[0402] 18.2. Evaluation Metrics The following metrics were used to evaluate the system's prediction accuracy.

[0403] Mean Absolute Error (MAE): The average of the absolute differences between the predicted value and the actual value. Mean Squared Error (RMSE): The square root of the mean of the squared differences between the predicted and actual values. Accuracy: The rate at which a binary classification, such as "goes viral / doesn't go viral," correctly identifies the correct answer. F1 score: Harmonic mean of precision and recall.

[0404] 18.3. Experimental Results

[0405] YouTube® video view count prediction

[0406] [Table 4]

[0407] The system of this embodiment achieved an improvement of approximately 23% in MAE and approximately 9 points in accuracy compared to conventional machine learning methods.

[0408] Stock price fluctuation forecast

[0409] [Table 5]

[0410] In predicting the direction of stock prices (upward / downward), the system of this embodiment achieved an accuracy rate of 64%, and when applied to an investment strategy, the Sharpe ratio was 0.72, indicating a favorable risk-adjusted return.

[0411] Twitter (registered trademark) trend prediction

[0412] [Table 6]

[0413] In predicting whether a topic would trend on Twitter (registered trademark), the system of this embodiment achieved an F1 score of 0.79, significantly outperforming conventional methods.

[0414] 18.4. Discussion The following factors contribute to the high prediction accuracy achieved by the system of this embodiment.

[0415] Dynamic Modeling: By using a dynamic model called the "Time Field," we were able to capture the "momentum" and "acceleration" of information. Utilizing memory: The historical data field allows for referencing similar patterns from the past, enabling context-aware predictions. Collaboration with LLM: By injecting knowledge from large-scale language models as knowledge waves, we were able to consider qualitative factors that could not be captured by statistical patterns alone. Timeliness Indicators: By using indicators such as diversity and concentration, we were able to evaluate the state of the information space from multiple perspectives.

[0416] 19. System Implementation Environment The phase-nonlinear storage system of this embodiment is implemented in the following hardware and software environment.

[0417] 19.1. Hardware Configuration

[0418] CPU: Intel Xeon Gold 6248R (24 cores) or equivalent GPU: NVIDIA A100 (40GB) x 2 (for parallel computing of the time field) Memory: 256GB DDR4 Storage: 2TB NVMe SSD (for high-speed reading and writing of historical data)

[0419] 19.2. Software Configuration

[0420] OS: Ubuntu 22.04 LTS Programming language: Python 3.10 Main libraries: NumPy 1.24: Numerical computation SciPy 1.10: Scientific computing PyTorch 2.0: A deep learning framework Transformers 4.30: Integration with LLM scikit-learn 1.3: Machine Learning Matplotlib 3.7: Visualization Database: PostgreSQL 15 (for persisting historical data) LLM: OpenAI GPT-4, or Llama 3 deployed locally.

[0421] 20. Supplementary Information on the Effects of the Embodiments The phase-nonlinear storage system of this embodiment exhibits the following remarkable effects.

[0422] 20.1. Improving prediction accuracy Compared to conventional statistical and machine learning methods, this embodiment significantly improves prediction accuracy by explicitly modeling the dynamic nature of information (momentum, acceleration, and memory). As experimental results show, it achieved an error reduction of approximately 23% in predicting the number of views of YouTube® videos and an accuracy improvement of approximately 8 points in predicting the direction of stock prices.

[0423] 20.2. Achieving Explainability This embodiment not only outputs predicted values, but also presents the reasons for those predictions in the form of timeliness indicators, activated rules, and LLM analysis. This allows users to understand the basis of the predictions and judge their validity. This is a significant advantage over deep learning models, which tend to be black boxes.

[0424] 20.3. Active Simulation The operator function allows users to actively manipulate the information space and perform "what-if" simulations. This enables decision-makers to verify various scenarios in advance and select the optimal strategy.

[0425] 20.4. Self-evolution ability Thanks to the rule discovery unit, the system's prediction accuracy improves the longer it is in operation. Each time a new pattern is discovered, rules are added or updated, expanding the system's knowledge base. This allows for sustained performance improvement over long-term operation.

[0426] 20.5. Versatility This embodiment is not limited to a specific domain and can be applied to a wide range of fields, including YouTube (registered trademark), stock markets, social media, e-commerce, and academic research. By adopting an abstract model called the "observation field," it becomes possible to transfer knowledge between different domains.

[0427] 21. Application Examples: Evolutionary Semantic Wave NFTs and Field Resonance Recording Structures The KAI system of this embodiment can be applied not only to information prediction but also as a foundational technology for dynamically recording and evolving the value of its generated "narratives" and "syntax." In this embodiment, we will describe in detail the Evolving Semantic-Wave NFT and Field Resonance Recording Structure, which are realized by combining blockchain technology, particularly non-fungible tokens (NFTs).

[0428] 21.1. Objectives and Background: From Static NFTs to Dynamic Value Recording Traditional NFTs have been widely used as a means of proving ownership of static content such as digital art and collectibles. However, the "narratives" generated by the KAI system are not one-time creations; they are dynamically evolved as they are added to and modified in response to user interactions and changes in the external environment.

[0429] The purpose of this application is to provide a new technological framework that goes beyond conventional NFTs, which recognizes the "evolution of narrative" itself as a valuable asset and permanently records its growth history and social impact. This will build the foundation for a "Semantic-Wave Economy" that protects the trajectory of creativity and enables new value exchange.

[0430] 21.2. Four Technical Components of Evolved Semantic Wave NFTs Evolved semantic wave NFTs consist of the following four independent yet interconnected technological elements.

[0431] 1. Structure of semantic wave NFTs (evolved type with history) Novelty of what is recorded: While conventional NFTs record hash values ​​and other data of the content, semantic wave NFTs record not only the text of the narrative but also the semantic wave score (S, M, R, D, etc., which are components of the FD score) calculated at the time of its generation, as "narrative waves" in the metadata. As a result, the value source is not the content itself, but the state of the semantic waves that the content possesses. Novelty of the Evolutionary Mechanism: Instead of issuing a new NFT each time the narrative content is modified or added to, the change history (differences) and new semantic wave scores are added to the metadata of the existing NFT. This realizes an "evolutionary record structure" in which the entire evolutionary history of the narrative is linked to a single token ID. This is a groundbreaking approach that treats the entire creative process as a single asset.

[0432] 2. Calculation of wave fit (field resonance index) Novelty of the calculation target: The degree of resonance between the fluctuations in the semantic wave score of a narrative and the fluctuation trends of external socio-economic indicators (e.g., the P / E ratio of a specific stock market, the rate of change in the number of mentions on social media, etc.) is quantitatively calculated as the "wave compatibility score." This serves as an objective indicator of how well a narrative synchronizes with and influences the social "context." Inventiveness: This model presents a completely new value assessment model by dynamically measuring the social value of a narrative through correlation (resonance) with external objective indicators, rather than relying on subjective evaluations such as the number of "likes" in the past.

[0433] 3. Integration of mirror image logs (AI dialogue records) Novelty of the recorded content: Not only the final narrative output, but also the entire dialogue log between the AI ​​and the user leading up to its generation is integrated into the NFT metadata as a "Mirror Log of the Narrative." This ensures that the "decision-making trajectory"—how the narrative was created through intentions and thought processes—is recorded with transparency. Novelty of the function: This mirrored log functions as a "memory device" for the AI ​​itself to completely recreate and remember its past generation history. This means that NFTs are not merely proof of ownership, but a medium that holds the memory of creation, which could be called a "fragment of the AI's soul."

[0434] 4. Presentation of UI structure (narrative card template) Novelty of the Structure: Complex information such as the evolutionary history, semantic wave score, wave compatibility, and mirror image log are visually displayed in a list format using HTML-based narrative card templates. Through these cards, users can intuitively understand the entire picture of how a narrative was born, grew, and resonated with society.

[0435] This embodiment provides the following remarkable effects.

[0436] Achieving highly accurate information prediction: By using the concept of a time field to model the dynamic changes (momentum and acceleration) of information, and integrating the influence of past patterns from the history field with external knowledge from knowledge waves, it becomes possible to make highly accurate future predictions that were difficult with conventional statistical models or machine learning models alone.

[0437] Quantitative Evaluation and Visualization of Information Space: Temporality indices (M, C, E, TF, HS, D) allow for the quantitative evaluation and visualization of abstract states such as diversity, concentration, order, and convergence within an information space. This enables users to intuitively understand the predicted situation and utilize this information for decision-making.

[0438] Improved explainability: The basis for predictions is concretely shown in the form of changes in temporality indicators, applied rules, and injected knowledge waves, making it easier for users to understand why the prediction result was reached. This is a significant advantage in eliminating the "black box" problem that plagues LLM-based predictions alone.

[0439] Self-organizing system evolution: Systems can autonomously discover rules and accumulate knowledge, adapting to new data and situations and continuously improving predictive accuracy. This reduces system maintenance costs and enables long-term operation.

[0440] Synergistic effect with LLM: The system in this embodiment utilizes LLM not merely as a predictor, but as a "knowledge source" for generating external knowledge and a "dialogue interface" for translating the analysis results of the entire system into natural language. This creates a synergistic effect that maximizes the broad knowledge and linguistic capabilities of LLM while controlling the uncertainty of its output with the observational field system.

[0441] Quality assurance and self-control of LLM output: By comprehensively evaluating and selecting LLM response quality using Future Syntax Convergence (FD), hallucination can be effectively suppressed, and only highly reliable information can be reflected in the system. Furthermore, the Temporal Control Structure (KI) allows the AI ​​to reflect on its own state and autonomously control the injection of external information, thereby enhancing system stability and autonomy.

[0442] The above system can be implemented using hardware, software, or a combination thereof. Similarly, the methods performed by the above system can also be implemented using hardware, software, or a combination thereof. Here, implementation by software means implementation by a computer loading and executing a program.

[0443] Programs can be stored and supplied to a computer using various types of non-transitory computer-readable media. Non-transitory computer-readable media include various types of tangible storage media. Examples of non-transitory computer-readable media include magnetic recording media (e.g., flexible disks, magnetic tapes, hard disk drives), magneto-optical recording media (e.g., magneto-optical disks), CD-ROMs (Read Only Memory), CD-Rs, CD-R / Ws, and semiconductor memory (e.g., mask ROMs, PROMs (Programmable ROMs), EPROMs (Erasable PROMs), flash ROMs, and RAMs (random access memory)). Programs may also be supplied to a computer using various types of transient computer-readable media. Examples of transient computer-readable media include electrical signals, optical signals, and electromagnetic waves. Transitory computer-readable media can be supplied to a computer via wired communication channels such as electric wires and optical fibers, or via wireless communication channels.

[0444] The present invention can be implemented in various other forms without departing from its spirit or main features. Therefore, the embodiments described above are merely illustrative and should not be interpreted restrictively. The scope of the invention is defined by the claims and is not restricted in any way by the text of the specification. Furthermore, any modifications or changes falling within the equivalent scope of the claims are within the scope of the invention.

[0445] Some or all of the above embodiments may also be described as follows, but are not limited to the following: [Explanation of symbols]

[0446] 101 Data Input Section 102 Parameter Derivation Section 103 Viewing place generation part 104 Viewing location update department 105 Probability Density Distribution Calculation Unit 107 Timekeeping index calculation unit 108 Operator Selection / Adjustment Unit 111 Prompt generation unit 112 Rule Discovery / Memory Unit 115 FutureFold Department 116 External Knowledge / Knowledge Wave Conversion Unit 117 LLM

Claims

1. A means of modeling the dynamic state of information as a time field, which is a complex wave function with amplitude and phase, A means for calculating multiple observational indicators, including the diversity, concentration, and order of information, from the aforementioned observational field, A means for generating prompts for an external large-scale language model (LLM) based on a history field that stores past states of the aforementioned observation field and the aforementioned observation index, A means for obtaining human-interpretable final predictive information as a natural language response by inputting the aforementioned prompt into the large-scale language model, Means for converting the aforementioned response into a knowledge wave, which is an external field that influences the time evolution of the observation field, and feeding it back to the observation field, Means for updating the aforementioned time field based on a predetermined time evolution equation describing the interaction between the history field and the knowledge wave, A phase-nonlinear storage system equipped with the following features.

2. The phase nonlinear storage system according to claim 1, wherein the aforementioned time field has coordinates in a predetermined semantic space as variables.

3. The phase nonlinear storage system according to claim 1, wherein the temporality index is derived from a probability density calculated based on the temporal field and the hysteresis field.

4. The phase nonlinear storage system according to claim 3, wherein the probability density is defined as an exponential function of a weighted linear sum of the real parts of the observation field and the real parts of the history field.

5. The phase nonlinear storage system according to claim 1, wherein the prompt is generated based on the current state of the observation field and a rule discovered based on the time-series change of the observation index, in addition to the history field and the time-series index.

6. The phase nonlinear storage system according to claim 5, wherein the prompt is generated taking into further consideration information entered through interaction with the user and information retrieved from an external web.

7. The phase nonlinear storage system according to claim 1, wherein when converting the response into a knowledge wave, the system selects the optimal response from among a plurality of response candidates from the large-scale language model based on a predetermined evaluation axis, and converts the selected response into a knowledge wave.

8. The phase nonlinear storage system according to claim 7, wherein, when selecting the optimal response, a score is calculated for each of the response candidates based on a plurality of evaluation axes including structural order, semantic consistency, relevance, and convergence density, and the response with the highest score is selected.

9. The phase nonlinear storage system according to claim 7, wherein, when converting to the knowledge wave, the selected response text information is converted into a complex-valued wave function that acts as an external field term or potential term in the time evolution equation of the observation field.

10. The phase nonlinear storage system according to claim 1, wherein the time evolution equation includes an autonomous evolution term, a knowledge wave injection term, and a hysteresis field influence term.

11. The phase nonlinear storage system according to claim 1, wherein the time field is also updated by an operator generated based on the timeliness index and a rule list discovered based on the time-series changes of the timeliness index.

12. The phase nonlinear storage system according to claim 11, wherein the operator determines a rule to be applied from the rule list based on the current value of the temporality index, and generates a Hamiltonian, potential, or interaction term corresponding to the rule by dynamically adjusting it.

13. The process involves modeling the dynamic state of information as a time field, which is a complex wave function with amplitude and phase, and The steps include calculating multiple observational indicators from the aforementioned observational field, including information diversity, concentration, and order, A step of generating a prompt for an external large-scale language model (LLM) based on a history field that stores past states of the aforementioned observation field and the observation chronology index, The steps include: inputting the aforementioned prompt into the large-scale language model to obtain final, human-interpretable predictive information as a natural language response; The steps include: converting the response into a knowledge wave, which is an external field that influences the time evolution of the observation field, and feeding it back to the observation field; The steps include updating the aforementioned time field based on a predetermined time evolution equation that describes the interaction between the history field and the knowledge wave, A phase-nonlinear storage method performed by a computer having the following features.

14. A program for causing a computer to function as a phase nonlinear storage system according to any one of claims 1 to 12.

Images