Cosmic
unread,Dec 6, 2024, 1:36:16 PM12/6/24Sign in to reply to author
Sign in to forward
You do not have permission to delete messages in this group
Either email addresses are anonymous for this group or you need the view member email addresses permission to view the original message
to Dual N-Back, Brain Training & Intelligence
Sorry for the messy punctuation :/
This may be used as a strategy, but it's better not to. If you are someone who does rrt, I recommend that you don't read this and instead focus on visualizing, or optimizing a strategy on your own while not utilizing it.
When speaking about first order conclusions(rather than one's composed from many conclusions like the ones in binary. btw this framework generalizes to them I just don't want to address them directly):
The process of relational reasoning is basically reducing the set of premises to a valid loop, this applies to all relational reasoning tasks and is quite interesting when it comes to the visualization part, which I'll expand upon later.
That being said, the process of verifying a conclusion in general reduces the premises as such:
Uncharacterized premises
(as in, they inhibit no characteristics, which means they may have internal contradictions. Syllogimous skips this part, tho it has some potentially interesting uses, such as empty sets.)
===>
non-contradicting premises
(which is the starting state for all the syllogimous tasks that don't start from a more refined point. their only characteristic being that they don't contain internal contradictions)
===>
semi-useful premises(they are basically all the premises that can be in the loop, yet may not be contained in it. (the loop as in the set containing only the premises necessary to support the conclusion), a clear example of this is how the "No is " premises have no value when dealing with an "All is " conclusion. which works due to the logic used being binary rather than tristate. A conclusion is either true or false. And when neither the conclusion nor its opposite are right, they both default to false rather than a third state.)
==>
Useful premises/pseudo-loop
(As in the set of premises that form
a chain that connects the two elements of the conclusion, all the other premises are irrelevant, the lack of this pseudo-loop is an automatic false due to the same aforementioned causes. Many syllogimous modes give this as the starting set of premises. there is not much to say here, besides that, they don't necessarily inhibit any reoccurring order. that being in variable's order (a>b, c<b, d<c) or the premise's direction relative to the way they're navigated, example: both (a>b, c>d, b>c) (a>b, d<c, b>c) are ordered in the sense they're navigated in)
==>
The loop(the set of all needed premises, mentally organized, ready to be evaluated)
(Their organization / order, is either established mentally through memory, or visually through the game presenting them in a certain way, such as syllogimous(2d/3d/spacetime/direction) literally giving you the loop(needed premises, in order) from the start lmao, in both v3&v4. Soamsy fixed this, yet there's still a flaw where the wrong conclusion is always the opposite of the right one in spatial based tasks, which makes you able to solve an n dimensional task using a single dimension. this is irrelevant to the current subject, but given that this is targeted towards developers, it's a fitting side note.)
=(Evaluation, which navigating a loop given conditions it must verify)=>
The conclusion.
uncharacterized premises
=>
non-contradicting premises
=>
semi-useful premises
=>
useful premises/pseudo-loop
=>
the loop
==(evaluation)==>
the conclusion
We humans do these in combos. The reason i specified this is because the logic of the tasks
makes such distinction.
In my case, it's done as such:
(uncharacterized premises, non-existent within syllogimous)
non-contradicting premises
[
=>
, through automatic visual filtering
]
semi-useful premises
[
=>
useful premises
=>
the loop
==(evaluation)==>
, all of these are done at once, the loop is being found, ordered, and in the same time evaluated, so that if any errors show up in any of the stages, the conclusion is wrong due to the inexistence of a loop that supports it.
]
the conclusion
(Verification requires doing this process once. Derivation requires doing it twice at most)
Acknowledging these stages is useful when making an rrt game, you can implement a loop finding to loop evaluation ratio, define what stage a task starts from, and create new tasks that stem from the same universal logic.
Also the loop finding to evaluating ratio is one of the most significant differences there is when comparing two different rrt games/tasks, syllogimous has some loop forming elements(even tho its not consistent in doing so. For some tasks, it's enforced. And for some, it's non-existent), while another game may give you the loop directly for you to evaluate.
Back to the visualization part. Utilizing this viewpoint turns the variables into vertices and premises into edges.
Those relations between the
variables define the task and its properties.
Finding a conclusion or verifying it, is but navigating this mental model starting from the first term of the conclusion to the last, which forms a literal loop.
A valid loop is a set of connections that connect both terms in a valid order of valid relations, the order can be established through inversing premises.
All A is B
All A is C
Can be written as
Some B is A
All A is C
Which implies that some some B is C.
Yet,
All A is B
All B is C
Can be written as
All A is B
Some B is C
Which doesn't mean that all some A is C.
This is all basic stuff, but when seen as a mind map, a premise/arrow of the type "some" can only exist once in a valid loop and must be positioned next to either ends.
This allows you to verify a "All is " conclusion rather than a "some is " conclusion if no "some" premises tie to either end. Which is implemented in the filtering stage.
So many patterns arise when seeing the relationships this way rather than spatially or verbally.
All of this basically allows you to formalize rrt mathematically.
Some of you may already know about all of this. And others may see it as useless.
Yet I am sharing it so that hopefully both a fully customizable rrt game and a fully customizable rrt task framework comes out. Which will help us see if rrt is even worth it lmao. Good luck to whoever is willing to implement this, and thank you.