Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.
Aufgabe 9.3 ADT-Mengen
Seh ich das richtig (danke für die mail ;)) dass die Lösung der Aufgabe ganz einfach so ist:
create: Menge
add: T x Menge Menge
isIn: T x Menge Boolean
del: T x Menge Menge
empty: Menge Boolean
single: T Menge
union: Menge x Menge Menge
intersect: Menge x Menge Menge
und dann noch die axiome die ich im jpeg angehängt habe.
ist cdas schon alles?
Attachment:
Unbenannt.JPG: https://fsi.cs.fau.de/unb-attachments/post_30456/Unbenannt.JPG
du solltest noch ein paar axiome bei intersect und union einführen
also hab ich zumindestens gemacht… z.B.:
intersect(m,n)=intersect(n,m)
intersect(single(x),single(y)) = add(create,x) falls x=y
= create falls x≠y
könnte ich da nich noch viel mehr schreiben???
oder ist nur wichtig dass ich ein paar habe?
also ich hab da ne riesige liste von axiomen
hab mir allerdings noch keine großen gedanken darüber gemacht ob ich vielleicht ein paar weglassen könnte … lieber zuviel als zuwenig 
Eher nicht. Wenn du dir mal die Folie in der Vorleseung durchliest wirst du (in etwa) das finden:
Die Kunst der Spezifikation ist genau das zu beschreiben was benoetig wird und nicht zu viel.
ja klar … hast wohl recht
aber erstamal brainstorming und möglichst alles hinschreiben … danach kann ich immer noch schaun was zuviel ist
also ich hab die axiome mal so gesetzt:
empty(create) = true
empty(add(create,x)) = false
empty(single(x)) = false
isIn(add(create,y),x) = true falls x=y
= false falls x≠y
isIn(create,x) = false
isIn(single(x),y) = true falls x=y
= false falls x≠y
del(create,x) = create
del(add(create,y),x) = create falls x=y
= add(create,y) falls x≠y
del(single(y),x) = create falls x=y
= single(y) falls x≠y
intersect(m,n) = intersect(n,m)
intersect(single(x),create) = create
intersect(create,create) = create
intersect(add(create,x),add(create,y)) = add(create,x) falls x=y
= create falls x≠y
intersect(single(x),single(y)) = add(create,x) falls x=y
= create falls x≠y
intersect(single(x),add(create,y)) = add(create,x) falls x=y
= create falls x≠y
union(m,n) = union(n,m)
union(create,create) = create
union(single(x),create) = add(create,x)
union(single(x),single(y)) = add(add(create,y),x) falls x≠y
= add(create,x) falls x=y
union(add(create,x),add(create,y)) = add(add(create,y),x) falls x≠y
= add(create,x) falls x=y
add(single(x),y) = single(x)
add(create,x) = add(create,y) falls x=y
also ich hab jetz insgesamt 30 axiome. hier mach ich schluss egal obs noch welche gibt oder net…des muss reichen etz…
@raistlin
So ganz stimmen tut’s noch nicht so… Sind eigentlich auch viel mehr als notwendig, weil du [m]single(a)[/m] als elementar betrachtest, aber dafür könnte man ja [m]add(create,a)[/m] schreiben…
Bei [m]isIn[/m] sind im Moment 2 von unendlich vielen Fällen abgedeckt, und bei den anderen schaut’s recht ähnlich aus…
Man könnte sich das Ganze so vorstellen:
Was du durch die Axiome erzeugen kannst, ist im Prinzip eine Liste, und wenn du [m]add(L,x)[/m] in den Parametern stehen hast, kannst du ein Element [m]x[/m] von dieser Liste [m]L[/m] abschneiden. Und daraus kann man dann eine Rekursion basteln…
A ja, und ausgehen würd ich mal von einem [m]add[/m] wie bei MuMu.
du kannst nicht immer single(a) durch add(create,a) ersetzten weil single(a) eine einelementige Menge ist … da kann man nicht einfach was dazuaddieren oder abziehen weil dann ist es keine einelementige menge mehr
ich würd schon sagen das man da eine falluntschreidung machen muss
ansonsten hast du natürlich recht … war auch nur ein erster entwurf
Sagt aber doch auch keiner, dass es dann noch eine einelementige Menge sein muss…
{a} \ {a} = {}
und add(create,a) = {} u {a} = {a}
…oder versteh ich dich jetzt ganz falsch?
ähm :rolleyes:
meint ihr nicht, dass ihr’s euch bisschen kompliziert macht? die axiome decken doch ‘so-to-speak’ die minimalst nötigen operationen in hinsicht auf die jeweilige signatur aus - sprich mehr als 30 axiome (oder gar unendlich viele fallunterscheidungen :vogel: ) scheint mir etwas danebengepeilt… wir sollen doch nicht alles nochmal einzeln zerlegen (z.B. boolean zerpflücken…), oder???
mal den Ü-Leiter bequatschen…
Echte Axiome sind’s dann, wenn man nicht eines aus den anderen Ableiten kann.
Boolean zerpflücken?
In der Signatur hab ich’s natürlich drin, aber…
Und wenn ich mich nicht verzählt hab, komm ich auf 10 Stück. 
naja immoartl
single(a) sollte eigentlich nicht gleich add(create,a) sein … sonst hätten sies ja gleich weglassen können
ich denk einfach das eine einelementige menge eben auf genau ein element beschränkt ist sodass du keine operationen darauf ausführen kannst die diesen rahmen sprengen würden (also add und del)
bei union und intersect ist des wieder was anderes weil man da ja wirklich eine neue menge erzeugt (mit eigenem Namen) … in diesem fall könntest du sagen das single(a)=add(create,a) gilt
aber eben nicht allgemein
Also quasi eine Menge mit Schreibschutz?
…irgendwie klingt das jetzt fast ein bisserl böse…
War aber sicher nicht so gemeint…
naja bla
die aufgabe is ein einziges dummes defenitionen rumgeficke (ums mal drastisch auszudrücken)
ich definier des bei mir mal so das einelementige mengen eben so bleiben sollen … und eigentlich können sie mir da auch nix anrechnen … sind ja defenitionen und die kann ich definieren wie ich will -.-
es gibt laut musterlösung 13 axiome, waren früher mal 17, aber 4 konnten noch wegdefiniert werden. mein üleiter meinte, lieber 2 axiome mehr als 1 zu ewnig.
Müssen eigentlich auch Axiome wie
union(m, intersect(n, o)) = intersect(union(m, n), union(m, o)) (oder so ähnlich)
beachtet werden?
Ist mir gerade so eingefallen…
Ich würd mal sagen nein, weil beide letztendlich auf [m]add[/m] zurückgefürt werden [sollten], und daraus müsste man dann union(m, intersect(n, o)) = intersect(union(m, n), union(m, o)) ableiten können.