Methods for branching information

Hi all,

I’m wondering if anyone can help me with techniques specific to memorising tree structures, where instead of normal sequential information, each point may branch into a number of sub-trees. My current understanding suggests that this would require a memory journey where branching data-points are stored at branching loci along my journey. If anyone can suggest a better suited technique or point me in the direction of some useful reading material, it’d be very much appreciated!

Apologies if this has been covered before, but I’ve only recently started learning about memory techniques. I couldn’t find anything searching the forum, but I suspect I’m not familiar with the correct terminology.

Thanks for your help!

If you don’t want your journeys to be organized like a tree, then I suggest you use portkeys (object which takes you from one locus to another locus [from “Harry Potter”]).

Let’s say I want to remember cat-like animals. I have"Family: Cats" written at the trunk. Now one branch goes to tiger, another to leopard, third to lion and so on. Now I visualize a journey where this trunk-cat-portkey takes me to leopard hanging on tree, then to lion sleeping among his herd and finally to tiger’s gave.
To make it more memorable, I can use pegs: I have picture for numbers 1-10. 1 could be a wand. 2 a swan. Now first the trunk-cat took me to leopard. I visualize leopard hanging on a wand instead of tree. And when I think of 1 (wand) I think of the place where I saw wand and trunk-cat at the same time: leopard’s tree. I remember that 2 (swan) and trunk-cat were at lion’s herd and so on.
Now tiger has many species, each on different leaf. The tiger in that cave becomes next portkey and takes me to the loci of the species. And so on.

That’s a very interesting idea, thanks r30!

Welcome Michael,

My MMP system allows you to build a tree structure. See:

You can always combine with other methods such as story/link/peg for additional flexibility.

Cheers

Gavino

Thank you Gavino! I’ve read through those threads and it seems your MMP system could be very close to what I’m looking for.

First of all, I must say that I like gavinos idea.
However, I guess the answer might depend on what kind of information you need to store in this way. Is it for instance likely that you will insert new information or not and what kind of branching structure does the tree have and so on. I have though a little about how data-structures from computer science could be used to create better memory palace structures, but haven’t really tried anything yet. Seen as you yourself studies computer science I guess you had similar thoughts when writing this post.

Hi! Just curious: Is there any reason for wanting a tree structure? As mentioned, seeing as you study CS, are you thinking of binary trees? Or nodes with arbitrary number of children? I think the idea of using CS knowledge to enhance memory palaces/journeys is very interesting:-)

Hi guys.

I had been wondering if tree structures could be represented with any specific system since, like you’ve both pointed out, they crop up in computer science but also in various ‘real-world’ data sets. I imagine having a computer science background has certainly influenced my approach!

To be a little more specific about the case I had in mind, I was wondering about chess opening theory. To explain for the unfamiliar, in chess, certain sequences of opening moves are considered better and top players analyse these to ever greater depths, finding improvements over older games. While in some of these variations playing with general principles is adequate, there exist some where moves must be more precise. I had been discussing with a some chess playing friends about the practicalities of modelling this if one were keen to simply memorise reams of opening theory (leaving aside the objections chess players would make to this amateurish approach to openings!). Having made a chess playing program as part of my undergraduate work, I had studied tree structures and wondered if the memory experts had an answer to this problem.

This leaves us with a data structure that typically alternates between large (what your opponent may play) and small (what you’d reply with) branching factors at each new node, but I feel that this feature would be best ignored to allow for a general case solution. Additionally, this tree structure would require the option of a much larger branching factor than a binary tree which makes our solution more broadly applicable. As for the nodes, the data would be stored would be quite simple, certainly not too tricky for traditional memory techniques i.e. just the move and perhaps some mental notes too. In terms of the option of updating the information, one would presume this would be a fairly rare occurrence if the initial tree were well made.

Understandably the structure I’m describing is likely to be prohibitively large for all but the most dedicated mnemonist; if we imagine an average branching factor of 5 (which is something of a guess on my part), to reach a depth of only 5 moves, we have nearly 4000 nodes. I was mostly curious about how one might set about this task.

I am also a chess player actually and did try an initial approach to memorizing chess openings a while ago. However, because of move reorderings it is somewhat like a tree, but with some move orderings leading to merging of branches. Unfortunately I can’t say that I have a system for making the branching elegantly, but rather stored everything sequentially and used pointers whenever a branching occurred. One can for instance insert the most common line sequentially and branch of the less common lines to avoid having to follow pointers all the time. The only good thing about this system is that you at least will have time to follow pointers if you play with long time controls. For this to work you must be able to go to a certain index, preferably without counting from the beginning. I think gavinos system works well for this since indexing is more or less built into the system.

However, I think that it would be difficult to get a tree-like structure without using something like pointers. I have memorized a subway map by simply branching the path I take in a memory palace, but I don’t think that would work at all for trees that have a bit more branching. Also, even memorizing a subway map in this way requires you to plan the paths you are going to take in your memory palace quite well in advance.

One workaround that is somewhat similar to using pointers, but not exactly is to write the tree as a sparse matrix and memorize that matrix. In the chess opening example this would mean that you could have something like this:
e4 c5 Nf3 d6 …
________ e6 …
_____ Nc3 …
__ e5 Nf3 …
_____ f4 …

So looking for an alternative move would mean going down and playing the main line from that position would mean following the row. You could also use a special image to indicate that a move reordering has occurred indicating that you must go backwards to find where the move reordering began.
However, what both this and the pointer solution suffer from is that search is only fast as long as you follow the main lines which could be a problem.

You’re right, pabergg. The transpositions would cause quite a significant issue. It was only after I wrote my last post that I realised using a tree-structure for this specific issue may not necessarily be the most efficient, particularly for a move by move repertoire. The time issue would certainly be noticeable in a quick play game, but as you say, in slower games it would not be so problematic.

I agree with your pointers approach. It seems to be analogous to the portkey and gavino’s system in broad terms. The matrix idea is certainly something I’ll have to think about a little more. If I come up with anything I’ll have to report back!

Thank you for your feedback!