I've received complaints that my texts aren't accessible, impenetrable.

This is perfectly fair, I've always had doubts about my texts and to be
honest, I'm sure they're crude at best. Having said that, I try harder
and harder to better communicate my ideas.

And will continue doing so.

In this edition of the leet list I will discuss logos the language, why
logos of all things and what are all things logos. Be prepared for bits
and pieces of programming jargon as well as basic philosophical ideas,
but this time around I will try to explain myself without having to
bring any of the big words.

Logos is a language based on a set of rules.

As-if within a game.

These rules are meant to be followed closely; it is also considered that
all players of this language game agree with the rules, understand each
other perfectly, and can also agree on what's been said, when, by whom.

We engage in such games all the time; in fact, some thinkers argue that
all of the human interaction can be described with games. Why logos of
all things? Suddenly, it provides a very flexible foundation to describe
various things and prescribe what can be done to them.

In logos, we refer to all things, objects— as signs, and to actions on
them we refer to as propositions.

Now let's see real quick how logos can be applied.

The classic example is quid pro quo, a willful bargain in which quid is
exchanged for quo. This discursive practise is very old, in fact as old
as people who first started trading.

Let's say that a good (product) is simply a number.

Then I could use logos to encode this contract:

	Item := real. { number }

	{ Inventory maps actors to their items. }
	Inventory := actor -> item list.

	Quid pro quo, sir? :=
		Quid, quo := item.
		Sir := actor.

		My stuff  <- inventory of this.
		Their stuff <- inventory of sir.

		{ Both must be true to proceed. }
		My stuff contains quid.
		Their stuff contains quo.

		{ Perform actions. }
		Remove quid from my stuff!
		Put quid to their stuff!
		Remove quo from their stuff!
		Put quo to my stuff!

	Quid pro quo, sir! :=
		Quid, quo := item.
		Sir := actor.

		{ Assuming the deal is "fair"... }
		If quo > quid, then commit!

This segment is a rough description of a bargain, or what I should like
to call it, language game– between two actors. The world is described as
consisting of item numbers, the inventory (in which actors correspond to
item lists) and two propositions.

The question mark indicates that the proposition is mutable, meaning it
can and will influence system state, which represents precisely current
state of the affairs.

The exclamation mark indicates affirmation.

Questions specify what about the world will change exactly, and then all
actors involved must affirm it by exclamation! All possible mutations
can be written as negotiations.

Actors struggle to mutate the system, and can ultimately succeed only if
cooperating in the open. This is meant to represent how decision-making
is done in real-life human interactions.

The discourse above can be computed on a blockchain.

The idea is that we can scale this up to much more complicated systems
and public spaces. I.e. this would allow us to compute whole bodies of
judicial texts like civil and criminal codes.

Another possible use-case would be to use it as the skeleton form for
future, more sophisticated AI. You can imagine how it's much easier to
decipher meaning when there's a formal specification of the discourse
that's supposed to convey it.

I believe in this idea.

-badt

> The idea is that we can scale this up to much more complicated systems
and public spaces. I.e. this would allow us to compute whole bodies of
judicial texts like civil and criminal codes.

Wow, basically, Logus can be perceived as a formal language for people's
communication and knowledge transfer, can't it?

> On 24 Jul 2021, at 13:59, Hirrolot <hirrolot@gmail.com> wrote:
> 
>> The idea is that we can scale this up to much more complicated systems
> and public spaces. I.e. this would allow us to compute whole bodies of
> judicial texts like civil and criminal codes.
> 
> Wow, basically, Logus can be perceived as a formal language for people's
> communication and knowledge transfer, can't it?

Oh wow! Im so excited to this implemented. Philosophical speculations aside though, what math formalism is behind this? Cat theory? Type theory? Something else? I would like to see at least description of a potential implementation direction. A detailed elaboration on architecture would be more appreciated tbh :)

You can’t begin to imagine my own excitement!

I’ve been essentially working over this for the last 3 years, very happy
to be able to get the word out.

> what math formalism is behind this? Cat theory? Type theory?

You see, my background in logic is Frege, Wittgenstein, Ramsey.

Even though I make my living almost entirely on the engineering side of
things, theory-wise I'm coming from a very, very different place, which
is what I like to think gives me a fresh perspective on the programming
language crisis, or the unforgiving lack of creativity thereof.

The exact theory to reason about this is of little interest to me, let's
see what Hirrolot has to say on it, for he is much more experienced than
me in this respect.

That said, I do have a bunch of ideas as to how this can be implemented.

We need a padded serialization format for texts.

Bytecode representation of the input text is what we feed into a VM, it
then proceeds to map the corresponding discourse onto a graph. This will
first be done in-memory, but with the strategy to make use of a proper
distributed graph database in the future.

Dgraph is what I have in mind.

Theory–wise, there are two obstacles that I believe can be dealt with.

(1) A proposition can be viewed as a path in the lexical tree; words and
punctuations make vertices, so when parsing what you do is walk from one
to another.

This is not very trivial, as you have to deal with things like articles,
possessive moods, adverbial turns— the usual suspects when it comes to
most natural languages.

	Update object's value!
	Update the object's value!
	Update value of object!
	Update the value of the object!

All of the above is supposed to be parsed as equivalent propositions.

(2) You have to be able to think of propositions in ASTs.

This is no big surprise. What must be considered, however, are possible
optimizations that would be required for the constraint mechanism that
modality in logos provides via questions and exclamations. (Mutations
being transactional in nature.)

High-complexity parsing doesn't necessarily imply that the verification
process can't be efficient. On the contrary, the efficiency of run-time
verification is the primary goal insofar our constraint model goes. The
idea is that nonsense must be easily refutable.

Hence logos has to optimize both for tautologies lexically, and for
contradictions– syntactically.

-badt