Well, same thing again. I think there’s a parallel with what I did. Only you are evaluating “truth” values, whereas I evaluated sequence predictions.
In my system, to try to build a parallel with yours, you might have a question whether AX is a valid sequence in the language:
(AX?)
The system doesn’t know, so it “spits out” what it does know, which is that AB is an observed sequence.
(AX?, AB)
The system detects there’s no connection between X and B, so it “asks” if one can be found, and finds it in observed sequences (CX, CB):
(AX?, AB, CX, CB)
The system detects a link between X and B in the sense they share context in C, so it “collapses” X and B into a class which shares contexts, and allows AX on the basis that AB is observed, and X and B are observed to share context C.
I’m doing sequences, and you’re doing “truth” values, but I think it comes to the same thing. You’re chaining associations to build new sets.
“What happens” I think is that you’ll find you get contradictions between those sets of associations, and you’ll need to base the “collapse” mechanism on a balance of associations, not just one association, like “cat is a mammal”.
The utility depends on the utility of your association principle. But I do think there is value in chaining associations in new ways, because I think you DO get contradictions. And building sets of associations on the fly is the only way to capture contradictions, and to resolve them, by picking which of several contradictory sets of associations is relevant/“true” in a given situation.
What is crucial is the realization that the sets of associations you build will have contradictions. If you didn’t get contradictions, then you wouldn’t bother chaining associations at run-time, you’d just “learn” all the sets beforehand.
BTW, I think what transformers do (just to hammer back on my continual theme), is they “learn” as many such contradictory association sets as their compute budget will allow, and select the appropriate one using prompts at run time. But they hide the fact of contradictory sets in the black box of their network, so we don’t realize they are working as well as they do because they are capturing contradictory sets.
If you do get contradictory sets, the more efficient way to do it would be to accept you can get contradictory sets, and only build the ones you need at run time, through an association chaining mechanism, much as you describe.
The burden of proof for the utility of a real time association chaining mechanism such as you describe, would be whether sets of associations you can build, result in contradictory sets.