My Note Taking Grammar

This is an initial attempt at an ontology for my note taking system, and is still changing frequently.

My Note Taking Grammar

Goal

A clear, simple, descriptively typed note-taking language.

Philosophy

The idea is to take the linked notes one step up from where there are by default.

Normally, notes are linked together and this creates interesting connections and potentially meaningful insights.

However, this also makes it hard to differentiate between different types of relationships.

If page x references page y in a cursory fashion, but page z references page y in a very meaningful and important way that is relevant to page y, there is no easy way to distinguish between these relationships besides reading the context of the backlinks.

Tags and metadata serve as ways to differentiate certain relationships, but so much of the meaning of the relationship lives in the language of the notes. So I wanted to create a system that can live in the content of the notes, instead of either in the structure of the database or in the metadata. These relationships and discourse between notes are really the data that matters, after all. They should not be relegated to metadata.

I’ve fallen into the trap before of trying to put too many of my note relationships into the metadata, but this is treating a note taking tool like a database. Relationships are often discovered in the note-writing process, and just because they live organically in your notes does not mean they shouldn’t also be clear about what type of relationship they are and be easily queryable. It just requires a tightening up of the language that we use every day.

This is why I have tried to create a system for semantically typing relationships. In a way, this is a first pass at trying to create a semantic, human friendly, note taking language.

The grammar and syntax for this follows below, but will almost certainly be changing frequently as I am in the early stages of developing this system.

One of the important components of this has been thinking about keeping the underlying text files as readable and close to human language as possible.

The hope is that this will help my note taking become a more clear, sustainable, synthesis encouraging, and transferrable form of knowledge, at least for me.

To recap, the goals of the system are the following:

Show what types of relationships exist between notes in the content of the notes themselves.

Grammar

Note Types

Core

=> question

type/question

a statement that can be satisfied by a claim

=> claim

type/claim

a predictive or declarative statement

=> observation

type/observation

a past tense statement (associated with an external source, if none stated then I am the source)

=> external

type/external

an external entity or source

=> concept

type/concept

an idea or schema (may or may not be original)

Future Considerations

=> quantity

e.g. high / medium / low, 0-10, -inf to inf, etc

=> context

probably contains an observation, and is associated with an external source

Edges

Core

=> informs =>

=> supports =>

claim => claim

observation => claim

=> opposes =>

claim => claim

observation => claim

=> responds to =>

=> similar to =>

Future Considerations

=> type =>

node => node

=> child of =>

node => node

=> certainty =>

claim => quantity

=> effort =>

claim => quantity

Syntax

->

When an arrow neighbors a link to an edge, this creates a typed relationship.

The following syntaxes are allowed

[[x]] -> [[edge/supports]] -> [[y]] = x supports y

[[y]] <- [[edge/supports]] <- [[x]] = x supports y

-> [[edge/supports]] -> [[y]] = parent block supports y (first arrow is optional)

-> [[edge/supports]] -> = parent block supports all child blocks to this block (y) (first arrow is optional)

[[y]]

Implementation

Currently I am trying to implement this as much as possible in templates

Also considering building a Logseq Functional Notes Plugin

The idea is to have this system be one that can eventually be a standard parsing mechanism and one gets as much adoptions markdown

A point about Category Theory

There is a nod here to Category Theory. I’m not yet sure what to make of it, but I have a desire to make a note-taking language that can essentially be the language of Category Theory. If ever achieved, then, in theory, anything that can be represented by a Category can be represented as Knowledge Graph of notes.

Similarly to the Category Theory relationship, in the back of my head I think of this as a Functional language for writing.

The edges here are specified for clarity, but really any note can be an edge. The arrow -> simply specifies that there is a way to get from the note at the start of the arrow to the note at the end of the arrow (plus some minimal syntactic sugar to allow for dropping an arrow when it’s implied).

This of course means that you can also have arrows from “edges” to “edges”, but not sure that most note repositories will find that useful. Nonetheless, another nod to Category Theory by adding a way to sort of create functors.

There is almost certainly a better way to represent functions between notes in this Category Theory representation (is it just Haskell?), but I thought I’d put this attempt to the test for a while.

Types of discourse

Learning flow

Literature notes / notes on external sources with structured observations

Create solid nodes in my notes from those ideas

Pulling out questions and claims

Evergreen notes

Putting my thoughts into atomic notes and relating them to existing nodes and notes

Creating concepts and structures of thought that group together varieties of notes

Projects

The tasks and work I’m doing for my various projects

Connecting those projects to my notes and learning