Ich werde es uns so jetzt im Wesentlichen kurz wiederholen,
für die, die ein bisschen später kommen,
die können dann auch immer noch fleißig wieder einsteigen.
Geht also um die Puzzle-Order-Semantik und die Idee,
dass wir da uns überlegen, wie wir die Sachen noch
ein bisschen besser beschreiben können, als mit irgendwelchen Sequenzen.
Was wir da hatten, war halt irgendwelche Prozesse,
die aus entsprechenden Handlungen bestehen,
wobei eben die Eigenschaften der Handlungen extensional sind,
sind unteilbar und entsprechend geordnet,
wobei wir eben insbesondere die entsprechende Ordnung uns anschauen wollten,
wie das da aussieht und von der sequenziellen,
eher zur partiellen Ordnung hinkommen
Dafür hatten wir uns angeschaut, wie es aussieht,
dass wir hier nur die Möglichkeit haben, A,
B und BA auszudrücken,
aber wir sind nicht in der Lage auszudrücken,
dass zwei Dinge auch nebeneinander unabhängig sein können und haben dafür dann für die sequenzielle Darstellung das Ganze als Peternetz dargestellt.
Frage dazu. Ich kenne mich das sozusagen auch so nebeneinander
darstellen. Frage kommt gleich noch dazu. So,
wenn ich jetzt das also als Aktionsfolgen darstelle mit A,
B und B, habe ich jetzt die entsprechende,
in der Lieblingssemantik und entsprechend hier die Parshial Order Semantik,
wo ich jetzt diese beiden Ja, irgendwie erstmal nicht in eine Beziehung setze.
Würde ich das jetzt also so beschreibe, weiß ich dann
auch, dass die zur selben Zeit stattfinden können.
Ja. Ja. AfD können, so werden sie es
ja schon bedingt. Deswegen lustig, beide VC-Stattfinden müssen. Okay,
wir können, ist das denn garantiert in einem System,
dass wir jetzt A und B gleichzeitig stattfinden lassen können?
Ja, ich bin mir ja auch erst A und dann bietet das B
Ja, wir können auch sequenziell, die Frage ist jetzt,
können doch garantieren, dass wir die beiden noch zeitgleich sozusagen handeln lassen können.
Dass wir da oben jetzt aus diesem Bild heraus sozusagen erst mal schließen würden.
Eine Sache hier nicht. Warum? Weil gesagt wurde jetzt
, nein, jetzt wäre die Frage, warum?
Nicht von dieser Semantik her. Weil wenn du diese merkst,
da kannst beide passieren vor zehn.
Ja. Nichts sagt, wann
Genau, wir können erstmal nur aussagen, dass sie überhaupt 4C stattfinden,
aber nicht wann und ob sie auch garantiert unabhängig voneinander sind.
Wir werden nachher nochmal versuchen, mich daran zu erinnern,
dass ich nochmal ein Beispiel aufmale, wo es entsprechend beim Netz
dann auch genau nicht mehr möglich ist, die beiden gleichzeitig auszuführen.
Okay, gut, dann haben wir uns halt angeguckt,
was so eine partielle Ordnung ist,
dass sie entsprechend reflexiv antisemitrisch und transitiv ist,
hatten dafür die entsprechende Striktordnung uns auch angeschaut,
wie das entsprechend darzustellen ist,
nämlich dass du die einzige Metrie sozusagen schließen können aus
der Irreflexivität und der Transitivität
Was dabei ja nicht gegeben sein durfte, waren diese entsprechenden Zyklen.
Das hatten wir auch besprochen. Dann gab es die partielle Ordnung und eine entsprechende strikte Ordnung,
die wir darauf definieren und dann eben noch dazu die Präsidenzrelation,
die sozusagen noch weiter reduziert ist,
und sozusagen noch die grundlegenden Abhängigkeiten zwischen jeweils zweien darstellt.
Wenn wir sie entfernen, reicht es also immer genau aus,
erst mal diese Zweierbögen sozusagen rauszubekommen,
wo wir also einmal um die Ecke sozusagen kommen,
nämlich was ich von A, CD,
können wir entsprechend diese Art A, die weglassen,
aber es reicht auch genau aus,
wenn wir diese Zweierbeziehungen wegnehmen,
weil das sozusagen
genau diese Mehrfachbögen sozusagen gerade wieder entfernt
Okay, dann haben wir irgendwie einen direkten Nachfolger,
dass eben genau das, das eben keiner zwischen Zweien liegen kann,
was natürlich dann heißt, dass es auch der direkte Nachfolger ist
und haben dann entsprechend die Präzedenzrelation dazu angeguckt.
So, dann haben wir eine totale und lineare Ordnung,
wenn wir eine Parzellordnung haben und wir haben diese entsprechenden Dinge,
dass wenn die beiden ungleich sind,
dass dann dies oder das in der Relation jeweils drin sein muss.
So, da zeigen wir uns dann angeschaut,
was wir mit diesen Folgen halt machen können,
aus diesem Gebilde
hier oben
Können wir dann entsprechend die entsprechende Ordnung so machen,
dass wir AVB oder BVA haben und entsprechend natürlich
auch die weiteren transitiven Dinge dabei raushaben können.
So, dann haben wir einen Großlin-A, kleiner,
was eben die lineare Striktordnung ist. Nein,
die eins ist die lineare Striktordnung, wofür eben genau gilt,
dass diese kleinere Geschichte immer wirklich eine echte Teilmenge von diesem ist.
Das heißt, wenn wir solche Sachen ergänzen,
ist dieses Gebilde hier oben immer darin enthalten.
Gut, und damit haben wir dann die Menge der
linearen Vervollständigungen
da drin
So, Zeitstempel, da hatten wir gesagt,
wir haben Uhren laufen, die laufen irgendwie unterschiedlich.
Und wir haben jetzt hier die Möglichkeit,
so ein A fuhr irgendeinem B oder irgendeinem anderen C oder sowas,
was wir oben auch haben zu können.
Und das ist sozusagen genau vor,
während das hier drüben mit dem Nebenläufig,
ist genau das A und B, dass die beiden sozusagen nebenläufig stattfinden können,
weil sie in keiner direkten Abhängigkeit stehen.
So, dann hatten wir das Nachrichtenmodell,
wobei wir eben die entsprechenden Prozessoren eingeführt haben,
mit den lokalen Rechenschritten und den Nachrichten.
Da muss man so gucken,
was liegt nun vor wem und wollten das in irgendeiner Weise
sortieren und haben uns halt das Gebühr hier dazu angeschaut
Also haben wir nur drei Prozessoren und haben dort eben
die entsprechende Relation vor, uns angeschaut und haben festgestellt,
wenn wir auf demselben Prozessor sind, dann liegt das natürlich hier,
wie hier vorne sozusagen, klar und deutlich angeordnet.
Das Nächste ist, wenn man zwischen zweien ist,
wenn ich eine Nachricht verschicke, weiß ich auch,
dass das angeordnet ist und das Ganze transitiv ist,
wissen wir auch,
dass das hier vorne vor dem liegt oder auch die zehn vor der sieben und so weiter und so fort.
Gut,
dann haben wir uns ein Banksystem angeguckt mit den entsprechenden Filialen,
die irgendwie angeordnet sind und haben irgendwie eine Übertragung von Nachrichten
über irgendwelche Kanäle uns angeschaut,
dass wir
so irgendwelche Gelder darüber schieben
Und da gab es dann entsprechend Probleme,
dass wir also gesagt haben, ja,
wir haben eigentlich immer 60, aber wir wollen jetzt sozusagen zwischenschnitte,
wilden im Laufe der Zeiten wollen, dann immer wissen,
wie sieht der Geldbestand da jetzt gerade aus,
um zu schauen, wie sich das entwickelt.
So, dabei ist aufgefallen, dass,
wenn wir sich hier jetzt schneiden würden, unserem Beispiel,
dass wir dann ein Problem haben,
und zwar sind das dann die noch nicht empfangenen Nachrichten.
Das heißt, von der Vergangenheit noch in die Zukunft,
weil die noch nicht angekommen sind,
deswegen haben wir sozusagen jetzt hier ein Problem.
Und die kann man man jetzt sich überlegen, woran liegt das?
Was passiert da? Ich weiß ja, was ich abgeschickt
habe und jetzt nur vergessen, das noch zuzurechnen.
Also muss ich entsprechend das umrechnen und ich muss die Summe
der abgesandten Minus der Summe der Eingang und Beträge immer entsprechend hinzuzählen und dann weiß ich, was ich entsprechend habe.
So, liegt einfach da dran, dass ich,
wenn ich meinen Stand angebe und das, was ich abgesendet habe,
dann muss es irgendwann wieder ankommen und wenn es schon angekommen ist,
dann muss ich da wieder abziehen und das,
was noch nicht angekommen ist, hat man selbst sozusagen dazu gepackt.
Okay, dann hatten wir das nächste Problem,
was wir, was jetzt auftreten kann, nämlich,
dass wir bei unserem verteilten System das Problem haben,
dass wir in irgendeiner Weise in der Vergangenheit haben und die dich
das jetzt im grünen Bereich hier und dann entsprechend diese Nachricht,
die wir jetzt dort haben, die sozusagen aus der Zukunft in die Vergangenheit reicht.
Und damit haben wir so genau das Problem, dass wir
Nachrichten aus der Zukunft in die Vergangenheit da drin haben.
Und das muss man jetzt irgendwie auch wieder berücksichtigen,
muss halt schauen, wie man damit entsprechend umgeht.
Und das haben wir versucht, irgendwie hinzubekommen,
dass wir jetzt solche Dinge hier mit einführen,
dass wir die Schnitte entwickeln, anders legen und Dinge anders errechnen.
So, wir haben so eine logische Uhr, Logical Time,
und wir haben die für die Ereignisse jetzt Folgendes festgelegt,
dass dieses 4-1 vor dem 4-2 ist,
wenn die logische Uhr kleiner ist als die andere logische Uhr.
Und bei diesen logischen Uhren haben wir dann entsprechend so eine Fortrechnung gemacht,
was wir hier oben in diesem für den konsistenten Schnitt sozusagen hier besprochen hatten.
Gut, die Sachen hier sind,
dass hier etwas verschickt wird an P1,
und zwar sind es die entsprechenden Nachrichten,
wobei eben dann zwei Einheiten oder eine Einheit jeweils geschickt wird
und man das entsprechend umrechnen musste
Dann hatten wir uns das angeschaut, wo ihr sozusagen
nochmal nachlesen könnt und euch sozusagen gewisse Motivationen herholen könnt.
Wer es dann ebenfalls genauso beschrieben hat,
dass dieses Problem hier auftritt und hier mit der entsprechenden Lösung,
mit dem entsprechenden Hochzählen, was er jetzt ein Tick anders macht,
als wir das nachher noch beschrieben haben.
So, eine der Anwendungsbereiche hatte ich genannt,
waren die Datenbanksysteme, wofür wir das haben möchten,
weil wir gerne konsistente Datenbanken haben möchten.
Das war sozusagen die Idee. Da hatten wir einen Lämperzeitstempel,
das ist genau das,
was da dahinter steht
Und jetzt haben wir noch sozusagen die Idee,
dass wir so eine totale Ordnung drauf haben müssen.
Noch ein weiteres Buch, was ich jetzt noch nicht angeführt habe,
was ebenfalls diese Teile bearbeitet und wo ihr halt nochmal nachschauen könnt,
wenn euch das interessiert, dass ihr mit an anderer Stelle irgendwie vertiefen wollt.
So, dann haben wir die entsprechende Landfahrtordnung. Das heißt,
wir wollen in irgendeiner Weise aus der Strickordnung auf diesen Prozessen,
aufgrund der Zeitstempel, eine totale Ordnung herstellen und fügen also
jetzt da zu diesen logischen Uhren jetzt noch eine Reihung ein,
die wir jetzt willkürlich wählen und definieren,
indem wir die Prozessoren durchnummerieren.
Wir halten noch irgendeine andere eindeutige Zuordnung oder eine Betriebrechnung
haben können
Und erreichen damit eine entsprechende Möglichkeit, diese logische Uhr,
ein bisschen Zeitstempel entsprechend eindeutig zu machen.
Und zwar schaffen wir es eben genau so,
dass entweder ist das so und so so,
dass das eine kleine ist, als das andere bezüglich der Zeit oder
aber die Prozessnummer hier muss entsprechend kleiner sein.
Okay, das ist das, die Taibrek-Ruhe, die wir da drin haben von Lempert.
Wir können das jetzt genau senden mit den logischen Zeitstempeln machen,
hatten wir gesehen, wir haben also diese Nummerierung hier entsprechend drin,
jetzt habe ich ihn doch nicht rausgenommen, Informationen.
So, und da haben wir jetzt die entsprechende,
sprechende Möglichkeiten, die dieser eindeutige Ordnung eben herzustellen,
indem wir jetzt genau diese zeitlichen Ordnung erstmal nehmen und dann
innerhalb der jeweiligen Zeit das dann umsortieren und aufgrund der Prozessoren anordnen.
Gut. So, dann haben wir gesagt, okay,
jetzt noch ein bisschen weiter, jetzt geht es also los,
dass wir das hier jetzt gesehen haben und steck ist
die Redaktion kleiner aber die Vorrelation exakt da.
Das heißt, gilt auch die Umkehrung. So,
und jetzt wollen wir mal schauen, wie das aussieht.
Das heißt, wenn wir das jetzt hier haben,
ob wir das Ganze auch umkehren können.
So, und jetzt ist natürlich die Frage,
hier ist zwar irgendwie so eine logische Uhr von da,
aber da können wir irgendwie das mit dem vorher nicht hinbekommen.
Das ist halt nicht drin. So, jetzt ist die Frage,
kriegt man das irgendwie wieder zurück oder was passiert hier eigentlich an der Stelle,
wenn es darum geht? Jetzt haben wir eine Definition,
das 4-1 heißt unabhängig von den 4-2
bzw. 4-1 heißt nebenläufig, zu viel 2,
was wir genau mit dem doppelten Balken sozusagen jetzt hier kennzeichnen.
Falls gilt, dass diese beiden also nebenläufig sind,
dann entspricht das eben,
dass nicht das 4-1 vor dem 4-2
liegt und nicht 4-2-4-4-1.
So, wir sagen also etwas genau,
was wir vorhin schon hatten. Wir sagen nicht aus,
wer da vor wem liegt und dadurch bekommen wir das hin.
Gesucht ist also eine strikte Ordnung auf dieses Parallel
sozusagen genau darstellt. Sind wir wieder bei diesem Teil,
wie relationär wir diese Teile und wie bekommen wir das
da entsprechend mit rein
Und das sind die entsprechenden Nachrichten, die man irgendwie aussehen kann,
wo man, wir haben eben das andere Beispiel schon,
wo man sehen kann, dass das ein Problem ist.
So, was wir jetzt machen,
ist ja für uns so eine Art Vektorzeit ein.
Das heißt, wir fangen jetzt nicht an,
die entsprechenden Sachen durch das Netz sozusagen zu propagieren, damit das eingeführt wird.
Sondern wir möchten jetzt hingehen und für jede Funktionseinheit eine eigene
Variable VI einführen mit den Werten, die eben N hoch N hat.
Und das N ist dann die Anzahl der entsprechenden Prozessoren.
Und wir fangen mit dem Null-Dektor einfach an,
mit der quasi lokalen Anfangszeit sozusagen. So,
wenn wir jetzt also auf dem PI sind,
und es passiert ein Ereignis in irgendeiner Weise,
also dass entweder etwas abschicken oder wir erhalten etwas,
was wir innerhalb des Prozessors auf jeden Fall irgendwie eindeutig zuordnen können.
Also wir sagen jetzt nicht,
ja gleichzeitig kommen wir jetzt hier irgendwie, während ich abschicke,
habe ich gleichzeitig noch irgendwie was da entsprechend ankommen.
Soll ich sagen, entweder liegt das,
kommt erst das Absenden oder erst das Empfangen oder umgekehrt,
aber innerhalb eines Prozesses behaupte ich,
kann ich das eindeutig regeln durch einen lokalen wechselseitigen Ausschluss.
Das kriegt man auch normalerweise geregelt
So, wenn also so ein Ereignis irgendwie auftritt,
dann wird innerhalb dieser Prozessor Umgebung diese Variable hochgezählt.
Damit habe ich eine eindeutige Ordnung, wie wir sie vorher
auch schon hatten, innerhalb des jeweiligen Prozesses aus.
So, das ist ganz schön. Jetzt ist die Frage,
was müssten wir das, hatte ich vorher ja auch schon.
Jetzt ist so die Frage, was übertrage ich denn jetzt
eigentlich an die nächsten, an die weiteren Sachen?
So, und was man jetzt macht, ist,
wenn wir so ein entsprechendes Ereignis verschicken,
verschicken wir den ganzen Vektor, den wir kennen gerade.
Am Anfang ist es natürlich 0-0,
werden das gleich noch am Beispiel sehen.
Und die Idee ist dann, dass man seine eigene Zeit mitschickt,
sodass die eigene Zeit sich im System verbreitet. Man weiß,
das letzte Mal, wenn ich von dem was bekommen habe,
war der im Zustand 1, 5,
8 zu einem bestimmten, den er mir mitgeteilt hat.
Und das sortiere ich bei meinem eigenen Teil ein.
Und ich kann für mich selbst immer etwas hochzählen, aber das,
was ich von einer bekomme, das übernehme ich so,
wie es ist.
Weil du nicht weißt, dass Dumzustand 1 und Dum3 bist und du in 8
Und ich bin im Zustand 2. Dann hätte ich einen entsprechenden
Vektor mit 4 und ich hätte genau diese Zahlen da drin und würde,
wenn ich eine Nachricht erhalte, eure jeweiligen Zustände erstmal entgegennehmen.
Solange ich nichts gehört habe von euch,
bin ich alleine im Zustand 2 und der Rest ist für mich null,
weil ich sozusagen vorher noch gar nichts weiter hatte.
Und wirst du dann, wenn ihm mir irgendwas schickt,
dass da, wenn eine 8 als 8, als Einheit ist,
dass da acht Ereignisse schon gewesen sein müssen, wie auch immer.
Und die müssten irgendwie bei mir mitgeteilt werden. Und wenn
ihr euch bei mir meldet und ihr seid 1 und 2,
würde ich trotzdem sozusagen davon ausgehen, dass die anderen acht Ereignisse irgendwo,
Das gesamte System ist irgendwo nochmal ankommen wird.
Das heißt, dass auch später anders bei anderen Leuten auch weiter hochgezielt wird. So,
dieses, die Idee ist dann, dass ich,
wenn ich dieses VI jetzt nehme, nämlich also das entsprechende Maximum,
nämlich von dem, was ich bisher kenne, nämlich die Null,
und eure Zahl und packt die dann entsprechend da rein,
weil die mir genau mitgeteilt wurde.
Dadurch zähle ich sozusagen meine eigene Zahl hoch. Das heißt,
ich aktualisiere die entsprechende Vektorzeit in Bezug auf die anderen Komponenten.
Da packe ich immer nur rein, was ich erhalte
Und wenn ich irgendwas verschicke, nehme ich das,
was ich kenne und da ich ja ein neues Ereignis mache oder erzeuge,
meinen eigenen Stempel, den ich dann nur eins erhöht habe und verschicke den dann.
So, das ist also das, was dann hier entsprechend
letztendlich gesammelt wird in den einzelnen Prozessoren, die mir das anschauen.
So, wie sieht das jetzt aus? Dieses Teil,
dieses Sternchen da unten soll mich daran erinnern,
dass auf dieser Fuhr jetzt ein Fehler ist und die Idee ist jetzt,
dass Emil sagt, wo der Fehler ist,
den wir eher so im grundlegenden Teil erklärt haben,
wie das Ganze aussieht.
Ich weiß jetzt wieder vergesse. Also,
wir starten hier mit 000, das ist sozusagen unsere Vektorumgebung,
mit der
wir loslegen
Wir haben jetzt die entsprechende Abbildung, die wir jetzt hier definieren.
Und können jetzt hier mit der Vektorzeit in irgendeiner Weise arbeiten.
So. Und was wir jetzt haben, ist, dass da oben,
wenn die erste Nacht verschickt wird, das hochgezählt wird.
Das ist der Haftbubbel dann. So, das Gleiche gilt
hier. Was passiert an dieser Stelle? Naja,
ich erhalte hier die Eins von dieser Seite hier,
von dem Prozessor Null
Übernehmen sie hier und ziele da es ein neues Ereignis ist für den Prozessor 1,
der in der zweiten Komponente steht, auch entsprechend um einen hoch.
Und der dritte bleibt erstmal unverändert. Johann ist das Gleiche
, ich schicke jetzt was los. Das heißt,
ich selber setze mich sozusagen als Prozessor Nummer 2,
der in der dritten Komponente steht,
auf eins und verschicke das, was ich weiß.
Was passiert denn hier? Naja, hier passiert ein neues Ereignis,
die eins von hier oben bleibt unverändert, die zwei wird entsprechend hochgezählt,
weil hier ein weiteres Ereignis stattfindet und die eins wird entsprechend übernommen.
Hier oben, der kennt erstmal nichts anderes,
der schickt erstmal runter lustig los und hat die zwei und sendet die hier unten hin.
Hier unten kommt dann die Information an, aha,
Prozessor Nummer 0, also in der ersten Position hier,
der ist im Zustand zwei, das weiß ich jetzt auch hier unten.
Der zweite, da weiß ich immer noch nichts drüber,
weil da habe ich noch keine Nachricht von erhalten,
da habe ich was hingeschickt und so weiter,
aber ich weiß davon nichts.
Und bei mir ist die zweite, weil ich habe das zweite Ereignis auf dieser Geschichte.
So, wo liegt im Folgenden der Fehler? Beim Sinne von,
was heißt 2, 84, 1, bei 4, 84.
Da ist die erste Komplente, die wird nicht maximiert.
Genau, das ist also eine Sache, die nicht so
schön ist. Wir haben also jetzt genau dieses 2003,
was wir eigentlich hier verrennen wollen, warum die drei,
naja, weil wir halt das dritte Ereignis haben und die es losschicken sollen.
So, und dann ist das hier hinten schon mal richtig eingetragen.
Hier wird also eine 3 draus,
es wird auch eine Vierte aus diesem Teil,
weil das jetzt richtig das vierte Ereignis auf dieser,
für diesen Prozessor hier eigentlich ist, aber die 1 ist falsch,
weil sie halt sozusagen nicht entsprechend richtig übernommen wird.
Das heißt, an der Stelle gehen wir halt rein und
setzen das und dann im Folgenden auch genau das Gleiche.
Natürlich sehen wir auch schon, dass das dann hier genauso fehlerhaft war.
Wenn man noch weiß, dass quasi der Brenner ja eh
quasi müsste es ein Ereignis höher geben muss.
Warum merkt man nicht, dass uns die anderen nicht schon warten,
falls sie eine Anime-Näherung schmalz zu machen?
Welche Art von Annäherung soll denn das jetzt sein? Also ich,
wenn ich jetzt hier unten stehe und ich kriege jetzt hier irgendwas an,
dann weiß ich ja nicht, wohin diese Nachrichten geschickt werden.
Also ich weiß nicht, wo im System diese Aktivitäten stattfinden.
Und wenn es mehr als drei sind, dann wird es
auch wirklich schwierig, um zu wissen, wo es dann hingeht.
Hier könnte man es noch irgendwie rückschließen, weil man ja den dritten hat.
Das ist richtig, dass die Idee ist nicht ganz verkehrt.
Natürlich bei dritten kann man irgendwas schließen,
dass das wohl, wenn ich es nicht gewesen bin,
Dass genau diese Informationen und so weiter,
wer was wohin geht und was man verschickt hat,
steckt da nicht drin.
Weil man stellt sich ja nur den eigenen Zustand und das Wissen, was man gerade hat.
Und dadurch kann man das nicht Schlusszeuger, Entschuldigung. So,
die entsprechende partielle Ordnung kriegen wir also über diese VIs sozusagen,
dass wir die jetzt sozusagen hinbekommen hier,
indem wir nämlich die ganzen Vektoren uns angucken und jeweiligen Komponenten anschauen.
Genau, was wir eben leider halten.
Und die entsprechende strikte Ordnung ergibt sich ebenfalls. So,
jetzt ist die Frage, sind jetzt damit alle Sachen
eindeutig sortiert
Nein, noch nicht, sehr lehrt. Wir halten vergleichen Sektoren. Und da kann man,
also das für alle Aussage, für das Kleiner gleichgemacht,
aber es kann ja sein, dass die überhaupt nicht vergleichbar sind.
Ich glaube, darauf läuft auch das Ziel der Nordrestauranten.
Genau, richtig. Strikte Ordnung gilt für diesen Fall,
aber die Dinge heißen unvergleichbar unsere Vektoren hier in dem Augenblick,
wo wir eben genau diese Eigenschaft,
die wir vor gerade gefordert hatten,
nämlich, dass nicht das eine kleine,
jetzt andere oder größer ist als das andere,
haben wir das Problem,
dass wir hier das
nicht vergleichen können
Und damit sind die unvergleichbar, dann sind die also nicht total geordnet.
Und genau das, was wir auch eigentlich haben möchten,
wenn es im System sozusagen möglich ist, das zu beschreiben.
Denn wenn ich das jetzt als verteilte Dinge ansehe und ich keine weiteren Beziehungen dazwischen habe,
dann sind sie auch unabhängig und sind sie auch wirklich nebenläufig dazu.
In dem Augenblick, wo ich jetzt wieder weitere Ressourcen einfüge,
müsste ich dieses Wissen über die Ressourcen in diese Information mit einbauen,
damit ich weiß,
ob ich vielleicht doch eine Sequenzialisierung dort auftritt,
weil die sich um diese Ressource eben sozusagen bewerben müssen und dann versuchen müssen,
sich zu einigen,
wer das zuerst bekommt,
sodass sie nicht
in echt nebenläufig sind
So. Die, dieses 4-1 heißt unabhängig davon oder
nebenläufig genau das, was wir hier hatten.
Also genau die Definition, die wir eben schon hatten.
Das entspricht genau dem, was wir da jetzt als Beobachtung auf diesen Ordnungen,
die wir jetzt da finden können, wieder eintreffen.
Das bedeutet, wir haben die Definition,
die wir am Anfang der Veranstaltung letztes Mal hatten,
mit den entsprechenden mathematischen Darstellungen.
Jetzt hier wieder sozusagen eigentlich zusammengeführt und können uns jetzt
sozusagen verschiedene Begriffe rausgreifen, um im System bestimmte Zustände entsprechend
zu beschreiben
Und das ist auch sozusagen relativ eindeutig. Und nachher auch
dann wieder maschinell abbildbar. Das ist schön sauber, alles
aufgeschrieben werden kann. Es ist also nicht mehr nur so,
dass ich das irgendwie im Kopf habe und mir allgemein was überlegt habe,
wie ich denn wäre, vor wem und was abgesprochen habe,
sondern ich kann das mathematisch aufschreiben.
Und damit haben wir mit unserem Rechner halt die Möglichkeit,
das auch sauber abzubilden. So, jetzt hatte ich hier
das Gleiche nochmal. Jetzt haben wir so einen entsprechenden Satz,
dass diese Vector-Clock kleiner ist VI,
ist kleiner als diese Vector-Clock für 4-2. Genau dann,
wenn wir 4-1 vor 4
-2 haben
Und in dem Moment, wo die beiden jetzt hier nebenläufig sind,
was mir jetzt hier in der Ecke leider nicht sehen kann,
anscheinend ist der Beamer verrutscht in diese Richtung hier,
sind sie halt unvergleichbar.
Und wir haben aber auf jeden Fall eine Möglichkeit,
diese Beziehung hier so aufzuschreiben, dass wir sagen,
wenn das eine Ding echt klein ist, das andere,
dann muss sie auch vorher liegen.
So, und für den Fall,
wo das nicht echt kleiner ist,
wo ich sie unvergleichbar habe,
in dem Augenblick sage ich halt,
okay,
die sind halt irgendwie nebenläufig zueinander und ich kann darüber
nichts aussagen
Gut, das kann man sich jetzt hier nochmal genauer angucken,
hat irgendwie so eine Präzedenzen, die man da einfügen kann.
Auf jeden Fall ist das schon mal innerhalb der jeweiligen Prozessoren ja klar,
wie das aussieht, dass sie nämlich sagen kann,
ja, hier, die sind jeweils vorher,
das sind die entsprechenden roten Pfeile.
Ich kann auch noch sagen, jo,
das hier vorne muss auch noch sein,
weil ich ja hier diese entsprechende Nachricht da drin habe.
Und das Gleiche gilt auch für das untere Teil.
Hier oben gilt es nochmal, das sind genau die Nachrichten,
die wir da drinnen haben.
Und jetzt ist natürlich die Frage, was ist mit dem unvergleichbar?
Achso, habe ich jetzt gar nicht mehr eingezeichnet in dem
Ding hier.
Ich kann nochmal zurück
So, welche sind jetzt sozusagen unvergleichbar oder nebenläufig?
Ja, eigentlich 2-1 und 2. April.
1-1, 0 und 9-1.
Und 9-1 und 2-0 und 9
Mhm. Genau. Man kann sich also angucken, wo man hier Schnitte durchlegen kann.
Wir werden gleich noch mal bei den Prozessen dann auch noch mal sehen,
wie man dort entsprechende Schnitte durch das System liegt,
die also über das ganze System hinweggehen und über die jeweiligen
Zustände erfassen und damit die Möglichkeit haben,
genau die echte Nebenläufigkeit oder maximal Nebenläufigkeit einem System entsprechend zu beschreiben.
Und je nachdem, wie weit man durch das System schneiden kann,
kriegt noch mehr oder weniger Nebenläufigkeit in manchen Systemen hin.
Das werden wir noch uns genauer anschauen
Gut. Jetzt die Frage, ob das sozusagen geht mit
der Aufgabe. Und das ist natürlich das,
was wir dann hier entsprechend natürlich genau aufgebaut haben.
Und hier habe ich jetzt auch mal eine Folie,
von der ich meinte, ich hätte eben schon,
dass wir entsprechend hier die Schnitte durchlegen können, was sozusagen,
wo wir auch so eine Art von Unabhängigkeit sozusagen jetzt wiederfinden können.
Beziehungsweise Schnitte, wo wir eindeutig einen Schnitt durchlegen können und das berechnen können,
wie das Ganze jetzt aussieht für die entsprechende Bankleitung.
Das Gleiche ist natürlich dahinter, also immer so,
dass man einen sauberen Schnitt hinbekommt
So, dann sind wir damit durch.
Achso, jetzt bräuchte ich noch mal die... So,
jetzt kommen wir zu meinem Thema, mit den Petri-Netzen.
Und an der Stelle wollte ich erstmal über die allgemeinen Eigenschaften
ein bisschen was erzählen.
Um dann in die entsprechenden Hintergründe
zu gehen
Also, warum beschäftige ich mich sozusagen auch selbst gern mit diesen Netzen?
Sie sind im Grunde genommen zum einen ein formales Modell,
was die Automaten erheblich erweitert und dem heutigen System wesentlich besser entspricht,
weil wenn ihr euch die ganzen Rechner,
die alle verteilt sind, als Ressourcen,
wie ja teilweise schon bei euch selbst mit euch rumtragt mit eurem Smartphone und dem Rechner,
dass ihr irgendwie synchronisieren müsst und irgendwie zusammenbringen müsst,
läuft das Ganze sehr verteilt ab.
So, wenn ihr jetzt das Thema also entwickelt,
sage ich mal so,
die Entwicklung von Einzelplatzsystemen
ist heutzutage weitgehend geklärt
Bis auf natürlich irgendwelche speziellen Algorithmen,
wenn es besonders schnell auf einem Prozessor laufen soll.
Also was, das sind immer noch Dinge, wo man
immer noch eine Menge machen kann. Aber die Schwierigkeiten,
denen ihr heute gegenübersteht, ist die Entwicklung vom verteilten System.
Also insbesondere für die Webservice-Geschichten ist das ein Thema,
was an euch nicht vorbeigehen wird.
Und inzwischen ist ja auch in den Sprachen entsprechend,
bringt man dort an vielen Stellen Erweiterungen, die es ermöglichen,
Nebenläufigkeit abzubilden. Was ihr braucht, ist,
ihr braucht ein Konzept im Kopf, was wirklich das darstellt,
was die Wirklichkeit reflektiert.
Und mit endlichen Automaten kommt ihr da nicht weit
Oder mit einem einfachen Kellerautomaten. Ihr braucht diese Begriffe,
um die entsprechenden Sprachen zu verstehen und bestimmte Vereinfachungen vorzunehmen,
damit man leichter über die Sachen reden kann.
Also wenn ich über einen Lichtschalter rede,
will ich nicht da sozusagen eine ganze Juri-Maschine mir hinter vorstellen,
sondern ich will es an Ausmöglichkeit eigentlich nur dahinter haben.
Man muss also immer adäquate Modelle haben. Euer Problem ist,
wenn ihr Software heutzutage schreibt, braucht ihr nebenläufige Ausdrucksmittel.
Und dieser Spaß ist jetzt, wie kriegt man es am besten hin?
Da gibt es verschiedene Lösungen in der Informatik und die Petrinetze
bieten euch eine von den Lösungen.
Das ist also nicht das Einzige, was das Ganze löst,
aber es ist auf jeden Fall eins,
was es schon mal grafisch angucken könnt
Unformal. Das heißt, es gibt die Möglichkeit,
für euch etwas nachher auszuführen,
auf dem Rechner und gleichzeitig könnt ihr auf der Oberfläche sehen,
wie ihr irgendwelche Pfeilchen ziehen könnt und sagen könnt,
was passiert denn hier gerade?
Das könnt ihr normalerweise bei eurem Java-Programm nicht,
da braucht ihr den Debakka und dann guckt ihr in irgendwelche Variablen rein,
irgendwelche Zustände und ihr kriegt nicht sozusagen irgendwelche Grafiksachen,
wo irgendwas so durchläuft oder sowas angezeigt.
Das ist relativ schwierig, das zu visualisieren,
so eine Fortschrittsgeschichte dabei zu erkennen.
Auch dazu werden wir dann nachher bei den Prozessen nochmal
eine Idee bekommen, was man sich dahinter vorstellen kann
So, die Verwendung von den Netzen passiert eben einerseits auf diesem grundlegenden Phänomen,
wo man eben auch mit aufgrund der mathematischen Hintergründe
Sachen sehr präzise und genau ausdrücken kann.
So, da ist bis heute werden da immer noch seit
dem Anfängen der Petrinetze werden dort immer noch wieder theoretische Ergebnisse gefunden,
die immer noch wieder neue Ergebnisse liefern.
Die Fortschritte aktuell in der Forschung passieren aber im Wesentlichen nachher in höhersprachlichen Dingen.
Das heißt, die passieren in dem Bereich Softwareentwicklung,
Nutzung davon, Prozessbeschreibungen im Produktionssystem oder eben in der Wirtschaft
oder Geschäftsprozessen
all diesen Themen
Dort findet man jetzt solche Beschreibungstechniken, die häufig auf Basis
der Petri-Netze definiert werden. Das heißt, die Phänomene,
die in all diesen Techniken, sei es Activity-Diagramme,
Epicars oder BPNN oder BPL oder so findet,
werden ganz oft mit Hilfe von Petri-Netzen beschrieben.
Und mehr Phänomene, als bei den Petri-Netzen, wer die dort nicht finden,
ihr werdet nur abkürzten Schreibweisen für sie Sachen finden, aber keine neuen Phänomene.
Das heißt, wenn ihr in der Lage seid,
diesen Teil, was jetzt hier kommt, sozusagen wirklich zu verinnerlichen,
dann könnt ihr euch die anderen Sachen sehr gut erklären nachher und damit mitnehmen,
wo dort Schwierigkeiten stecken und wo Merkwürdigkeiten in den Systemen drin liegen.
Wird insbesondere dann spannend,
wenn ihr selber solche Maschinen programmieren sollt und solche Umgebungen oder Sprachen selber beschreiben sollt,
dann müsst ihr wissen,
was ihr anrichtet in Bezug auf die Nebenläufigkeit oder auf Konflikte oder auf Konfusionen oder was da noch alles noch kommt.
So, die allgemeinen Eigenschaften von Petri-Netzen. Als erstes Mal
haben wir eine grafische und ein Äquivalent der allgebranchenen Textuelle Darstellung.
Das heißt, genau das, was ich eben gerade meinte,
ihr könnt so gute Grafik sehen,
als auch nachher irgendwie ein bisschen Mathematik, ein bisschen Magic dahinter haben.
Es gibt formal abgesicherte Algorithmen für die Analyse,
das heißt, ich kann ganz klar Sachen beweisen,
warum bestimmte Eigenschaften im System drin sind
Was auch nicht so einfach ist, wenn ihr von einem Java-Programm
bestimmte Dinge beweisen sollt, dann ist das relativ anstrengend.
Beweise für Programme im Umfang von 10.000 Zeilen Code gibt es durchaus,
aber es sind die Ausnahmen und das sind speziell entwickelte Programme,
wo man gerade jetzt sozusagen Forschungsstand ist,
wie man in so einem Java-Programm auch wirklich im Hinblick auf die Eigenschaften bewiesen bekommt.
Aber das sind dann auch keine kleinen Dinge mehr,
sondern das sind wirklich große Anstrengungen, damit man solche großen Code-Fragmente
dann auch wirklich noch im Hinblick auf Eigenschaften abklopfen kann.
Dann gibt es Abstraktionen und hierarchische Strukturen.
Das ist eine Sache,
die ganz wichtig ist
Netze sind erstmal ein ganz einfaches Spielchen.
Unten drunter mit, wie man schon sieht,
so irgendwie Stellen und Transitionen und irgendwelchen schwarzen Marken drauf.
Und wenn nur genau eine draufliegen darf, dann hat man
so das grundlegende Modell. Und jetzt kann ich darauf eine
Menge definieren. Was ich aber machen kann, ist,
ich kann Sachen zusammenfalten, oder noch die Faltung noch eingehen.
Und zusammenfassen und dann immer astrakter zusammenlegen. Letztendlich kriegt man
das so lange zusammengefaltet, bis nur noch ein einziges,
eine einzige Transition und eine einzige Stelle da ist mit zwei Kanten dazwischen.
Und der Rest ist Programmtext. Wenn man diese Faltung dann
entsprechend über allgebrage Ausdrücke wieder hinbekommt oder entsprechende Beschreibungssprachen
Das bedeutet, ich kann also auch mein Java-Programm an eine Transition ranschreiben und daran ausfüllen lassen.
Und da auch den variablen Werten arbeiten lassen und das sogar nebenläufig,
also zu sich selbst nebenläufig, was mehr ist als das Java-Programm normalerweise kann.
Auch dazu wäre ich noch ein bisschen mehr am Ende der Veranstaltung erzählen,
wenn ich ein bisschen was zu Rinho nochmal im vertieften Sinne erzählen darf.
So, dann gibt es eine hochentwickelte Theorie der Nebenläufigkeit,
Concurrency-Theorie, das ist genau das,
wo Petry eben angefangen hat und 62 Jahre darüber promoviert hat,
dass eben genau dazu sozusagen die grundlagen gelegt werden und das ist sozusagen das,
womit man mit diesem Begriffsmittel eine Menge erreichen kann.
Wie gesagt, endliche Automaten sind in vieler Hinsicht schöner,
sind nämlich einfacher, lassen sie einfacher darstellen,
ich habe nur Zustände und Kanten und muss mich nicht mit
irgendwie noch mehr Elementen darum herumärgern und hier noch irgendwelche komischen Kästchen dazwischen malen,
dass also in der Hinsicht eigentlich viel schöner ist und endlicher Automat.
Nur ist das, wofür ich ihn verwenden kann, nicht so ausdrucksstark wie das,
was ich bei Netzen erreichen kann. Dann kommt dazu,
dadurch, dass wir die Allgewahr da oben haben,
haben wir die Möglichkeit, Dinge zu entwickeln am Rechner,
die sich dann Rechnerwerkzeuge oder Softwarewerkzeuge, wie auch immer,
schimpfen und mit denen wir dann editieren können,
wir können also das Ding bearbeiten und ändern und hinzufügen und löschen und so weiter und so fort.
Wir können es simulieren. Wir können also dieses Verhalten,
das wir hier drauf jetzt definieren, wie sich das verhalten soll,
diese statische Beschreibung, ebenfalls durchführen.
Und es gibt Analyseverfahren, wie es auch noch maschinell ausrechnen,
welche Eigenschaften da drin gelten.
Und zwar in sehr kurzer Zeit für einige Modelle.
Diese Simulation versucht mal, ein Klassendiagramm zu simulieren.
Füllt euch schwerfallen an der Stelle, wenn ihr sie direkt versucht.
Gibt auch da noch Sachen zu,
was man denn eigentlich machen kann,
aber im Normalfall passiert nicht viel in Bezug auf Simulation darauf
Selbst wenn eine UML-Activity-Diagramme nehmt, müsst ihr erstmal ein Werkzeug finden,
was das auch entsprechend gut beschreibt und mit einer eindeutigen Semantik ausführt.
Oder wenn ihr BPL oder BPMN nehmt. Diese Engines sind dann,
jetzt werden auch entwickelt, aber sie müssen irgendwie dahinter liegen,
diese Nebenläufigkeitsprobleme, die wir auch haben, lösen.
Und da haben wir eben bei den letzten nette Sachen.
So, für euch gilt dieses Teil hier als das Werkzeug,
was wir die nächsten fünf Wochen benutzen werden.
Das gilt also auch für die Hausaufgaben,
dass ihr euch das von dort runterladet und entsprechend in
den Übungsaufgaben einsetzt und benutzt
Die Oberfläche ist halb 15 Jahre alt. Das heißt,
es gibt da diverse Dinge, die man heutzutage
ein bisschen besser darstellen würde, ticken anders designen würde.
Zu dem Zeitpunkt, wo es entwickelt haben,
haben wir halt von den neuesten Oberflächen, die Frameworks zusammengefasst und haben die benutzt.
Und aufgrund von Lizenzbedingungen haben wir dann halt darauf verzichtet,
uns direkt unter Eclipse zu packen,
die damals noch nicht ganz so weit waren,
aber eine serigide Lizenz gefahren sind.
Dadurch gab es sozusagen bestimmte Entscheidungen,
die vor langer Zeit gefallen sind,
sodass die Oberflächen optimal ist
Aber dahinter liegen die entsprechenden Algorithmen,
die wir bis vor eine ganze Weile noch entwickelt haben.
Und das ist sozusagen der neueste Stand von dem,
was man, weil wir dieses System als Plugin-Architektur aufgebaut haben
und dadurch kontinuierlich weiterentwickelt und weiter aufgebaut haben.
Die zugrunde liegenden Algorithmen da drin,
sind von Olaf Kummer entwickelt worden in seiner Dissertation.
Und das ist halt jetzt 15 Jahre weit her.
Die Benutzung ist zwar 15 Jahre alt, aber es gibt darin Konzepte,
die bis heute in anderen Werkzeugen auch noch nicht unbedingt Einzug gehalten haben.
Also wenn man in anderen Werkzeugen guckt oder auch UML-Werkzeugen oder
Bibelwerkzeugen gibt es in den im Reniue diverse Feature,
die bis heute nicht in anderen Werkzeugen eingebaut sind.
Deswegen ist es auch nicht einfach so einfach ist, das einfach so abzusetzen.
Das nächste ist, dass die Bittenetze generell universal sind in der Anwendbarkeit.
Also das ist das, wo ich mich immer so ein
bisschen oute. Ich bin in der Lage inzwischen,
nachdem ich mich so viele Jahre damit beschäftigt habe,
in diesen Netzen quasi zu denken.
Das heißt, ich kann das immer auf die einfachen Netze
unten drunter abbilden. Wenn ich irgendein Problem mir genau angucke,
bin ich in der Lage, das auf diese Sachen abzubilden,
bin aber auch in der Lage, dadurch,
dass es eben diese Hierarchisierung und Abstraktionen gibt entsprechend,
auch Sachen sozusagen abstrakter zusammenzufassen
Und wie das geht, da werde ich
euch in dieser Veranstaltung nur einen kleinen Teil mitgeben können.
Das wird dann stärker vertieft in den Vertiefungsveranstaltungen, hatte ich ja schon erwähnt,
mit Rudium verteilter Systeme oder unseren entsprechenden Softwareentwicklungsprojekten,
mit denen wir dann so etwas machen.
Gut, die entsprechenden Varianten, die es dann jetzt hier noch gibt,
das ist so ein anderes Problem. Wenn ihr losgeht und sagt,
ja, ich habe in Hamburg was mit Petrinetzen gemacht,
dann werden eigentlich alle Informatiker in Deutschland sagen, ja,
ja, kennen wir, das mit den schwarzen Boppeln schalten dann halt da und das ist dann Nebenläufigkeit.
Das ist so, das ist das,
was man üblicherweise außerhalb so ein bisschen so erst mal wahrnimmt oder was auch Leute,
die schon länger weg sind aus der Uni sozusagen kennen.
Inzwischen gibt es jede Menge Erweiterungen da drin,
die alle mit Spezialfälle entwickelt haben,
bis hin zu gar keiner operationalen Semantik mehr,
also noch seine darstellendes Teil in Richtung auf Kanalinstanznetze,
bis hin zu Zeitnetzen, dass ja also Zeit in diese Netze mit einbaut,
was normalerweise in diesen Beschreibungen wir noch sehen werden,
gar nicht so einfach unterzubringen ist oder sturassische Netze,
das heißt, wenn man Verteilungsfunktionen an den Transitionen dran und können da sagen,
wir sind an dieser Verteilung, wird jetzt hier geschaltet,
entsprechende hochsprachige Netze.
Wir haben also Java-Netze, wir haben Scream als Anschriftsprache.
Skala wäre zum Beispiel etwas, was ich mir immer noch wünschen würde.
An Python sind wir auch gerade dran, dass wir so einen Formulismus entwickeln,
was man, wie man das jetzt an Schriftsprache benutzt,
um dann die Operation im Netz mit unterzubringen.
Das andere ist eine Strukturierung da drin, Richtung Objektorientierung oder Agentenorientierung,
das ist das, womit wir uns dann auch entsprechend beschäftigen.
Gut, das heißt, es gibt dann noch
eine ganze Menge mehr, eine lange Historie der Petrinetze.
Hier in Hamburg haben wir noch eine Seite,
ich werde gleich nochmal
drauf eingehen
So, das war der Herr Petry, hier mit seiner Zigarre,
Zigarette saß er hier so und hat fleißig geschmückt.
Und die Informationen dazu findet man auf der Webseite,
wer es näher angucken möchte,
der Herr ist leider seit drei Jahren tot und von daher
können wir jetzt nur sozusagen die Ergebnisse von ihm benutzen.
Das hier war die erste Seite seiner Diss,
ist also schon eine Weile her und passiert eben Mathematik und Physik
und bietet sich also eigentlich nie richtig als Informatiker gesehen,
hat aber nun für die Informatik eine ganz wichtige Grundlage geschaffen
und ist auch mehrfach dafür geehrt worden für diese Sachen
aus dem Kontext der Informatik heraus
Die grafische Darstellung, naja, es soll angeblich schon so alt sein.
Im Wesentlichen hat die aber nachher Anna Tollholt im Wesentlichen Benutzen eingesetzt,
weil der sich sehr stark für Benutzbarkeit eingesetzt hat.
Also Verwendungsmöglichkeiten von diesem Formalismus. In Petris Arbeit findet man
nicht ein einziges Petri-Netz im Sinne von Kuller und Kästchen,
also Kreisen und Karsten. Wir erstellen Transitionen,
sondern nur in abstrakten Beschreibungen, was dort prinzipiell passiert.
Was der Prinzip passiert, werde ich gleich noch kurz darauf eingehen.
So, diese Darstellung hier ist dann eben die Idee,
dass man einzelne chemische Elemente zusammennehmen kann,
die was noch weiter dazu packt
Dieses Verschmelzen, über das Zusammenkommen von diesen entsprechenden Elementen sorgt halt dafür,
dass wir die weiteren Stoffe erhalten oder wir zerlegen können
und haben damit also eine einfache Beschreibung da drin.
Kästchen und Kreise ist eine zufällige Wahl gewesen.
Er hätte genauso auch andersrum sein können,
dass die stelleneckig gewesen sind und die Aktivitäten rund,
was dann vielmehr auch den Datenflussdiagramm und anderen Spezifikationssprachen zu der Zeit entsprochen hätte.
Aber das ist halt eine zufällige Wahl gewesen
und die fiel nun gerade so rum
So, dann kommen wir wieder auf die Uhren,
das, was wir vorhin schon hatten,
die gleiche Motivation war auch da,
dass man diese Verteilung von Uhren hatte und in irgendeiner Weise von Minkowski angeregt,
diese entsprechenden Linien hat, sodass ich also A,
4B habe, dass ich also sehen kann,
das liegt vor dem irgendwie in diesem Zeitkorridor.
Und dazu dann entsprechend parallel oder nebenläufig die entsprechenden A- und C-Geschichten,
die jetzt hier als nebenläufig eingezeichnet werden können an diesen Stellen.
Wir haben ein bisschen genauer reinschaut, sieht das so aus,
dass sich so eine Art Lebenslinie habe oder mehrere Lebenslinien Und entsprechend jetzt in dem Kegel,
was jetzt hier so noch im Laufe der Zeit passieren kann,
ist so Lebensliebe von jeweils einzelnen Entitäten, die irgendwie in diesem ganzen Kontinuum,
was ich jetzt hier gerne betrachten möchte, noch drin ist.
Und da hat er dann eben gesagt, okay,
wenn sich diese Ereignisse genau schneiden, in dem Augenblick passiert die Handlung,
also genau das ist das, was relevant ist,
was nach außen und extensional beobachtbar ist,
was intern bei mir noch an Zustandsänderungen passiert,
das interessiert eigentlich niemanden weiter,
sondern genau die Ereignisse wollen wir uns anschauen.
Und damit man das Ganze ein bisschen entkoppelt,
packt man dazwischen auf den Zustand,
damit man die noch explizit darstellen kann
Es gibt eben auch Formalismen, die sich nur mit Zuständen
oder nur mit Ereignissen beschäftigen. Und die haben immer die Schwierigkeit,
dass sie nicht zeitgleich beides in einem Modell darstellen können.
Und deswegen haben die Netze eben gewisse Vorteile.
Der Nachteil ist, ich muss mehr zeichnen. Ja,
ich muss halt diesen Cola da einführen und das ist halt
der entsprechende Nachteil dabei. Unsere Lebenslinie ist sozusagen das Grundmodell,
was man sich vorstellen kann und das gilt für jede Art von Ereignis,
beziehungsweise jede Art von Systemen, was wir beschreiben wollen.
Wenn ich jetzt also irgendwelche Quarks beschreiben möchte und mir angucken möchte,
wann stoßen die zusammen und was passiert dort eigentlich,
kann ich diese Lebenslinien von diesen Teilen,
die ja teilweise sehr, sehr,
sehr kurz sind,
immer noch anschauen
Und beschreiben. Ich kenne genauso gut,
aber auch das Entstehen und Vergehen von Kulturen
mir angucken oder das Entstehen von Planeten und gucken,
wann stoßen die immer zusammen und wann was passiert daraus und so weiter.
Also was ich darunter fassen möchte, entspricht eben den jeweiligen Bedürfnissen dessen,
was man beschreiben möchte in einem verteilten System.
Und normalerweise gehen wir von einem verteilten System aus,
wenn wir über irgendetwas nachdenken. Häufig sind wir uns dieser
grundlegenden Phänomene dahinter dann gar nicht so bewusst. So,
eine der lustigen Ideen dann war,
ob das Universum eigentlich ein Computer ist, das heißt,
die Physiker haben auch mal nachgelegt und sich angeguckt,
ob sie das nicht noch
ein Ding anders darstellen können
Also alles Informationen, im Grunde genommen können wir das ganze Weltall als ein Informationsverarbeitungssystem angucken.
Das ist eine der Dinge, die es darin gibt,
ist ganz nett beschrieben in diesem Spektrum der Wissenschaft.
Und wer Lust hat, kann da ja mal in
der Bibliothek gucken gehen und dort mal einen Blick reinwerfen.
Deswegen wäre es mal als großes Netz, ist schon diskutiert worden von Konrad Zuse,
einer der Ehrendoktoren dieses Fachbereichs, wenn ihr in unserem Display,
was unten im Haus F-Jahr wird, so leuchtet,
seht ihr auch die Daten von dem so ein bisschen,
könnt ihr ein bisschen gucken.
Ansonsten gibt es in einigen Räumen auch entsprechende Tafeln,
ansonsten auf den Webseiten finde ich auch noch Informationen dazu
Und die beiden haben sich auch dazu ausgetauscht und haben ganz am Gerichte Diskussionen geführt.
Und der Ingenieur Zuse hat also durchaus gesehen,
dass man da irgendwie etwas mit anfangen kann,
weil er hat natürlich mit sequenziellen Maschinen schön gearbeitet.
Und war von der Idee von Petri eben sehr fasziniert,
wie man das auch nebenläufig machen kann.
Und Zuse hat also eine Menge schicke Sachen gemacht mit seinem
Computer und dem entsprechenden Plankalkül, was entsprechend entwickelt hat.
Aber das ist jetzt nicht so der Hauptfokus. Spannend waren,
dass er dann entsprechend Petri-Netzbücher dazu geschrieben hat,
weil er das so spannend fand, wie man das verwenden sollte, diese Teile.
Findet ihr bei uns, wie ihr seht, darunter auch
in der Bibliothek, diese Bücher? Okay, so,
jetzt geht es weiter mit den entsprechenden allgemeinen Eigenschaften von den Netzen und ja,
wir haben ja jetzt diese Möglichkeiten dort, was zu machen,
wenn wir gleich mal gucken.
Weiteres Buch, was für euch spannend ist, mal reinzugucken,
ist, dieses hier steht auch zuhauf in der Bibliothek,
das ist das von Falk,
der da einige Sachen beschrieben und diverse Teile von dem,
was wir hier jetzt beschreiben,
ist dort
wesentlich ausführlicher beschrieben
Ja, das heißt, zum Nachlesen mit Sachen unklar sind,
wenn Beschreibungen, Definitionen nicht in Ordnung sind,
oder ihr meint, es passt irgendwie nicht,
könnt ihr doch mal nachlesen und dort habt ihr teilweise eine etwas ausführlichere Darstellung als das,
was wir hier im Skript zusammengetragen haben.
So, das Ganze gibt es auch noch auf Chinesisch,
wenn ihr das möchtet, aber das ist im Moment nicht ganz so aktuell.
So, dann gibt es diese Konferenzen sozusagen,
haben wir in Hamburg eine gehabt, 2012,
jetzt entsprechend in Milan letztes Jahr und dann dieses Jahr,
nächstes Jahr entsprechend im Tunnis.
Achso, das habe ich jetzt gar nicht mit eingeblendet hier.
Das wird dort Tunesien halt stattfinden. Dann gibt es diese Pitting Nets World Seite,
die wir hier pflegen und wo man dann entsprechende Literatur findet,
Informationen dazu, auch noch weites Hintergrundmaterial, weitere Bücherhinweise, Papiere.
Wir haben eine Penisbiografie mit 8.000 Einträgen,
die wir vor einigen Jahren bis vor einigen Jahren gepflegt haben.
Inzwischen findet man im Netz die Sachen noch besser als bei uns,
DWLP oder entsprechend Springer, wie auch immer,
findet man diverse Papiere zu diesen entsprechenden Themen.
Aber wenn ihr erstmal Fragen habt,
ist das eine ganz gute Einstiegsseite,
mit der man da reinkommt,
insbesondere für Softwarewerkzeuge
Okay, wie war es jetzt die Entwicklung davon?
Es gibt eigentlich drei Ansätze zur Einführung. Entwicklung als aus
dem Programmcodes haben wir schon so ein bisschen gesehen.
Kommunizierende Automaten, dass die Grundidee eigentlich mit diesen Lebenslinien,
wo sich bestimmte Sachen schneiden, werden wir gleich nochmal schauen.
Und dann gibt es eine Idee von einfachen zu höheren Netzen,
wie man da eigentlich sich weiterentwickelt. So, wenn wir
vom Programmcode loslegen, haben wir irgendwie unsere entsprechenden Anweisungen.
Wir wissen, das muss irgendwie abgebildet werden. Das haben wir
auf die Sequenz abgebildet, diesmal von oben nach unten.
Dann schulen sie das Ganze anders aus als vorher in der waagerechten Darstellung,
was eine der Probleme bei grafischen Darstellung ist,
wenn ich sie anders irgendwie zusammenwürfel an die Pfeile
sozusagen irgendwie dahin male
Steckt da erstmal überhaupt keine Semantik drin und ich kann da gar nichts draus schließen und es kann einen durchaus verwirren, wenn die Bilder immer wieder anders aussehen. So,
aber das erstmal so die Ausgangslage, jetzt packen wir es natürlich,
wenn wir es als Netz sehen wollen,
eine Sache dazwischen und sagen, ja okay,
wir haben da jetzt die entsprechenden Stellen zwischen und können uns angucken,
was passiert denn da, wir haben einen Staat,
den wir hier angeben, wir starten da oben,
wir setzen das Ganze weiter,
wir rechnen da durch,
das wäre so die Idee dabei und das Gleiche machen wir dann hier oben entsprechend mit den entsprechenden Marken,
die wir da drin haben können.
So, das Ganze aufgrund der Unabhängigkeit haben wir jetzt genau die Idee,
dass wir natürlich auch so darstellen können und können das dann von da aus durchspülen,
das Ganze und haben da eine Möglichkeit.
So, das sind so Ideen, dass wir von den Programmen aus versuchen,
dahin zu kommen und ihr könnt es auch vom Java aus genauso mitsehen.
Ist sozusagen eine Frage, ob das wirklich immer notwendig ist,
aber für diese Sachen hier,
wenn ihr irgendwas mit Nebenläufigkeit zu tun habt,
wird das dann wirklich spannend, ist,
weil mir solche Programmteile verteilen wollt oder in Threads packen wollt,
müsst ihr wissen, was unabhängig ist und da braucht ihr genauso ein Gedankenmodell.
Das hier ist halt nur ein Beispiel dafür. Nächster Punkt war kommunizierende Automaten, das heißt,
wir haben Automaten 1, der hier irgendwie so durchschalten kann,
der kann seine Marke da durchlaufen lassen, naja, schön und gut.
Wenn ich jetzt zwei habe, ja,
dann laufen die sozusagen jetzt nebeneinander genauso rum und eigentlich unabhängig voneinander an den Stellen. Was jetzt aber,
wenn ich mal irgendwie gemeinsame Aktionen haben möchte,
wenn ich jetzt sozusagen das jetzt als zwei endliche Automaten betrachten möchte,
wie kriegt denn jetzt irgendein Handshake-Verfahren hin oder wie stimmen sich zwei Rechner denn eigentlich ab,
dass wir die Idee, dass man versucht, okay,
es gibt bestimmte Handlungen, da müssen weit zusammenkommen in irgendeiner Weise und gemeinsam etwas machen.
So, und das kann man dann so machen,
dass man sagt, okay, gut,
ich verschmelzt diese Transition und packe sie dann entsprechend zusammen
und habe damit dann die entsprechende Kommunikation in den Automaten drin
So, und jetzt kann ich natürlich anfangen,
irgendwie dann hier zu schalten an den Stellen.
Das heißt, ich gehe jetzt hier durch und schalte mal
diese entsprechenden Marken. Jetzt ist das hier noch nicht aktiviert,
weil bei den Netzen wir gleich noch sehen werden,
von der Schaltregel her, brauchen wir jetzt hier irgendwie noch eine Marke.
Das heißt, sie muss da rumlaufen an den Stellen.
Und entsprechend dann hier, ups, kann sie entsprechend schalten.
Es war. Dieses Teil, und jetzt ist sozusagen
die Schaltung entsprechend möglich,
um dahin zu kommen
So, diese Marken müssen nicht erhalten bleiben,
sondern war den letztens so, dass die Marken sozusagen kannten
im Ausgangsbereich sind, werden die entsprechend doch alle belegt.
Und es müssen alle im Vorbereich belegt sein,
damit man die entsprechend abziehen kann. Also es reicht nicht,
dass man einen Teil abzieht oder man kann nicht davon ausgehen,
dass man die Sachen, wie man da hat, durchschiebt.
Das ist kein, da würde eine andere Semantik verwendet werden.
Das andere Teil ist nämlich hier, das war das,
was ich jetzt hier als Nächstes hatte,
wenn ich jetzt hier schalte,
dann generiere ich jetzt hier sozusagen noch eine weitere Marke und habe mit einmal drei an der Stelle.
Das heißt, es geht nicht um Werterhaltung an der Stelle,
es geht nur um Wahren falsch an den Dingen,
ob irgendwas erfüllt ist oder nicht.
Und ich davon etwas anschauen möchte. Und natürlich kann ich
dann wieder hier unten schalten und weiterreichen
Gut, Grundprinzipien dahinter. Die Grundprinzipien bei den Netzen
sind jetzt die, dass wir Lokalität irgendwie einführen können.
Also ich möchte irgendwie trotzdem noch eine gewisse Art von Lokalität behalten in meinem System,
weil da habe ich die volle Kontrolle und kann dort auch
irgendwas machen und habe da auch immer den Zugriff auf die Ressourcen,
die ich lokal vorrätig haben will.
Die Nebenläufe, ich habe mich die aber auch haben,
weil ich möchte ja, dass es mehrere Lokalitäten gibt.
Ich möchte auch,
dass ihr was tun könnt und nicht nur erst was,
esse ich was, dann ihr,
sondern wir können auch gemeinsam ein Lied singen, wenn wir wollen.
Grafische und formal textuelle Darstellung können wir noch eingehen und
die einfachen zu höheren Netzen kommt eben jetzt auch
Beispiel ist Formel 1,
erst was Schumacher wie Falk angefangen hat und das entwickelt hat,
inzwischen ist es jetzt ein Viertel, den man dann nehmen kann,
als Rennwagenfahrer und könnt ihr das angucken,
wir haben ja so zwei Rennwagen A und B,
die in irgendeiner Weise fahren.
Und was wir jetzt brauchen, um so ein System zu beschreiben,
wie so ein Rennen eigentlich abläuft, ist,
dass wir in irgendeiner Weise Bedingungen und Aktionen im System beschreiben wollen.
Naja, und bei den Bedingungen,
wenn wir jetzt so einen Startvorgang uns nur angucken wollen,
damit wir nicht zu viel in vorne Rennen machen,
ist ja ein bisschen länger,
weil so ein Rennen,
haben wir jetzt also verschiedene Bedingungen,
die jetzt alle gelten sollen
Das Auto muss ich vorbereiten auf einen Start und es wartet auf den Start,
dann läuft das Auto und dann gibt es auch so ein Ready-Signal von dem Auto,
das heißt, er nimmt seine Hand hoch und sagt,
jo, ich bin soweit, die Hand oben haben,
dann sagt der Staat da, jo,
jetzt geht's los und so weiter und so fort.
Irgendwann gibt es also so ein Startsignal von dem hier und irgendwann
fahren sie dann mal los. Das ist jetzt die Frage,
wie wird das denn eigentlich jetzt angeordnet und man muss also
für A und B beides gleichzeitig lieber separat beschreiben,
naja, machen wir das halt erstmal.
Das nächste an Aktionen ist dann also,
dass man so ein Ready-Signal sendet, dass man so ein eurer Rennen startet,
gibt ein Signal und das Gleiche gilt eben für Auto A irgendwie auch noch.
So, jetzt können wir so globale Zustandsübergänge uns angucken dazu und ein Transitionssystem aufmalen.
Gehen wir so hin und sagen, ja,
mit diesen Zuständen können wir jetzt irgendwas beschreiben hier und die hervorheben und sagen,
das sind die, die spannend sind und dann gibt es hier so eine Änderung zu dem T1 an dem Teil.
So. Und was wir jetzt nehmen können, ist das T1,
mal konkreter eins anzugucken, indem wir nämlich sagen, okay,
wir haben diese Stille P1 und dann wird P2 und P4 werden dann entsprechend wahr.
Das heißt also, der bereits sich auf den Staat vor und dann,
wenn es Truhe ist,
macht der Wating und ein Ready Signal hat er auch noch,
dass er sagt, okay,
ich bin so weit,
nachdem er sich halt vorbereitet hat
Das Gleiche machen wir natürlich dann auch für das andere Auto,
dass wir sagen, yo,
T4 wird auch noch und sagt auch, wir sind auch fertig.
Und dann kann man das entsprechend weitersehen,
wie das weitergeht, dann im folgenden Jahr noch sehen.
So, dann haben wir also unabhängige Zustandsübergänge und nebenläufiger Zustand zu Belgien.
Was da passiert ist, ist, dass wir von
der Darstellung her jetzt unsere Netze erstmal irgendwie darstellen können.
Und im Normalfall werden wir die Handlungen in die Transition verbringen und
die Zustände auch. Vom Grundprinzip her, aber kann man
das sozusagen auch dual sehen und die entsprechenden Dinge nachher austauschen.
Da werden wir aber nicht drauf eingehen. Hier haben wir erstmal,
dass wir zwei Dinge haben, nämlich,
dass wir die Stellen und die Transitionselemente im Wesentlichen haben und damit also
die Aktivitäten auf die Transition packen und die passiven Sachen auf die Stellen.
Das ist das, was hier generell geht. So,
und wir nennen das Ding dann Bedingungen oder Plätze oder Stellen,
Betriebsmittel, Wartepools oder Kanäle.
Die Transitions- und Ereignisse, Aktionen, Ausführung von Anweisungen,
Übermittlung von Nachrichten und so weiter.
Das kann man dann so als solche Aktivitäten darstellen und das
stellen wir dann halt entsprechend über die Telemente,
das heißt die entsprechenden Transitionen dar
So, das war sozusagen das erste Prinzip,
dass wir also diese zwei Arten von Elementen haben.
Unser System immer prinzipiell so zerlegen. Also wenn ich irgendwas beschreibe,
muss ich sozusagen mein System über die Aktionen beschreiben und ich sage, was passiert davor?
Oder was gilt davor und was gilt danach? Diese Aktivität
in deinem System kann ich aneinanderreihen. Welche das sind,
ob liegt meiner Person sozusagen für den jeweiligen Kontext,
was ich da machen muss an dem Schiff?
Oder machen möchte. Lokalität. Naja, wenn der eine Wagen
da irgendwas tut, Und er muss selbst sich vorbereiten und
was machen und dann muss er sich melden und so weiter und so fort.
Das obliegt nur ihm sozusagen, was er denn da tut.
Und diese Zustandsänderung ist dann lokal. Und ich möchte gerne
bestimmte Lokalitäten halt beschreiben, wo bestimmte Aktionen eben sagen,
okay, wenn dieses Ereignis stattfindet,
dann muss das und das gegeben sein und dann kann das und das wiederum passieren.
Aber es ist nur noch das,
was sie als Lokalität damit zeichnen, nämlich die Vorbedingung,
die Aktivität und die Nachbedingung und habe damit dann die Lokalität geschaffen,
in der ich dann als eine kleine Aktion sozusagen was machen kann.
Und diese beiden Lokalitäten hier sind dann halt diese Stellen und diese Transition,
beziehungsweise diese Stellen und diese Transition mit den entsprechenden Marken oder Nichtmarken
da drin,
je nachdem,
wie man das dann gerne hat
Das heißt, das verhalten halt Transition mit ausschließlich durch ihre Lokalität bestimmt,
welche sich aus ihr und der Gesamtheit ihrer Ein- und Ausgangselemente zusammensetzt.
Das, was rein und was rausgeht. Prinzip der Nebenläufigkeit,
Transition mit Disjung der Lokalität, nämlich diese beiden, ja,
haben ja nichts gemeinsam jetzt an dieser Stelle, finden unabhängig oder nebenläufig statt.
Und jetzt merkt ihr schon, wo ich vorhin hin wollte,
mit denen können diese unabhängigen Ereignisse eventuell auch sozusagen wirklich immer unabhängig sein,
von der wathematischen Spezifikation her,
wenn ich nur die entsprechende Fazit der Ordner drin habe und nur angeordnet habe,
AVB, AVC und BVC, dieses A und B,
erstmal, wenn wir das jetzt so sehen würden mit des Jugend der Lokalität,
dann sind sie wirklich nebenläufig.
Das war auch genau das, was wir bei Lampard gesehen haben.
Wenn es nicht der Fall ist, kommen wir noch zu.
So, dann können wir Netzkompositionen hier durchführen. Wir können jetzt also
verschiedene solche Beschreibungen aufmalen. Wir haben ja so ein Teil hier,
wir haben einen T4, kann man auch hinmalen.
Und die können wir jetzt irgendwie zusammenbauen. Und ich lang jetzt,
also auf was danach noch stattfindet,
irgendwie eine T2-Operation stattfinden lassen, wo es dann irgendwie weitergeht.
Welche das dann sind, werden wir gleich noch sehen.
Hier sehen wir dann gleich den entsprechenden Starter und was wir
da noch drin haben können mit den entsprechenden Aktivitäten,
die dort jeweils auftreten können
So, da ist dann entsprechend zu verschmelzen. Das eine,
da muss man aufpassen, was man hier noch zusammenpackt und wie
man das zusammenbaut und was dann rauskommt, ist ein Netz,
was entsprechend so aussieht, dass ich hier wieder meinen T1 habe.
Hier mein T4, hier ist das T3 und hier sehe ich sozusagen die Anfangsmarkierung,
nämlich das Auto A und das Auto B und da zwischen den entsprechenden Starter,
die in den Anfangszuständen sind.
Und dann können die Aktivitäten machen. Der Starter kann kein Startsignal geben,
so lange wie nicht ein Okay-Signal von A und von Befull vorliegt,
weil ich diese drei Stellen hier sozusagen vorher markiert habe,
bevor ich dann irgendwas machen kann.
Was macht er dann? Er sagt, okay, starten,
die Signalstaaten, ist jetzt wie die Aufforderung für die beiden Autos,
nämlich hier oben und hier unten,
dass diese Autos losfahren können und damit ihre nächsten Aktivitäten starten dürfen.
Das heißt, ich habe also jetzt erst die Aktivitäten bei den Autos,
je nachdem, wie sie das dann sagen,
ja oder ja, haben sich beide gemeldet,
dann kommt der Staat da und danach können die Autos um die Wette losfahren und auch da wieder beide nebenläufig und wenn eine stehen bleibt, dann stehen.
Das könnt ihr auch von den Rennen,
manche Staaten ein bisschen schneller, manche ein bisschen langsamer,
das ist eine der spannenden Aspekte,
wenn man das beim Rennen fahren oder Formel 1 gucken,
überhaupt als spannend empfindet,
dann kann man das noch als eine der spannenden Phasen
sozusagen bezeichnen
Gut, was haben wir da drin? Was wir da drin haben,
ist quasi, dass jetzt so eine grafische Repräsentation halt haben.
Und es gibt eben die Möglichkeit,
dass diese Pelement durch Runde und die Transition durch eckige Elemente
darzustellen und die entsprechenden Kanten oder auch Pfeile verbinden die Telemente mit den Pelementen und umgekehrt.
So, und es kann eben nur Kanten zwischen Stellen,
Transition, Transition stellen geben, aber keine Zwischenstellen und keine Zwischentransition.
Das ist nicht definiert in diesem System, das kann Übergang entsprechend beschreibt.
Und die Beschriftungen werden dann an die jeweiligen Karten auch noch drangehängt,
wir können auch an die stellen,
an die Transition bestimmte Bestriftungen ranhängen, welche Semantik dann dahinter steht.
Auch das kommt erst in den gefärbten Netzen am Ende der Veranstaltung.
Ja. So, dann haben wir das Prinzip der formaltextuellen Darstellung von Petrin Netzen. Naja,
es gibt eine Äquivalente formaltextuelle Darstellung, das heißt,
es gibt sowas, welcher das ist,
werden wir auch beim nächsten Mal nochmal ein bisschen genauer angucken,
beziehungsweise werden jetzt schon mal die erste so ein bisschen anschauen.
Also, ein Netz ist ein Triple,
was sich zusammensetzt aus Stellen, Transitionen und der Flussrelation.
Und wir haben also eine Menge von Plätzen oder auch Stellen
und wir haben eine Menge von Transitionen,
die das jungt ist zu den Stellen
Darf natürlich nicht sein, dass eine Stelle gleichzeitig Stelle und Transition
ist an der Stelle hier. So, und wir haben
eine Flussrelation, die sich eben jetzt hier so definiert.
Warum kann ich nicht P-Vereinigt Tee-Kreuz-Tee vereinigt P hinschreiben?
Ja, wir wollen eine zweistellige Relation haben. Wir wollten
eine hierstelligere. Nö, das wäre immer noch zweistellig,
wenn ich das sozusagen als Kreuzprodukt mache zwischen zwei Vereinigten Mengen hier,
hätte ich immer noch zweistellig das Ganze.
Nein, das meinten sie nicht. Vereinigt,
Kreuz vereinigt. Ach so. Ich freue mich nicht,
dass wir inzwischen seit kleiner zwei Positionen auch für eine Relation Genau,
wir wollen nicht Stellen verbinden und nicht Transitionen miteinander verbinden.
Und deswegen wollen wir das nicht haben. Genau. Das war,
da hatte ich halt eben nicht deutlich genug ausgesprochen bei diesen Sachen.
Genau. Und wenn diese P&D endlich sind, dann heißt
auch das letztendlich. Es gibt also auch unendliche Netze,
die wir auch noch für unsere Prozesse auch noch durchaus benötigen werden.
Okay, ja, und haben wir halt so ein kleines Beispiel.
Und so kann man es dann entsprechend hinmalen.
Und wenn wir jetzt so ein P6T3 haben, haben wir
hier das genau sozusagen als diese blaue Kante entsprechend drin.
Oder wenn wir jetzt hier T3P5 haben,
finden wir es ebenfalls in der entsprechenden Flussrelation drin
So, jetzt kommen wir in irgendeiner Weise hier rüber und das ist sozusagen das Verhalten.
Und das ist sozusagen die Abbildung der Schaltringle, die Darstellung,
wie die Schaltregel funktioniert, nämlich das Abziehen aller Marken aus dem Vorbereich.
Alle stellen den Vorbereitung markiert sein,
wegnehmen und hinten alle stellen, wieder markieren,
entsprechend der Kantenbeschriftung, die jetzt hier erstmal wegfällt,
also immer nur einen schwarzen Token wieder raus aus der Transition.
Gut, dann haben wir ein Netz wiedergegeben und wir haben so ein Element X,
was entweder eine Stelle oder eine Transition ist dieses Punkt X bezeichnet dann die jeweils jeweiligen Dinge,
die im entsprechenden Vorbereich liegen von diesem X.
Also wenn ich jetzt eben diese Stelle P1,
T1 meinetwegen mal anschaue, dann gucke ich mir das,
was im Vorbereich von T1 ist, an.
Dann würde hier das X sozusagen das T1 sein und das
Y wäre dann das P1 entsprechend, würde hier reinkommen.
Das wäre auch das einzige. Und damit habe ich
die Elemente aus dem Vorbereich und das wäre also
genau nur das P1. Entsprechend für diese Sache
So, und das ist die Menge der Eingangselemente,
Eingangselemente, natürlich da spezialisiert,
entweder Eingangselemente für die Transition oder Eingangselemente für die Stelle,
wobei eben für die Stellen die Transition das sind und für
die Transition die Stellen als Eingangselmetertümer in Frage kommen.
So, und definiert wird das dann über die entsprechende Flussrelation,
die wir dann sozusagen benutzen, um das festzuhalten,
welches diese jeweiligen Elemente sind.
Entsprechend das Gleiche mit x Punkten, sodass wir die Ausgangselemente hier wieder vorfinden.
Was wir machen können, ist, ja?
Seelemente, Ausgangselme. Ja, genau. Das Ganze muss auch
eine Seele haben, das wäre ein bisschen seelos, einflusslos hier.
Okay, also die X, Punkt X,
mit Groß X können wir also auch Mengen von Elementen zusammenfassen.
Und dann können wir sozusagen in diesen Mengen natürlich auch andere Sachen zusammenfassen,
weil nämlich das X aus Stellen und Transitionen zusammenfassen,
wenn ich also diese beiden hier nehme oder T3 und P2,
dann habe ich eben das im Vorbereich und hier entsprechend die Stellen im Vorbereich,
womit ich also auch gemischte Mengen haben kann.
Bei den Groß-X-Sachen, bei den kleinen X-Sachen eben genau nicht.
So, und die Lokalität ist eben das Element selbst und
Vor- und Nachbereich. Und jetzt seht ihr auch,
wie man das dann formal aufschreiben kann und das dann benutzen kann.
Das sind das formal auch irgendwie dann so heißt,
dass man das Punkt X und X-Punkt oder Y-Punkt und so weiter da hat,
das ist dann die nächste Geschichte, wie man das interpretiert.
Aber da haben wir schon mal eine Art und Weise,
wie wir das anschauen können und wie wir uns das definieren.
Wenn man das jetzt dafür ansieht, kann man sich überlegen,
wie sieht das aus dafür?
Und dann hätte man hier eben das T1 und das T3
als Vorbereich für diese große Menge hier zum Beispiel.
So, jetzt haben wir ja immer nur so statische Geschichten gehabt.
Das heißt, ich habe immer nur so feste Teile und
irgendwie hat sich noch nichts bewegt in unserem System.
Ich habe nur gesagt, da gibt es diese Aktion und diese Aktion und diese
gibt es da. Habe ich auch noch nicht gezeigt,
was da wirklich an Aktivitäten drin los ist.
Und jetzt müssen wir also irgendwie mal auf die schwarzen Punkte
zu sprechen kommen, sprich hier die Markierung. Das heißt,
die Dinge ich drauflege, nämlich eben Marken oder Token,
wenn wir das im Englischen nippen,
wenn man wieder nimmt, das passiert immer wieder,
dass ich auch die englischen Begriffe mit oder benutze.
Ich versuche mich auf Marken zu beschränken, genauso wie mit
Plätzen und Stellen, die verwende ich synonym. Die,
wir haben jetzt wieder ein Netz und wir haben irgendwie M,
was man als Timing von Peg jetzt hier definiert erstmal,
als eine Markierung.
Und eine Transition T ist in dieser Markierung aktiviert.
Genau dann, wenn
Im Vorbereich der Transition, ich die Stellen zusammensammle und die eine Teilmenge von Groß-M sind.
Das heißt, meine Stellen müssen in diesem Vorbereich sozusagen alle
markiert sein und der Nachbereich ist leer. So,
die Nachfolgemarkierung am Strich ergibt sich dann aus diesem im Strich als das M,
wo ich dann die aus dem Vorbereich wegnehme und die aus dem Nachbereich wieder reinschmeiße.
So, was ich jetzt machen kann, ist,
ich kann noch eine Nebenbedingung haben, das heißt,
ein Pfeil hinten fall zurück von der Stelle,
das ist eine spezielle Variante,
gucken wir uns auch noch an.
Gut, da haben wir also die beiden Marken,
die wir abziehen und einen dann rauspacken oder rein und raus
und damit dann die entsprechenden Sachen
da drin haben
Wo dann diese Markie hierherkam, lassen wir erstmal dahingestellt,
dass wir vorhin auch noch Marken sind.
Die hätten es auch noch schalten können vom Prinzip.
So, was haben wir jetzt da entsprechend drin?
Wir haben hier eine Beschreibung von diesem Netz und können jetzt sagen,
was da drin passiert. Wir können nicht sagen, okay,
wenn ihr oben Tee einschaltet, also quasi unser A-Auto fährt,
haben wir hier ein A und wir haben diese Markierung hier.
Oder wir schalten hier vor die Transition T4
und kommen dann zu dieser Markierung
hier drüben
Und wenn wir das Auto B erst mal fahren lassen und
dann das Auto A, kommen wir zu dieser entsprechenden Markierung
oder aber wir fahren erst A und dann B.
Und jetzt könnte hier den grauen Pfeil auch sehen,
dass man hier auch die Möglichkeit hat,
A und B gleichzeitig in einem Schritt schalten zu lassen,
dann kommt man auch dahin.
An dieser Stelle ist das sogar gleichbedeutend mit dem entsprechenden Prozess sozusagen,
das unterscheidet sich nicht von den Prozessen,
wir werden noch sehen, was das bedeutet.
An dieser Stelle Hinweise eine gewisse Schrittsemantik. Wir haben also
Interleaving-Semantik gehabt, das ist A, B oder B-A.
Mit einem Schritt, sagen wir,
die können auch beide
gleichzeitig passieren
Etwas, was im Skript nicht weiter groß thematisiert wird,
einer der Gründe, warum man sich das hiermit anhört,
anstatt nur das Skript zu lesen, das wird dort nicht groß vertieft.
Das muss man dann entsprechenden Büchern einfach irgendwo anders nachlesen,
wie das entsprechend definiert ist. Also, dieses Ding ist
ein wichtiger Aspekt darin, dass wir eine unterschiedliche Semantik haben.
Wir werden nachher auch noch darauf eingehen,
dass wir eine Prozesssemantik haben, die sich davon noch wieder unterscheidet,
noch ausdrucksstärker ist, als wenn man nur Schritte nimmt,
wo man zwei Sachen gleichzeitig lassen kann.
Ihr könnt euch ja mal selbst überlegen,
dass ihr etwas findet, wo etwas ausdrucksstärker ist,
als dass ich sagen kann,
ich kann Sachen nebenläufig in einem bestimmten Schritt schalten
Wie er das ausdrücken würdet, in eurem eigenen Kopf,
um da noch mehr ausdrücken zu können,
dass man nicht mit Schritten ausdrücken kann.
Kann ich mir überlegen. Das hat in der Informatik etliche
Jahre gedauert, bis man auf die Idee gekommen ist,
was es denn sein muss.
Das war eine der Sachen, die bei Petri eben mit drin stecken.
Also das ist etwas, wo es spannend ist.
Es gibt insgesamt nachher auch unendlich viele Semantiken für die,
die man unterschiedlich darstellen kann.
Die restlichen sind aber nicht ganz so spannend.
Ihr müsst euch nur die Folgen oder die Lieblingssemantik,
die Schrittemantik und die Prozessemantik sozusagen merken.
Und dazu dann auch jede Antwort stehen können in den Prüfungen
Sachen. So, wenn wir jetzt also hier angekommen sind
und wir haben jetzt ARW oder BA oder auch beide gleichzeitig
hier geschaltet oder auch sozusagen irgendwie völlig unabhängig voneinander, sind wir in dieser Nackierung.
Hier gibt es dann die entsprechende Schaltung von dem,
durch den Starter und danach ist es so,
dass dann diese beiden Autos in das Rennen starten können,
also wieder erst Auto A und dann B oder B und A und was aber wahrscheinlicher ist,
dass beide gleichzeitig irgendwie losrasen und den Sprit vergeuden,
ist dann an dieser Stelle hier.
So, das ist dann sozusagen das Pardon an der Stelle
und auch hier sieht man wieder die Folgeschritt- und Prozessemantik,
wobei Prozess- und Schrittsimantik erstmal nicht für euch erstmal
so direkt unterscheidbar sind
Gut. Was jetzt noch kommt ist, ist dieses simultane Schalten.
Und das heißt, wir definieren jetzt also Transitionsmengen auf diesem Tee.
Wenn wir jetzt also ein Netz haben und eine Markierung,
haben wir eine Transitionsmenge, irgendwie U.
Und die ist in Tee aktiviert, wenn wir den Vorbereich
markiert haben und der ist in diesem M drin.
Und der Nachbereich ist entsprechend leer und die Transitionen sind nebenläufig.
Das heißt, die Lokalität muss das jung sein.
Warum muss ich das jetzt noch mit dazunehmen?
Warum reicht es nicht zu sagen,
dass der Vorbereich markiert ist und der Nachbereich soll jetzt
erstmal leer sein
Eine Sonne. Ich habe es gerade genannt. Stelle.
Die können die ja theoretisch auf Zwei-Transitionen quasi. Genau. Also,
der Vorbereich kann eventuell so sein, dass eine Stelle,
die markiert ist, für beide Transitionen im Vorbereich liegt.
Und damit werden sie ja beide markiert, aber sie stehen in einem Konflikt.
Und das darf nicht der Fall sein. Das erreichen wir dadurch,
dass wir das jungte Lokalitäten haben und dieses jungten Lokalitäten erlauben
wir dann, dass diese beiden dann nebenläufig schalten können.
Also wir zeichnen genau diese Transition als nebenläufig für den Fall,
dass sie in dieser Menge halt drin sind.
Und wenn das nicht die gleichen Transitionen sind,
dann sind die Lokalitäten bis jung,
hier sollt ihr noch eine leere Menge spielen an der Stelle.
Sorry, für die Darstellung. Die Nachfolgemarkierung ist entsprechend so definiert,
dass wir den Vorbereich abziehen und den Nachbereich draufpacken und
damit sind wir dann auch schon durch.
Das heißt, das Rechnen passiert hier genauso wie mit einer Transition,
also wir können noch mehrere gleichzeitig berechnen.
Das ist dann sozusagen der Schritt, den wir da drin haben.
Und dann haben wir die Schrittzimmerntick halt entsprechend definiert.
Setzen wir also gleich Tee-Seiten mit bekannte sequenzielle Schaltregel.
Und sequenziell heißt dann wirklich,
wir nehmen erst ein T1 und dann ein T4 und dann
ein T3 und dann ein T2 und dann
so weiter
Okay. Damit sind wir also jetzt genau hier drin
und können uns genau da drin entsprechend bewegen.
Gut, das war das jetzt zu den Netzen,
was so ganz grundlegend da drin steckt.
Womit es jetzt eigentlich dann beim nächsten Mal wieder weitergeht,
ist, dass wir uns mit Verfeinerung und Vergröberung weiter beschäftigen werden.
Ich bin noch nicht fertig, also ich sehe gerade so Aufbruch.
Ich wollte gleich noch eine kleine Demo für das Renio-Tool geben,
damit ihr wisst, wie das funktioniert und wie das läuft.
Da ist zur Hausaufgabe dazugehört, wollte ich das hier
schon einmal vorführen
Sonst müsst ihr den Kram selber angucken und das ist ein bisschen nervig,
weil so zwei, drei Kniffe findet man jetzt raus,
wenn man das Handbuch wirklich liest.
Und das sind halt durchaus 150 Seiten und das müsst ihr nicht ganz lesen.
Deswegen werde ich euch die Tipps geben, die dringend notwendig sind.
Auf dem Übungszettel wird dann auch die entsprechende Hinweise geben und da sollte ich auch genau drauf gucken und gucken,
was da draufsteht und die auch genau so befolgen und nicht irgendwie versuchen, erstmal vorbeizukommen.
Wenn man rumspielen möchte,
kann man natürlich irgendwie anders vorgehen und selber mal gucken,
aber es gibt so zwei, drei Kniffe,
die man dann erstmal einfach lesen muss oder nachgucken muss,
weil die Benutzung hat ein bestimmtes Konzept im Hintergrund so mit möglichst wenig Klicks,
möglichst schnell Netze erzeugen zu können, was dazu führt,
dass jeder Klick und jeder Tastengeschichte was zu bedeuten hat und was die Benutzung nicht ganz so einfach macht,
aber sehr schnell und effektiv nachher, wenn man weiß,
wie das Werkzeug funktioniert.
So, vorweg wollte ich jetzt noch was zur Verfeinderung, Vergröbung erzählen.
Das heißt, eine der wichtigen Dinge ist ja,
dass wir jetzt so tolle Gebilde, wie ich jetzt gerade eben habe,
so schön im Detail beschreiben können. Spannend war dabei natürlich,
dass wir bei dem Autofahren nicht gesagt haben und dann steckt er den Zündschlüssel rein und dann
startet er und dann gibt er ein bisschen Gas und ein Fetterstückchen oder dann macht er irgendwie die Hand hoch oder also wenn ich das möchte,
hätte ich also den Startvorgang und das Signal geben, ich bin fertig,
noch ein bisschen anders beschreiben können und auch viel detaillierter beschreiben können,
nämlich auch nebenläufig, dass während er die Bremse tritt,
er auch schon die Hand hebt, weil er dann meint,
er würde jetzt gerne gleich starten oder irgendwie sowas.
Also diese Aspekte haben wir einfach außen vor gelassen.
Und das ist einer der schwierigen Aspekte da drin,
wie wir das jetzt hier in Folgen noch das Rennen sehen wollen,
ist das wirklich alles so beliebig,
verfeinerbar oder läuft das bestimmt so durch.
So, und wir können jetzt hier sozusagen dieses Netz mal angucken.
Da haben wir gesagt, im Rennen gibt es jetzt hier
auch so ein weiteres Rennen und das fahren die ja so eine Strecke ab.
Und bestimmte Strecke kann ich jetzt also mit weiteren Aktivitäten
quasi wieder beschreiben. Ich kann also jeden Zentimeter mit
so einem Teil beschreiben oder jeden Kilometer oder bestimmte wichtige Abschnitte
Und die Idee ist jetzt dabei,
dass wenn man sozusagen so eine Schikane einbaut, wo,
nach irgendwann gibt es das bei so einem Rennen meistens zum Teil,
wo es dann darum geht,
um die Ecke zu fahren oder irgendwo durchzufahren und dann wird es spannend.
Die Rennen, wo man einfach nur gerade ausfährt,
kann es zwischen passieren, dass der andere einem davor fährt,
dass dann auch wieder so eine Art von Problem von Synchronisation,
die man nicht haben will meistens.
An dieser Stelle hier ist es eine knappe Ressource,
um die man sich bewerben muss. Man kann also quasi,
wenn man aus Rechnersicht draufguckt, zwei Prozesse haben,
die sich um eine knappe Betriebs- oder ein kleines Betriebsmittel
bemühen und die im wechselseitigen Ausschluss steht und auf die möchte
ich zugreifen
Hier ist es einfach ein Autorennen mit Hindernis, was wir da drin haben.
Wir sagen, es darf nur einer, der gleichzeitig durchfahren.
So, nun ist die Frage, wie kriegen wir das
auf die Reihe? Aber es ist viel spannender,
irgendwie im Realweltlichen kriegen wir schon hin, zur Notfahrt,
weil gleichzeitig rein wirstoppt das Rennen und das ist ein Datelocken, das Ganze verklemmt.
Sehr schönes Beispiel für Klemmen. Die andere Idee ist aber,
dass man das irgendwie arrangiert und doch irgendwie hinkriegt. Einfach,
wenn der Angriff schneller ist und dann gibt es die Regel,
dann musste er abbremsen, weil der andere hat vor,
das Recht vorwegzufahren.
Das ist ja klar geregelt im Rennen, deswegen gibt es
ja die Regeln, damit man das versucht hinzubekommen.
Bei Stockherren wird es dann ein bisschen anders,
da sind andere Regeln, da bin ich dabei,
aber auch da gibt es
keine Beliebigkeit
So, jetzt ist die Frage, wie beschreibe ich das
denn jetzt hier mit so komischen Kulonkästchen? Das heißt,
wie beschreibe ich dieses analoge Phänomen hier unten eigentlich mit so einem diskreten Beschreibungsmittel?
Ja, das habe ich eben gerade schon so ein bisschen erklärt.
Ich habe gesagt, alle relevanten Abschnitte ist dieses Rennens,
beschreibe ich separat und erkläre dann, was ist jetzt hier gerade der relevante Abschnitt?
Das heißt, ob das erste Stück,
wo sie gefahren sind, erst mal ein Kilometer lang ist,
wo sie alle kräftig Speed aufnehmen konnten und dann in die Kurve fahren können,
beim Start ist das ziemlich unglücklich,
wenn das zu lang wird.
Oder bis noch ganz kurz,
ob es nur 50 Meter waren und dann mussten sie schon
einigen Wetter zuerst reinfahren darf,
hängt ja von der jeweiligen Grennstrecke ab
Das habe ich aber einfach jetzt hier so als die Staaten
hier und dann fahren sie und naja, und jetzt wollen wir irgendwie gucken,
wie kriegen wir den nächsten Abschnitt, wo sie sich wieder treffen sozusagen.
Und danach, danach können sie ja wieder parallel fahren,
das möchte ich auch wieder darstellen, dass sie da unabhängig
fahren können und der einen anderen überholt oder schneller sein kann, wie auch immer.
So, das heißt,
ich baue das jetzt hier oben entsprechend ein und sage,
ja, das ist da vorne, das ist jetzt die knappe Stelle,
in Rot habe ich ja auch drin und sage,
da ist irgendwie ein Problem drin.
Und ich möchte eigentlich, dass da jetzt was passiert.
Kann man jetzt auch ein Java programmieren,
ein Bezynkrenized und da müssen sich zwei synchronisieren, zwei Prozesse,
die dann irgendwie sind und kann man entsprechend mit einbauen,
aber das wollen wir jetzt hier nicht weiter vertiefen
So, was wir da jetzt machen, ist,
dass wir jetzt eine Handlung haben, die da ja entsprechend stattfindet.
Und für die ich jetzt irgendwas arrangieren muss an den Stellen.
Und das kann ich jetzt irgendwie mit Handlungen darstellen.
Oder aber ich kann jetzt hier anfangen und sagen,
damit diese Aktion hier stattfinden darf, dass wir da reinfahren darf.
Das wird eigentlich hier vorne entschieden. Aber der und der entscheiden ja
quasi unabhängig voneinander. Die brauchen aber jetzt irgendwie diese Ressourcen,
nämlich das Recht, dort einfahren zu dürfen. Und das Recht,
dort einfahren zu dürfen, ist die Regeln klar geregelt,
nämlich wer von euch ist, links oder rechts,
bevor, hinten, da wäre es jedenfalls weiter vorn.
Letztendlich läuft es darauf hinaus auf eine 0-1-Geschichte,
weil das Rennen so definiert, man muss aufpassen.
Und da gibt es irgendwelche Beschreibungen, die wir nicht näher angucken wollen.
So, wie mache ich das also? Ich sage,
okay, ich baue hier einfach eine Konfliktstelle ein,
packe eine Marke da drauf und sage, okay,
wer da rein darf, der kriegt den einen Token,
der da drin liegt.
Also quasi das Einfahrtsrecht ist genau ein eindeutiger Token, der dort beschrieben wird.
Und der wird hier jetzt entsprechend hinterlegt. Und je nachdem,
wer jetzt zuerst schaltet, der kommt auch durch.
Wer fällt jetzt, also hier zuerst durch, zwangsweise?
Nee, genau. Deswegen stelle ich extra diese blöde Frage,
die ist blöd und fies.
Und natürlich denkt man, der Untere,
der kann doch jetzt
hier fahren
Die Netze müssen vom Prinzip nicht schalten. Vom Prinzip muss da
gar keiner reinfahren. Netze sind so definiert, man muss nicht schalten.
Es gibt also keinen Schaltzwang. Das Ganze wird anders,
wenn ihr davon ausgeht, das läuft doch immer.
Und wenn ihr irgend so ein Ding in einen Simulator reinschmeißt,
dann geht man davon aus, es muss doch immer durchlaufen,
es muss doch immer weiterschalten.
Das ist auch nur dann der Fall, wenn ihr den kontinuierlichen Modus einschaltet.
Wenn ihr immer nur schrittweise schaltet, dann wird entschieden,
ob geschaltet wird oder nicht. Und wenn ihr einschlaft an
eurem Rechner und nicht weiterschaltet, dann wird nicht weitergeschaltet.
Und das sozusagen auch die Grundidee bei den Netzen,
das heißt, nicht schalten ist sozusagen ein Grundprinzip bei
den Netzen von Anfang an,
was mit eingebaut ist
So, das heißt, ich kann da oben jetzt erst mal
den schalten und dann doch den zuerst da oben noch passieren lassen.
Bei deinem verteilten System weiß ich nicht, wenn die unabhängig
sind, wer ist denn eigentlich schneller? Das heißt,
wenn der eine mit so einem ganz alten 80-86-Prozessor
da steht und versucht jetzt irgendwas zu tun und zu machen
und der andere hat eben so ein schönes Smartphone mit Gradcore-Computer und so weiter,
ganz sehr viel schneller,
der kann hier oben vielleicht mehrere Aktionen machen.
Oder der hier hat das super Turbo-Auto und fährt ganz schnell dann durch,
weil er noch feststellt, jetzt kann ich richtig Gas geben,
während der hier sogar ganz langsam längs schnorchelt und schafft das gar nicht so schnell genug da vorne hinzukommen.
Der ist zwar sozusagen gestartet Aber der ist noch auf dem
Weg dahin, bis er zu dieser entsprechenden Schikane kommt.
Und deswegen ist das sozusagen noch nicht da. Wenn man aber fragt,
welche sind aktiviert, dann hast du natürlich recht, diese Transition,
die er uns aktiviert, die da oben ist nicht aktiviert.
Es reicht also nicht, dass da oben jetzt ein Tucken,
ich denke, wird er schon mal reserviert oder sowas?
Das gibt es dann nicht, sondern die Transition muss wirklich
hier vollständig markiert sein, also markiert sein.
Und erst dann fährt auch dann das Auto quasi da rein.
Das ist so die entsprechende Interpretation davon. Gut. Und
was wir so haben, wir haben so einen strukturellen Konfliktplatz,
wir haben Verhaltenskonflikte und wir haben den wechselseitigen Ausschluss.
Das sind so drei Begriffe, auf die ich beim
nächsten Mal ein bisschen näher eingehen werde
Und die wir uns dann nochmal genauer anschauen. Ja,
und wie dann geschaltet wird, das ist dann halt die große Frage.
Dazu kommen wir zur Vergröberung und die Vergröberung bedeutet,
dass wir uns einfach bestimmte Dinge abknapsen und sagen, naja,
die waren am Anfang zum Starten, danach geht es hier irgendwie weiter.
Dass da noch einer drin sein kann, ist dann eine ganz spannende Aspekt da drin.
Wir können auch den kritischen Abschnitt zusammenfassen und die einfach als Nebenbedingung auffassen und sagen,
okay, die benutzen den kurz, ist ja im kritischen Abschnitt,
wenn die wieder raus ist, dann kommt die Marke schon wieder zurück.
Wie das dann genauer aussieht,
können wir uns dann hier unten angucken oder kann man sich das das mal durchspielen und dann ist die Frage,
was darf ich eigentlich noch vergröbern und wie viel darf ich vergröbern,
wie vergröber ich,
wie sind die Schnitte da dran und das ist die Frage nach dem Rand,
die jetzt beim nächsten auf euch zukommen wird.
Also im Urla-Test werdet ihr garantiert nach dem Rand gefragt und die formale Definition dazu ist das,
was ich euch bitten würde, dass ihr euch das anschaut,
weil die hier schlecht vorturnbar ist. Das heißt,
ihr müsst euch die selber einmal anlesen und habt eine Chance zu verstehen,
worüber ich das erzähle,
weil ich werde nicht das im Detail,
diesen ganzen Definitionssachen im Klein-Klein durchgehen, sondern ich werde euch erklären,
wozu ihr es benutzen könnt,
was das bedeutet und wie das funktioniert und den formalen Kram,
guckt euch zu Hause an und deswegen lest ihr
den Kram vorweg
Versteht ja auch, was diese komischen Kringel und Kästchen
und so weiter alle sollen.
Ja, das ist so die Idee dahinter. So,
dann werde ich nochmal zwei Minuten was zu Rinho erzählen.
Na, wollen wir jetzt das Teil?
So, wenn ihr euch das runtergeladen habt, reserviert habt,
es läuft also und beim Mac, bei Linux,
beim PC, unter Windows, ja, ja,
naja, ich bin immer noch aus der PC-Welt, genau.
Die, müsst ihr entsprechend gucken, wie das installiert wird,
wenn ihr da Fragen zu habt, meldet euch an den Übungsgruppenleiter,
die können euch da entsprechend weiterhelfen.
Genau. So, da haben wir jetzt also Rinho
und starten das Teil mal
Also poppt das jetzt hoch? Genau, also jetzt gibt
es hier oben eine entsprechende Menüleiste mit den üblichen Teilen.
Wichtig für euch ist erstmal hier,
dass wir ein neues Netroing anlegen und hier irgendwas machen können.
So, hier oben ist das die Simulation,
das werden wir gleich noch genauer angucken.
Und natürlich zum Basteln und schönen Malen und so weiter
können hier die üblichen Editiergeschichten benutzen.
Und guckt euch mal genauer an, was da alles so hintersteht.
Es gibt verschiedene Möglichkeiten, was man sich noch genau angucken kann.
Es ist durchaus tiefgehender in der Menüstruktur und sollte vom Kontext
ja halbwegs klar sein, was wir jeweils benötigt.
So, wenn wir jetzt hier was erstellen wollen,
gibt es die Möglichkeit, hier oben die Transition, euch Stellen zu benutzen.
Dies hier oben sind keine Transitionen und das hier sind keine Stellen.
Das sind grafische Hilfselemente. Das heißt, die erste Zeile
ist erstmal nur zum Schöner Mahlen. Das ist sozusagen das,
wo wir das herhaben, das hat Gamma mal entwickelt vor
einer ganzen Weile und das benutzen wir einfach und haben das dann erweitert.
Bedeutlicherweise ist die Toolpalette dann entsprechend in eine Richtung abgedriftet und
leider nicht mehr kompatibel
Was wir jetzt dann haben, ist,
dass wir hier eine Transition erzeugen,
indem wir einfach irgendwo hinklicken und da was entsprechend mitmachen.
Was kann ich jetzt machen? Ich kann da so draufklicken.
Chip, genau. So, und ich kann die jetzt
größer machen oder kleiner machen. Kann man so hin und
her ziehen. Was man dann hier sieht, ist,
dass es so eine kleine, so einen kleinen Double-Dye drin gibt.
Wenn ich da draufklicke, linke Maustaste,
ich benutze erstmal nur die linke Maustaste hier gerade.
Kann ich da raus? Kannst du einen Pfeil rausziehen an
irgendwie und loslassen und dann ist die Stelle da.
Das heißt, ich habe also einen Einklick und Ziehbewegung,
um die nächste Stelle zu erzeugen
So, dann bin ich da drauf,
dann kann ich sagen, okay, gut,
jetzt mache ich aus der Stelle eine weitere Transition und habe
dann hier die nächste und packe die mal hier rein.
So, jetzt habe ich also hier ein Netz und bin
damit erst mal mit der statischen Struktur schon mal fertig.
Ich kann jetzt beliebig weitermalen, ich kann auch hier oben
drauf gehen und dann entsprechend hierhin malen.
Ich komme mit Sticky Modus, wenn ich da zweimal draufklicke,
jetzt kann ich sozusagen, beliebig viele Stellen hier erzeugen,
die wir da mit reinpacken können.
Gut, nehmen wir es mal wieder weg und gehen hier
oben wieder drauf. So, jetzt kann ich hier draufklicken.
Jetzt die Frage, wie kriege ich jetzt eine Marke
da rein
Jetzt muss man dazu wissen,
dass die Idee bei den Netzen dahinter ist,
dass man quasi Tupel durch die Systeme durchschiebt.
Und diese Tupel werden mit eckigen Klammer auf, ihre Klammer zu beschrieben.
Wenn ich jetzt also die mittlere Maustaste nehme und hier drauf
gehe und einmal drücke, dann erhalte ich hier diesen schwarzen Token.
Also Token ist also eine entsprechende, eckige Klammer auf,
ey Klammer zu, Marke. Man kann das auch,
wenn man da drauf geht, auch ein bisschen größer machen,
einfach damit ihr es nochmal seht.
Das sind also eckige Klammern,
die wir da drauf sehen können an den Stellen
Gut. So, damit haben wir jetzt die Markierung und
ja, da haben wir jetzt eine Marke drauf.
Und jetzt ist die Frage, was passiert aber, wenn ich jetzt simuliere?
Naja, haben wir eben gerade gesehen, Vorbereich ist alles markiert.
Jetzt kann also genau eine Transition schalten. Das kriegen wir
jetzt hier oben über die Simulationen auf die Reihe.
Wir bleiben erstmal in diesem normalen Petronetz-Formulismus, dass der Yava-Compiler,
den wir jetzt hier gerade haben, als Formalismus und können jetzt Run-Simulation machen.
Dann fängt das Ding an zu laufen und wir sind in dem,
was ich eben gerade hatte, in kontinuierlichen Modus.
Das heißt, das liegen Leute einfach durch und hört nicht wieder auf.
Und dann wird er zwangsweise immer weiter geschaltet.
Immer wenn es markiert ist, schaltet irgendwas da drin und
das ist zufällig
Wenn ich jetzt so mehrere Alternativen habe, heißt es nicht,
dass eine bestimmte irgendwie weiter schalten muss oder weil die Transition
sich alle gleichzeitig schalten, sondern sie sind wirklich unabhängig davoneinander.
Und auch hier Transition zu sich selbst ist unabhängig voneinander. So,
das heißt, wenn ich einen Simulationsschritt mache, dann sage ich erstmal,
dass wir hier erstmal so eine Marke haben und das ist jetzt so eine Eins.
Naja, diese Eins da drin ist aber eigentlich nur
die Repräsentation, wie viele Marken habe ich da drin?
Da gibt es also grafische Darstellungsmodi in diesem Teil hier.
Die sind eben für die Gefärbtenwette durchaus notwendig.
Deswegen gibt es dort diese verdeckte Operation,
dass man hier, wenn man da draufklickt,
kriegt man das entsprechend angezeigt,
die Anzahl der Marken
So, wenn ich jetzt also einen Simulationsschritt machen möchte,
gehe ich also einen Simulationsschritt, könnt ihr euch eine Tastatur
bedienen und das ist ein Simulationsschritt und dann hat die geschaltet.
Naja, und jetzt kann sie hier wieder schalten und
dann kann die wieder schalten, ist die mittlere Maustaste,
die ich hier drücke und damit kann ich jetzt fleißig schalten.
Oder ich kann das Ding halt fleißig laufen lassen,
jetzt simuliert sie fleißig, das ist so schnell,
dass man halt nichts mehr sieht und es ist so,
dass die grafische Oberfläche softwaretechnisch abgekoppelt worden ist vom Simulator.
Das heißt, der Simulator läuft hinten so schnell,
wie er rechnen kann und die Oberfläche zeigt das an,
was sie alles mitgeteilt bekommt und daddet immer irgendwann mal hin und her hinterher,
wenn sie soweit ist,
dass sie auch das kann,
weil die Grafikoberfläche ist wesentlich wesentlich langsamer als natürlich der
interne Simulator
Führt zu bestimmten Phänomenen oder bestimmten Situationen, ist hier für
euch aber auch nicht weiter interessant. Es ist nur,
dass ihr wisst, Software-Technik sind die sauber aufeinander abgekoppelt,
könnt ihr euch dann im Quellcode,
den ihr euch ja komplett angucken könnt, gern mal anschauen.
Hatte noch was mit entsprechenden Softwarearchitektur-Dingen zu tun. So,
wenn ich jetzt wieder halten möchte,
kann ich jetzt ein Halt ein Terminate machen,
wenn ich ein Hall-Simulation mache, dann hält er einfach irgendwo wieder an,
wo er sich gerade befindet.
Wenn ich das entsprechende Terminate hier benutze, dann ist die
ganze Simulation wieder weg. Was ich jetzt hier noch machen kann,
ist, dass ich den Formalismus wechsle,
das ist das, was wir beim nächsten Mal braucht.
Das findet ihr Simulation
Da findet ihr auch dann die entsprechenden Angaben. Und zwar hier nehmt ihr statt dem Java-Netcompiler,
weil jetzt könnten wir Jahreanschriften und so weiter mit einbauen.
Nehmt ihr die PT-Net-Compiler. In dem Augenblick werdet ihr jetzt,
wenn ihr jetzt sagt,
okay, ich habe das doch hier jetzt gemacht,
aha, das ist alles schön und gut,
wenn ich da jetzt irgendwas editieren möchte und ich gehe da rein,
dann ist das ein Fehler.
Weil es gilt ein anderes Syntax. In dem Moment,
wo ich in einer Formulismus einschalte, muss die Beschriftung anders aussehen.
Und welche Beschriftung ihr da machen könnt, könnt ihr euch
nochmal genauer angucken. Es wird auch noch beschrieben,
aber auf jeden Fall ist so eine eckige Klammer auf,
ey Klammer zu, nicht mehr das,
was ihr jetzt an der Oberfläche eingeben sollt,
sondern an der Oberfläche Welches habe ich jetzt falsch?
Offensichtlich wohl diese Marke hier? Muss ich jetzt mal wegen
einer Eins oder meinetwegen auch nur mit Vier eingeben?
Ich sage jetzt, ich trage da vier Marken ein,
weil das ist nämlich die Zusammenfassung, dass ich sage,
ich habe da vier Marken stehen, das sind abkürzende Schreibweise.
So, jetzt kann ich hingehen und wieder den Simulations-Step einrichten.
Und dann sehe ich hier, ich habe jetzt hier die geschaltet,
ich kann noch zweimal schalten,
sodass ich jeweils zwei Marken auf den Dingern liegen habe.
Das ist das, was ihr beim nächsten Mal dann benutzen werdet,
um noch so ein paar Sachen zu verstehen und einzusortieren und den einzelnen Sachen.
So, und da kann man entsprechend auch die Simulation machen.
Oder wenn ihr da draufklickt, werdet ihr feststellen,
dass dahinter tatsächlich wieder zwei Marken sind. Aber das ist dann das,
was hinter der Fassade liegt, was ihr eingeben dürft,
ist dann entsprechend die entsprechende 2. Inklusive der Kantenbeschriftung,
wenn ihr da was habt, könnt ihr ebenfalls was einstellen.
Ich höre es mal an. Wenn ihr hier jetzt entsprechend draufgeht,
könnt ihr dort ein entsprechendes X raufpacken und könnt dort entsprechend Zahlen ranschreiben,
die dann irgendwie sagen, wie viele Marken ihr abzieht.
Gut, wie gesagt, wenn ihr Fragen habt,
erkunde ich euch, tauscht euch irgendwie darüber aus.
Ansonsten, wenn ihr sonst keine Liefer findet,
bin ich euch an mich und dann hoffe ich mal,
dass wir uns am nächsten Dienstag in diesem Raum dann wiedersehen,
erst übernächste Woche sind wir wieder drüben.
Nächste Woche sind am Dienstag auch hier.
Gut,
bis dann