The Zettelkasten as a Lattice of Thought Strings

edited September 2019

The Zettelkasten as a Lattice of Thought Strings

The Zettelkasten note-taking method has made book writing and writing scientific papers easy for hundreds of years already.

• edited May 2020

I just stumbled upon people quoting Christopher Alexander, father of architectural design patterns and author of very, very cool books. See A city is not a tree

The units of which an artificial city is made up are always organized to form a tree. So that we get a really clear understanding of what this means, and shall better see its implications, let us define a tree once again. Whenever we have a tree structure, it means that within this structure no piece of any unit is ever connected to other units, except through the medium of that unit as a whole.

The enormity of this restriction is difficult to grasp. It is a little as though the members of a family were not free to make friends outside the family, except when the family as a whole made a friendship.

In simplicity of structure the tree is comparable to the compulsive desire for neatness and order that insists the candlesticks on a mantelpiece be perfectly straight and perfectly symmetrical about the centre. The semilattice, by comparison, is the structure of a complex fabric; it is the structure of living things, of great paintings and symphonies. It must be emphasized, lest the orderly mind shrink in horror from anything that is not clearly articulated and categorized in tree form, that the idea of overlap, ambiguity, multiplicity of aspect and the semilattice are not less orderly than the rigid tree, but more so. They represent a thicker, tougher, more subtle and more complex view of structure. Let us now look at the ways in which the natural, when unconstrained by artificial conceptions, shows itself to be a semilattice.

Next best thing I could find to share is this communitywiki.org entry with ASCII art:
https://communitywiki.org/wiki/TreeVsSemiLattice

So planned cities are sterile and nobody wants to live in them, they are designed top-down like trees; beautiful cities are semilattices. In the ASCII art you will see trees VS semilattices like so:

            TREE                         SEMI LATTICE
|                                |
+---+----+                   +-------+----+
V   | W    X |    Y          V   |    W  X    |  Y
+---+-+    +-+----+          +---+----+  +----+--+
|     |    |      |          |        |  |       |
+-+-+ +-++  ++--+ +-+--+     +-++-+   +-+-++-+  +--+-+
|   | |  |  |   | |    |     |  | |   |   |  |  |    |
A   B C  D  E   F G    H     A  B C   D   E  F  G    H


In a tree, each branch has its leaves; in a semilattice, branches may share leaves and sub-branches.

Author at Zettelkasten.de • https://christiantietze.de/

• I love that phrase "The Zettelkasten as a Lattice of Thought Strings" and understand it immediately because that is the conclusion I came to as what a Zettelkasten is. I would use it but I'm not sure if people new to it would understand what "thought strings" are or what "latticework" means. But it is on point!

• I ran into this while trying to represent the outbound links as a tree. At the moment I approach it by considering it a graph and because a Zettel can be linked to from multiple places and they can be circular (i.e. creating loops), I only print up to N parents and M children. Considering it a set-based semi lattice as displayed in the linked wiki page might give some insight in how closely related things are, so I might experiment with them in the future to see if there are some interesting tree notations.

• @grayen so the way I think of it is the "latticework of thoughts" are expressways giving a larger structure to the notes.

Then there are the main road ways, which in the note collection are references to other notes that are meant to be connections you follow. Often it will be at the bottom of the note will be phrases like "See note y and x".

Lastly there are back roads, which are the contextual connections. They will be just linked words within the natural flow of the note. Often they are connected keywords. Say you are looking at an old note and have forgotten what a certain linked keyword means, when you hover over it, a popup appears with the definition. Thereby giving you "greater context".

Do you visualize it as a tree diagram or network diagram? I've been perusing data viz catalog lately and thinking about different ways to visualize notes.

• @Nick I am very interested all these types of connections. It makes me wonder whether these different types should be made explicit to they can be acted / integrated differently in tooling.

In the VS Code extension I am using at the moment, I visualize it just as a regular file tree, but with the active zettel determining what parents (inbound/backlinks) and children (outbound/connections) are shown. Due to limiting the depth, I can workaround the issue of circular connections and such.

Nice site that you linked! Nice place to get inspiration on how to best visualize data.

