From 1355dd88ba7e09827b5b78cd777ea0b289007d1c Mon Sep 17 00:00:00 2001 From: REllEK-IO Date: Tue, 17 Oct 2023 10:40:15 -0700 Subject: [PATCH] Additional citation --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index af990c7..54e16db 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ The inspiration for STRX was that of Redux and its origin via the FLUX design pa * [Unified Turing Machine](https://github.com/Phuire-Research/STRX/blob/main/The-Unified-Turing-Machine.md) - The governing concept for this entire framework. ## The Halting Problem -* [Video Citation: The requirement to stop within a behavior tree. Artificial Intelligence Summit @GDC 2016](https://youtube.com/clip/UgkxtZlIbvaMv0OUCJ5kJFiaUCjmEQCBD0C6?si=tkrAkvbpqByq096U) +* [Video Citation: The requirement to stop within a behavior tree. Artificial Intelligence Summit @GDC 2016 via Youtube](https://youtube.com/clip/UgkxtZlIbvaMv0OUCJ5kJFiaUCjmEQCBD0C6?si=tkrAkvbpqByq096U) Noting that in the clip above, the speaker is using behavior trees and the stopping term. Here within STRX, a behavior tree would be an ActionStrategy that is dispatched via a staged "Plan." What separates STRX from the approach above is that we are using the finite state machine pattern to avoid the use of the infinitely looping check of some observed value. In addition we are referring to this as halting. @@ -33,7 +33,7 @@ As the ability to halt within an intelligent system is the demonstration of its ## How STRX Solves this Problem Further the Unified Turing also accomplishes what has been considered to be an impossible to solve problem of the original theoretical Turing Machine. The halting problem, this is accomplished via the finite state machine pattern in conjunction with the new ActionStrategy pattern. This new pattern is capable of representing any calculation, but must be designed with a conclusion. Thus the finite state machine of STRX can perform any calculation and halts upon their conclusion. Noting that here we are using logic to solve this and utilizing a set of specified requirements to have said solution. The primary requirement to satisfy the solution is that the main run time of a program, must be a recursive function. The ActionStrategy pattern in addition satisfies the next requirement, via being a specific set of instruction that concludes, but is capable of a branching behavior that affords for error correction. The specific interest in presenting this solution at this time is to demonstrate a method of safety as to disallow some run away effect from an Artificial Intelligence or Neural Network. -As this pattern of halting is designed to be an analog to the inner workings of some graph network that eventually has some output. This is noting that previous to 2023, one of the major problem behind LLMs is whether they would have an output due to some input. [Video Citation: QLoRA is all you need @sentdex](https://youtube.com/clip/Ugkx47h3s4gtOSrKxF-CdqsnTrPTWwnwwha8?si=VLQJSBoZDw0dYsCF) That we may compare the runtime of an ActionStrategy to a Neural Network, would represent a series of weighted sums that fails to halt in aggregate and bears no output, or a repeating output. In addition this likewise demonstrates a method of proving safe functionality of any new Ai systems in their ability to halt. As if we task some Ai to create paperclips, how would we analyze their strategies to demonstrate that they would not paperclip the entire universe? That their strategies should be proven to be able to halt once some condition is met. +As this pattern of halting is designed to be an analog to the inner workings of some graph network that eventually has some output. This is noting that previous to 2023, one of the major problem behind LLMs is whether they would have an output due to some input. [Video Citation: QLoRA is all you need @sentdex via Youtube](https://youtube.com/clip/Ugkx47h3s4gtOSrKxF-CdqsnTrPTWwnwwha8?si=VLQJSBoZDw0dYsCF) That we may compare the runtime of an ActionStrategy to a Neural Network, would represent a series of weighted sums that fails to halt in aggregate and bears no output, or a repeating output. [LLM Infinite Loops & Failure Modes: The Current State of LLM Extraction @GDELT via Medium](https://blog.gdeltproject.org/llm-infinite-loops-failure-modes-the-current-state-of-llm-entity-extraction/) In addition this likewise demonstrates a method of proving safe functionality of any new Ai systems in their ability to halt. As if we task some Ai to create paperclips, how would we analyze their strategies to demonstrate that they would not paperclip the entire universe? That their strategies should be proven to be able to halt once some condition is met. Likewise the unfortunate truth of a Unified Turing Machine due to its recursive functionality. Is that it requires the ability to halt to function as a hard requirement. Otherwise the developer will run into unexpected behavior in their applications. This would be due to strategies and/or the supporting framework are halting incomplete and experiencing action overflow. As our general good enough computers and their branch prediction will generate ghost actions and other unexpected behaviors during this condition. Such as the thrashing the applications memory, and the inability to receive some output akin to a unresponsive Neural Network. So by strange effect the solution to solve the halting problem, was a method of programming that went beyond data entry of classic. Utilizing logic over mathematics to create the scope of this framework, to afford for the dynamic functionality of data transformation versus data entry.