initial formal model semantics document, etc.

simplest_model/model.typ

@@ -0,0 +1,203 @@
+// #import "@preview/polylux:0.4.0": *
+#import "@preview/simplebnf:0.1.1": *
+// #import "@preview/zebraw:0.5.0": *
+// #show: zebraw
+#import "@preview/curryst:0.6.0": rule, prooftree, rule-set
+#import "@preview/xarrow:0.4.0": xarrow
+
+= Формальная модель используемого языка
+
+== Синтаксис
+
+#h(10pt)
+
+#bnf(
+  Prod(
+    `tag`,
+    {
+      Or[`Ref`][pass by reference]
+      Or[`Value`][copy]
+    }
+  ),
+  Prod(
+    `value`,
+    {
+      Or[`Unit`][cell with some value]
+      Or[`Bot`][spoiled cell]
+    }
+  ),
+  Prod(
+    `arg`,
+    {
+      Or[`RValue`][new value, no associated variable]
+      Or[`LValue` $d$][value from some variable]
+    }
+  ),
+  Prod(
+    `stmt`,
+    {
+      Or[$f($`args`$)$][call function by id]
+      Or[`write` $d$][write to variable]
+      Or[`read` $d$][read from variable]
+    }
+  ),
+  Prod(
+    `body`,
+    {
+      Or[`body` `stmt`][with statement]
+      Or[$epsilon$][empty body]
+    }
+  ),
+  Prod(
+    `fun_decl`,
+    {
+      Or[`body`][function body]
+      Or[`tag` `fun_decl`][with argument pass strategy annotation]
+    }
+  ),
+  Prod(
+    `prog`,
+    {
+      Or[`fun_decl`][main function]
+      Or[`fun_decl` `prog`][with supplimentary funcitons]
+    }
+  ),
+)
+#align(center, [$d, f in NN,$ `args` $in NN ast.basic$])
+
+== Семантика статического интерпретатора
+
+#h(10pt)
+
+$V := {0, bot}$ - значения памяти
+
+$L := NN$ - позиции в памяти
+
+$X$ - можество переменных
+
+$sigma : X -> L$ - позиции памяти, соответстующие переменным контекста
+
+$mu : NN -> V$ - память
+
+$l in NN$ - длина используемого фрагмента памяти
+
+$M subset NN$ - множество испорченных ячеек памяти
+
+#[
+
+#let cl = $chevron.l$
+#let cr = $chevron.r$
+
+#align(center, grid(
+  columns: 2,
+  gutter: 5%,
+  align(bottom, prooftree(
+    vertical-spacing: 4pt,
+    rule(
+      name: [ spoil init],
+      $mu =>^nothing mu$,
+    )
+  )),
+  prooftree(
+    vertical-spacing: 4pt,
+    rule(
+      name: [ spoil step],
+
+      $mu =>^M gamma$,
+      $mu =>^(M union {n}) gamma[n <- bot]$
+    )
+  ),
+))
+
+#h(10pt)
+
+#align(center, prooftree(
+  vertical-spacing: 4pt,
+  rule(
+    name: [ $f(x), space f := lambda a. e$],
+
+    $cl [a -> sigma(x)], mu, l, nothing cr
+     xarrow(e)
+     cl sigma, mu', l', M' cr$,
+
+    $mu' =>^M' gamma$,
+
+    $cl sigma, mu, l, M cr
+     xarrow(f(*x))
+     cl sigma, gamma|_[0, l), l, M cr$,
+  )
+))
+
+#align(center, prooftree(
+  vertical-spacing: 4pt,
+  rule(
+    name: [ READ $x$],
+
+    $mu(sigma(x)) != bot$,
+
+    $cl sigma, mu, l, M cr
+     xarrow("READ" x)
+     cl sigma, mu, l, M cr$,
+  )
+))
+
+#align(center, prooftree(
+  vertical-spacing: 4pt,
+  rule(
+    name: [ WRITE $x$],
+
+    $cl sigma, mu, l, M cr
+     xarrow("WRITE" x)
+     cl sigma, mu[x <- 0], l, M union {sigma(x)} cr$,
+  )
+))
+
+]
+
+== Пример аннтаций аргументов
+
+#h(10pt)
+
+#align(center, grid(
+columns: 3,
+gutter: 5%,
+  ```
+  def f(?fx x, ?fy y) {
+    read(x);
+    write(x);
+    read(y);
+  }
+  def w(?wx x) {
+    write(x);
+  } 
+  ```,
+  ```
+  def g(?gx x, ?gy y) {
+    write(x);
+    write(y);
+    read(x);
+    read(y);
+  }
+  def r(?rx x) {
+    read(x);
+  } 
+  ```,
+  ```
+  def main(x, y, z, k) {
+    w(x);
+    r(x); // -> ?wx != ref
+    f(x, y);
+    r(y);
+    g(z, k);
+    w(z);
+    f(y, z);
+    r(k); // -> ?gy != ref
+  }
+  ```
+))
+```
+-> ?fx = ref, ?fy = ref, ?wx = copy, ?gx = ref, ?gy = copy, ?rx = ref
+...
+-> ?fx = copy, ?fy = copy, ?wx = copy, ?gx = copy, ?gy = copy, ?rx = copy
+```
+