[Zero]

Hi guys, I hope you're all right!

Today, I'll mix Noisett (a string pattern matching network), PL/S (a deliberately simple language), and DSX (a sentence structure syntax) together.

Rationale: Noisett is cool, but it works on simple strings, where the structure of sentences is not explicit, which makes it too weak to rock. I wanna make it lift heavy weight now. The whole thing is supposed to run on NodeJS.


Let's start with Noisett. Noisett is a network of agents called Nuts. Each nut reacts to incoming messages by testing them against patterns, and reacting accordingly. Noisett syntax uses special characters instead of keywords. Since I'm going to need special characters for something else, I first have to flatten Noisett's syntax, to make it look like PL/S.

Here is Noisett2's instruction set:

Code

*          Wildcard
$1         Capture
@          Name of message sender

SHARE:     send to followers
REPLY:     send only to sender

IF:        go on if message matches pattern
IFNOT:     go on if message doesn't match pattern
IS:        go on if pattern found in section
ISNOT:     go on if pattern not found in section

SECTION:   choose current section
APPEND:    add to section
REPLACE:   locate a target in current section
BY:        replace target by something else
COPYALL:   copy all matches from previous section to current section
COPY1ST:   copy first match
COPYRND:   copy one of matches
REMOVE:    del from section

NUT:       create or select nut
UPLOAD:    as section (ok if new section)
DOWNLOAD:  section from nut in current

ANYWAY:    stop skipping commands
EXEC:      execute this section or js file
ARGS:      with this as message

   

Now, instead of:

Code

[MAIN]
I'm * + * Noisett * > Received $2

We have:

Code

[MAIN]
IF: I'm *
IF: * Noisett *
SHARE: Received $2

Good. Next step: we want to make the structure of sentences explicit, so we'll need DSX stuff.
DSX looks like:

Code

I < need < ( [ your > clothes | your > boots ] =and= ( your > motorcycle ) )

Special characters < and > show subordination, and == characters show coordination. Parentheses group things.

We could turn this example into the following JSON:

Code

[
    {
        "id": 1,
        "content": "I",
        "container": 0,
        "main clauses": [],
        "subordinate clauses": [2],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 2,
        "content": "need",
        "container": 0,
        "main clauses": [1],
        "subordinate clauses": [3],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 3,
        "content": [4, 5, 6, 7],
        "container": 0,
        "main clauses": [2],
        "subordinate clauses": [],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 4,
        "content": "and",
        "container": 3,
        "main clauses": [],
        "subordinate clauses": [],
        "coordinated by": [],
        "coordinator of": [5, 6, 7]
    }, {
        "id": 5,
        "content": [8, 9],
        "container": 3,
        "main clauses": [],
        "subordinate clauses": [],
        "coordinated by": [4],
        "coordinator of": []
    }, {
        "id": 6,
        "content": [10, 11],
        "container": 3,
        "main clauses": [],
        "subordinate clauses": [],
        "coordinated by": [4],
        "coordinator of": []
    }, {
        "id": 7,
        "content": [12, 13],
        "container": 3,
        "main clauses": [],
        "subordinate clauses": [],
        "coordinated by": [4],
        "coordinator of": []
    }, {
        "id": 8,
        "content": "your",
        "container": 5,
        "main clauses": [9],
        "subordinate clauses": [],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 9,
        "content": "clothes",
        "container": 5,
        "main clauses": [],
        "subordinate clauses": [8],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 10,
        "content": "your",
        "container": 6,
        "main clauses": [11],
        "subordinate clauses": [],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 11,
        "content": "boots",
        "container": 6,
        "main clauses": [],
        "subordinate clauses": [10],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 12,
        "content": "your",
        "container": 7,
        "main clauses": [13],
        "subordinate clauses": [],
        "coordinated by": [],
        "coordinator of": []
    }, {
        "id": 13,
        "content": "motorcycle",
        "container": 7,
        "main clauses": [],
        "subordinate clauses": [12],
        "coordinated by": [],
        "coordinator of": []
    }
]

Using the following conventions:

Code

id                    #
content               +
container             ^
main clauses          <
subordinate clauses   >
coordinated by        %
coordinator of        &

We can shrink this example to:

Code

#1+I>2 #2+need<1>3 #3+4,5,6,7<2 #4+and^3&5,6,7 #5+8,9^3%4 #6+10,11^3%4 #7+12,13^3%4 #8+your^5<9 #9+clothes^5>8 #10+your^6<11 #11+boots^6>10 #12+your^7<13 #13+motorcycle^7>12

And then use this kind of things in a Noisett2 agent:

Code

[MAIN]
IF: #1+I>2 #2+need<1>3 #3+*
SHARE: #1+@>2 #2+needs<1>3 #3+$1<2

