Laws of Form

This plugin adds to Obsidian the ability to transform linear Laws of Form bracket expressions into their familiar two-dimensional graphical representation. An introduction to Laws of Form would go beyond the scope here. It is assumed that the reader is familiar with the concepts.

Useful links

• Laws of Form Playground – React Library
• Authors website
• Source Code
• LoF50

🗒 Code blocks

This plugin renders the laws of form expressions inside lof code blocks. Every code block starts with the lof keyword.

```lof
(()) ()
```

This block will look rendered like the LoF formalism.

Ⓞ Drawing distinctions

1. A cross is marked with ()

  ()

2. Any text in space is interpreted as the content of the space

  ((Observer) Society)

3. You can nest crosses

  ((())())

4. A Re-Entry is made out of two identifiers. $id and [id]. $id denotes the space that enters into [id]. id must be a number. There can be multiple $ids in a space, but only the rightmost counts.

  (([0]a)$0b)
  (([42]$42) Autopoiesis)

5. A space can also re-enter into two locations (see limitations).

  (([0]c)([0]a)$0b)

6. Multiple Re-Entries are also possible

  ([3]([0]$0)([1]$1)$3)

7. This is how you could implement the modulator function (see the first image above)

```lof font-size: 20px
  (((((((([0]a$1)$6[2])[1]$3)[0]$4)a$5)$2[6])[5]) [4]$0)
```

Equations & Separators

Because of the way the interpreter works, non LoF expressions (e.g., plain text, emojis) or separate LoF expressions within the same line must be explicitly factored out/separated.

Separation of expressions is needed for equations.

For example

```lof
() () = () 
```

without separators would be rendered like this To render the expression above correctly, it must be split into three parts with the separator (by default "::") for correct display.

```lof
() () :: = :: ()
```

This results in the correct form Everything between separators is just interpreted as plain text. Thus brackets "(),[]" and "$" will not be interpreted. The default separator can be individually overwritten using the separator keyword in the block parameters or globally inside the settings.

The last unclosed separator will move the uninterpreted text to the right.

```lof font-size:24px; 
((a)b)
::=:: ((a)b)((a)b) :: C5
::=:: ((a)((b)))((a)b) :: C1
::=:: ((((a)b)a)(((a)b)(b))) :: J2
::=:: ((((a)b)a)((b))) :: C4
```

will lead to

🌈 Style Customization

Using inline CSS, full customization of the expression style is possible. For example, if we want to have a red font color, set the font size to 22 pixels and have "Chalkduster" as the font, we can do that with the following inline CSS.

```lof font-family: Chalkduster; font-size: 20px; color: red;
((a[0])b$0)

((aasdasdasd[0])(b[0])$0c)()

([0]$0Autopoiesis)
```

This block will look rendered like this

⚠️ Reducing the font size (e.g., font-size: 50%; font-size: 0.8em; font-size: 12px;) is the most important customization in case expressions are too long and wrap around.

Global styling can be applied inside the plugin settings.

⚠️ Limitations

The entire drawing of the crosses and re-entries is done using divs. Each cross is a div. This allows many degrees of freedom, but this also comes with limitations, especially for the Re-Entry. HTML/CSS permits to use at most one :before and :after pseudo element (which is used for the Re-Entry) per div. Thus, for each Re-Entry we can have at most two spaces where it can re-enter. For the majority of cases, two re-enters per re-entry are perfectly sufficient. Sometimes using complicated nested Re-Entries it is necessary to rearrange expressions in case of display errors.