How to memorize logical word problems

My question ultimately comes down to this: Does anybody know how to build an extensible memory palace that allows you to memorize items, and then place other items between those items up to a fairly reasonable degree of nestedness?

I want to use this method to rapidly (and temporarily) memorize logical word problems. Logical word problems usually include a combination of ordering relations, equivalences and opposites.

For example,

A, B, C, D are quarreling quadruplets. If A goes to the party, then B will not go. If C goes to the party, then B will not go. What is the largest possible number that will go to the party?

The actual problem usually does not contain that much explicit information. However, the way to solve this problem is to work out a sequence of implications and keep track of them. In this case, we reason that:
(1) B will only go if A and C do not go.
(2) If B goes, at most B and D can go. (memorize this one)
(3) If B does not go, then A, C and D can go (memorize this one)
(4) B and D is less than A, C and D, so (3) allows the most people to go.
(5) (recalling and counting the number of items in (3)) At most, 3 people can go.

Other problems are just long disjointed lists of ordering relations such as “Sally is taller than Jane”, or “If x then y” with a question at the end. The trick is to be able to memorize and manipulate the list of relations in order to compose them. You basically have to be able to place each person or item in a line in your head, and then answer questions using the transitivity of the given relations.

I know a lot of mneumonists are good at memorizing static information that you can recite in the order it was originally given, but I don’t know of any system that allows you to place items in an order and then easily go back and insert new items between those items. Does anybody have any advice on how to do this?

Different approach

You could for example have
x = colored stick_man(maybe in 3d)
A = red x
B = yellow x
C = blue x
D = green x

Function : When B is present while A or C is present it loses color => invalid.

Result: some visuo spatial manipulation of ordering and you instantly see that there is a scope that you can verify quite quickly.

Issue: What if you have much more data? In one way or another you will need to chunk this data, which memory palaces do great but this may result in some new mechanics for referencing information overall, perhaps a search of some sort.

Point of this example:
For one it is a different approach, because while there are clearly logically optimal approaches, the brain itself can run very uniquely.
Images are very good at modelling concrete things that exist, but not so much on abstract pieces. Any kind of transformation or manipulation, what may be considered a function of some sort, is relatively easy to manipulate with movement in a memory palace. You will need to represent some kind of abstract point by either using your own language system if you have one or by using something that is very memorable for that particular point.

That said:

The key here being nested-ness, just as you can normally do h(x) -> f(g(x)) and you can associate anything to anything else, you could just associate an object to a location traversal, or a location to different location traversal based on some condition. There is no reason why you couldn’t for example add a door into your memory palace rather than an actual object, and use that door for moving to a different location.

The main issue with this is that you may not be comfortable with modifying your location if you are not used to building imaginary memory palaces.

As ghost images exist, it is not very reasonable to reuse the location if you are planning to store it for longer than temporarily;it would be more sensible for example to copy the data to a new location or use a new location as an extension. Furthermore, you would likely be using active transformations of objects in the location rather than any removing and adding for the same reason (if not a new one), both dependent to a different extent on how long exactly you want to keep this information and how much information it is. If you really want to insert and remove things in a location without using an existing one, it is best to overwrite the object in my opinion (rather than ignore it).

So quite literally, to build an extensible memory palace you should simply extend it at different points abusing the fact that you can associate anything to anything else. To make better use of how memory works, it then is sensible to not over-reuse a location because you are not completely in control of your ability to forget things (unless you somehow are).


Thanks for the reply. I’m aware of this method, but I’m running into a problem that is peculiar to ordering relations and logical implications when I try to use it. I need to be able to place an item “between” two other items without “concealing” subitems beneath layers of associations. That is, I need to be able to add a new loci without attaching it to a “door” at a given loci so that I end up with one flat sequence of objects. Traversing levels interferes with the ability to actually see how items are placed with respect to one another. Is there a way to “flatten” such a nested structure? Or else, is there another journey method that admits easily placing new lines between old ones?

The issue with this is that you may end up with 1000 items in one flat sequence, which will regardless, impede your ability to actually see how items are placed with respect to one another. The end result is that this is then no different than branching off to another location. You can however loop across the location in patterned form. By reactivating both locations alternatively you will be able to keep track of the different objects. Instead of thinking about a location of being active in view, you can create a new kind of data structure which is dynamically active, simply because it can deal with working memory limitations.

You can always use a multi display of the locations. If you have 3 locations you can just picture them as one, this may take a bit of practice but it doesn’t handle the working memory issue with 1000 objects. It does however effectively flatten nested structures.

Let me put it this way, I once tried picturing statements(sentences) of objects in detail on full view (without alternating). When I managed to get to 11 such detailed statements, I fainted.