Here, if NutX says "I < need < raincheck", agent will say "NutX < needs < raincheck".

The same could be written like this:

Code

[MAIN]
IF: I < need < *
SHARE: @ < needs < $1

Lovely, isn't it?



EDIT:

Code

Poll
  [ ] It rocks!
  [ ] It sucks!
  [ ] You're insane!

EDIT: Inevitable typos + clear syntax

[8pla.net]

Or the poll could have been written like this:

Code

[MAIN]
IF: I < need < help
SHARE: You < need < $1

EDIT:

Code

Poll
  [ ] It rocks!
  [ ] It sucks!
  [*] You need help

Ha!   Just joking with you!  Seriously...

Code

[*] It rocks!

[8pla.net]

The same could be written like this:

Code

[MAIN]
IF: I < need < *
SHARE: @ < needs < $1

Lovely, isn't it?



EDIT:

Code

Poll
  [*] It rocks!
  [ ] It sucks!
  [ ] You're insane!

Yes, it is lovely, and all joking aside, it does rock.
Surely there are better ways to port this to PHP,
but here is my first attempt:

Code

<?php

MAIN:

$input = "I need help";

${"I < need < * "} = "/I need (.*)/";

if( preg_match(${"I < need < * "},$input) ){ goto SHARE; }

SHARE:

echo preg_replace(${"I < need < * "},"You < need < $1",$input);

?>

Program Output:

You < need < help

[Zero]

Thanks, 8pla.net 
May I ask, I see you often do things with PHP: what stack do you use? Id' like to play with PHP. Are there lightweight ways to do it?

[8pla.net]

Thanks for your reply.

I enjoy using a LAMP stack.   That stands for Linux, Apache, MySQL and PHP.  But, I totally like JavaScript too.  It is super terrific with HTML5 which does a couple of things PHP can NOT do.  Of course PHP and JavaScript blend together perfectly on the web.

As for lightweight,  Well, I'm curious about embedding PHP, so it may run in the Loebner Prize Competition.  From what I gather, which is still very preliminary, PHP has an .exe file for Windows, so I am investigating that further.

The only thing is, at that rate, going full C or C++ language, with regular expressions may be another option for the Loebner Prize Competition. An outstanding example would be ChatScript, which is C++.

[Zero]

Well, I saw a port of PHP to JS, but I don't know if it's an interesting project.

Generally speaking, I think connectionism is a good path to AGI. But I also think that transmitted messages should carry more than an intensity. They should carry structured information. That's my opinion. Because of this opinion, I believe that the nodes of the "brain network" should be able to filter, transform, and generate structured information. Hence, PHP is interesting.

For instance, in another thread, I talk about a data serialization format between JSON and BEncode. It would be cool to use PHP as a formula language inside this data serialization language. Like this:

Code

{
  <key foo> <val foo>
  <key bar> <?php  **here some php code** ?>
}

AIDreams is very calm these days, isn't it?

[8pla.net]

Source Code filename: fl.json

Code

<?php
$formula_language="";
for($i=1;$i<=8;$i++){$formula_language.="$i";}
?>
{
  <key foo> <val foo>
  <key bar> <val <?=$formula_language?>>
}

Compiles with:

$ php fl.json

Program output:

{
  <key foo> <val foo>
  <key bar> <val 12345678>
}


Notes:
The .json file extension may be switched to .php in some situations.

Even shorter source code listing (fl.json), same program output:

Code

{
  <key foo> <val foo>
  <key bar> <val <?php for($i=1;$i<=8;$i++){echo"$i";} ?>>
}

Zero asked, "AIDreams is very calm these days, isn't it?"

It's Spring Break now.


_______________________________________________________________________

[LOCKSUIT]

Zero.................what IS this? You created human language machine already?

Does it respond back like a chatbot? If not, then what is the breakthrough?

How do you use it? After you enter a sentence, what does it do/output?

http://thinkbots.are.free.fr/ProjectDSX/

[ranch vermin]

i like how its actions,  actions speak louder than stored data.
[EDIT] oops sorry i read it wrong,  is it about if it wants to learn something or not? [EDIT]

[Zero]

DSX itself is a formal wrapper for natural language. It would ease communication with AGI during the first years, by expressing explicitly the structure of natural discourse. You can send an almost natural message, and the AGI receives an already structured message.

This was a precursor to AiDL. Lots of structured messages flowing through a symbolic processing nodes network... this thing thinks.

[LOCKSUIT]

Is there anything in DSX that I should know better if I want to create a language net that speaks to us?

[Zero]

I think you should wait for AiDL. Then you'll have all the tools to make it speak. Because that's what AiDL really is: a thinking machine, able to feel/understand itself, and to communicate.