SeMS

 

---

SeMS ist die semantische Meta-Sprache für die Semantischen Sprachverarbeitung von IS. Sie ist meta zu syntaktischen Ausdrücken und Texten. Sie ist semantisch, da sie tatsächlich den Inhalt von Sätzen widergibt, deren Bedeutung.

 

→  [zum Hauptportal Mechanische Intelligenz]

 

Es folgt eine kurze informelle Übersicht zur semantischen Metasprache SeMS. Sie ist angelegt an die Syntax der Prädikatenlogik und an die Semantik der Begriffslogik(!).

 

---

Syntax von SeMS Semantik von SeMS Compter-Sprache CS-1

 

Syntax von SeMS

---

Es gibt znächst nur Gegenstände. Zwischen diesen gibt es drei zweistellige Relationen. Etwa die Hälfte der Gegenstände sind Bezeichugen, Namen für andere Gegenstände.

 

1) Die B-Relation {| |}: gegenstand1 → gegenstand2  - ("hat B")

gegenstand2 {| gegenstand1 |}  :=  {| gegenstand1 |} = gegenstand2

Bsp.: {| "banane" |} = banane

 

2) Die O-Relation []: gegenstand1 → gegenstand2  - ("hat O")

gegenstand2 [ gegenstand1 ]

Bsp.: frucht [ banane ]

 

3) Die P-Relation (): gegenstand1 → gegenstand2 - ("hat P")

gegenstand2 ( gegenstand1 )

Bsp.: obst ( banane )

 

B, O und P sind keine Abbildungen, jedem Gegenstand können jeweils mehrere andere Gegenstände zugeordnet werden.

 

Ein Relations-Paar ist ein Elementarsatz si von SeMS, z.B.: frucht [ banane ] .

Elementarsätze können durch logische Junktoren iterativ zu komplexen Sätzen Si verbunden werden.

 

not s1 - Bsp.: not obst[banane] .

s1 and s2 - Bsp.: obst[banane] and affe(charly) .

s1 or s2 - Bsp.: obst[banane] and affe(charly) .

 

 

Semantik von SeMS

---

Die Semantik von SeMS beruht auf der Sprachtheorie von IS.

 

 

Compter-Sprache CS-1

---

CS-1 hat ein anderes Konzept von Variablen und Typen als herkömmliche Programmiersprachen. Diese orientieren sich nur an einem Teil der Konzepte der natürlichen Sprache. Es gibt dort eine Ebene von Typen (die beliebieg kombiniert und spezialisiert werden können) und die Ebene der Variablen, die Werte deser Typen halten können. CS-1 führt Abstraktionsebenen ein und ermöglicht so Typen von Typen (s.a. Interfaces). CS-1 führt Metaebenen ein und ermöglicht so Bezeichner von Bezeichnern (s.a. Tcl/Tk). Der Rest ist wie gewohnt.

 

Alle Typen (inkl. Default-Typen) sollten als Klassen realisiert sein.

Gegenstände, die nur O-Kinder ("gerichtete Relation") haben - grün - diese können gesperrt werden bzgl. P-Kindern. analog zu abstrakten Klassen.

Gegenstände, die O- und P-Kinder haben - blau

Gegenstände, die nur P-Kinder haben - lila

Einfache Gegenstände, die keine Kinder haben: schwarz (für Variable), grau (für Literal = Speicherbereich)

 

Variablen-Deklaration (abwärts):

int ( intA );

P-Relation int ( intA )

 

Variablen-Definition:

(const) intA = "3";

(const) varA = "intA";

B-Relation {| intA |} = 3  :=  intA = "3"  -  (Umkehrrelation B-1)

(const) intB = [| varA |];     // = "3" - (s.a. Parameter !)

 

Variablen-Deklarationen (abwärts a) ) - Listen (geordnet, dynamisch und generisch): myList

intListe [ myList ];

myList = { "2","4","6","8" };

liste [ intListe ];          // liste hat Methoden

O-Relation intListe [ myList ] bzw. P-Relationen myList("0"), myList("1") ...  :=  myList = { "0","1","2","3", ... }

 

Typvariablen-Deklarationen (abwärts b) ) - Aufzählungstypen (ungeordnet, statisch und generisch): byte

int [ byte ];

(intern) - byte = { "0","1","2","3", ... };

byte ( intC );  intC = "3";

zahl [ int ];               // zahl hat Methoden

ClsBase [ ClsNew ];

O-Relation int [ byte ] bzw. P-Relationen byte("0"), byte("1") ...  :=  byte = { "0","1","2","3", ... }

 

oder ( intA, intB, "3", ... ), { byte, int, ... }

 

Bei Aufwärts-Deklarationen braucht nichts aufgezählt werden !

Typvariablen-Deklarationen (aufwärts) - Array: koordinate

koordinate [ int, int ];

koordinate ( kooA );

kooA = "3, 5";

O-Relation koordinate [ int, int ]

 

Klassen:

Klassenvariablen-Deklaration (aufwärts) - Klasse: adresse

adresse {

     byte ( intA );

     koordinate ( kooA );

}

Bei CS-1-Klassen kann

a) abgeleitet werden: O-Relation

b) instanziiert werden: P-Relation

 

Methoden:

 

intA  =  intB.add(intC);

int::add ( int ( intVar ) )

{

     return value + intVar.value;

}