RefLog

[Jon Awbrey]

¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤

RefLog Sig:

Here is a formal introduction to the RefLog Syntax.

Formally speaking, we have the following set-up:

Set out the 'alphabet of punctuation marks' $M$ = {" ", ",", "(", ")"}.
The elements of $M$ are vocalized as "blank, "comma", "links", "right".

1.  There is a parametric family of formal languages of character strings
    such that, for each set $X$ of variable names $X$ = {"x_1", ..., "x_k"},
    there is a formal language L($X$) over the alphabet A($X$) = $M$ |_| $X$.
    The grammar can be given in gory detail, but most folks know it already.

    Examples.  If $X$ = {"x", "y"}, then these are typical strings in L($X$):

    " ", "()", "x", "y", "(x)", "(y)", "x y", "(x y)", "(x, y)", "((x)(y))", "((x, y))", ...

2.  There is a parallel family of formal languages of graphical structures,
    generically known as "painted and rooted cacti" (PARC's), that exist in
    a one-to-one correspondence with these string expressions, being more or
    less roughly, at a suitable level of abstraction, their parse graphs as
    data structures in the computer.  The PARC's for the above formulas are:

*   Examples.
|                                                                x   y  x   y
|                                                                o   o  o---o
|                               x      y            x y   x   y   \ /    \ /
|          o                    o      o             o    o---o    o      o
|          |      x      y      |      |     x y     |     \ /     |      |
|   @,     @,     @,     @,     @,     @,     @,     @,     @,     @,     @,     ...

Together, these two families of formal languages constitute a system
that is called the "reflective extension of logical graphs" (RefLog).

Strictly speaking, RefLog is an abstract or 'uninterpreted' formal system,
but its expressions enjoy, as a rule, two dual interpretations that assign
them the meanings of propositions or sentences in 'zeroth order logic' (ZOL),
to wit, what Peirce called the 'alpha level' of his systems of logical graphs.

For example, the string expression "(x (y))" parses into the following graph:

|       x   y
|       o---o
|       |
|       @

You can 'deparse' the string off the graph by traversing
it like so, reading off the marks and varnames as you go.

|  o---x->(--y---o
|  |   x  (  y   |
|  |   o-----o   v
|  |   |  )      )
|  (  (|)        )
|  ^   |         |
|  |   @         v

In the 'existential' interpretation of RefLog,
in which I do my own thinking most of the time,
concatenation of expressions has the meaning of
logical conjunction, while "(x)" has the meaning
of "not x", and so the above string and graph have
a meaning of "x => y", "x implies y", "if x then y",
"not x without y", or anything else that's equivalent.
The blank expression is assigned the value of 'true'.
Hence, the expression "()" takes the value of 'false'.
The bracket expression "(x_1, x_2, ..., x_k)" is given
the meaning "Exactly one of the x_j is false, j=1..k".
Therefore, "((x_1),(x_2), ...,(x_k))" partitions the
universe of discourse, saying "Just one x_j is true".

Jon Awbrey

¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤~~~~~~~~~¤