• The idea of thought strings isn't as tightly connected to Zettelkasten note taking as you might think - it's a general concept of how ideas and thought work. When you talk with someone about a topic, the idea moves along a red string; if you write a book or an article, the arguments, ideas and data you give are a red string that moves along the written piece from beginning to conclusion.

This general principle can be translated to how you typically extract knowledge from a source, be it a written piece, a lecture you heard or a video you saw: You write down the points in that source that have relevancy for you. On that metaphorical ball of arguments, data, anecdotes and sound bites, you collect those that are interesting and rearrange them via some kind of note taking - be it the cornell method, bullet points, visual note taking, you name it. The notes in themselves are a thought string as well, simply because they present the material in a linear fashion.

What's so different about the Zettelkasten method is that you take a scissor to that string and snip it down to their individual little pieces, in order to reconnect them. Yes, the main focus of practitioners of the Zettelkasten method is how to connect atoms. But, you have to make it into atoms first.

And that's one of the takeaways of that article: That we have an interesting dynamic of taking a source that presents ideas in a linear fashion, cut up those ideas, and reassemble them again. Then we can look at those linear sources - we begin with the question of 'which ideas are the same', and connect the strings there, build from these intersections.

You can also think of this as a compression algorithm: When you read ten books that are about the same topic, but have differing opinions on some points or present additional content, then most of the work is done after reading and dissecting the first book, and just highlighting the differences in additional Zettels.

This is a thought exercise to highlight the main differences and the advantage of ZK versus linear note taking methods, and isn't in any way connected to visualizations of the actual ZK connections. Those are much more messier, and there's very different overall shapes involved. Yes, you can follow paths. But other times, you'll back-track to one note again and again, when something revolves about a central idea.

Other times and especially in young topics with low amounts of connecting topics, the top down structure are just a few structure notes with the surrounding notes just being a linear note list and maybe a few interconnections internally and to other topics. That's what happens initially after converting a linear source or notes to a Zettelkasten format - the structure note of that topic or the source note looks in fact like a table of content then, or like the red string of main thoughts though the linear source. That's, by the way, how I came up with the idea of thought strings initially.

• edited May 2020

@grayen said:
In the VS Code extension I am using at the moment, I visualize it just as a regular file tree, but with the active zettel determining what parents (inbound/backlinks) and children (outbound/connections) are shown. Due to limiting the depth, I can workaround the issue of circular connections and such.

I think of the connection types the following way: There's a connection type for moving up, for moving down, for moving along the path and for backtracking the path. Lastly, there's the connection type of 'source'. My symbols for the those types are actually ^(or just o for overview because of keyboard layout making ^ cumbersome), v, <, > and @.

Moving up means going to a table of content note, or a structure note. Moving down means delving into sub-topics of the current Zettel. That's very useful for fact Zettels, when you also use your ZK as a reference collection. It's pertinent to limit the amount of down/uplink steps you include in the Zettel, especially with manual linking systems adding all hierarchy levels gets tedious. I often just include one up/downlink in the ZK itself but include all hierarchy levels in the structure note.

Moving along the path and backtracking (fore/backlinks) are the classical Folgezettel, the strings of Zettel that devolve in 'conversations' with yourself, and 'hey, that's something similar'/'further reading'/'See also' kind of deals. So same hierarchy level of the notes. That's the standard link.

Source links are essential for context. I've developed the habit of adding source index Zettels with a quick summary of the source, links to external information or the source itself, and backlinks to all Zettels that have the material as a source. That either in thought string order or replicating the original sources' TOC. It's a second kind of structure note that's very helpful in big ZK registries.

I've used '%' for a while to indicate 'similar' or 'see also' in the way as used at the bottom of Wikipedia articles or dictionary entries, but found it superfluous for my use and discontinued that.

• @gescho Well-written and insightful article (and the sketches helped) - thank you!

• A lovely post; thanks to @gescho for the contribution and to the Archive crew for sharing it for us all to see.

A "thought-string lattice" is a lovely way to describe this -- it makes it clear that some paths through are woven, others emergent. I have also seen the term "heterarchy" used in this context and love the notion. In a lattice, any thread through can be structural. In a non-hierarchical system containing hierarchies, any order can become the "blessed" order as the need arises.

This kind of argument is very useful as the world discovers note-making systems and tries to figure out how to fit it into note-sorting-system expectations.