Botanischer Garten und Botanisches Museum, 2k

Biodiversitätsinformatik / Biodiversity Informatics
Botanischer Garten und Botanisches Museum Berlin-Dahlem

MoreTax

Festlegung einer formalen Sprache zur Regelformulierung

INHALT:  Die Ausgangssituation | Der "potential Taxon"-Graph | Benutzerabfragen |
  Die Übertragbarkeit | Die formale Beschreibung | Beispiele | Editierbares Regelsystem

Die Ausgangssituation

Eine Vielzahl von Sachdaten, die sich in unabhängigen über die Welt zerstreuten Quellen (Literatur, Datenbanken, usw.) befinden, sind an Taxonnamen gekoppelt und können über diese verknüpft werden. Erhebliche Schwierigkeiten dieses Wissen zusammenzuführen entstehen dadurch, dass oft in den verschiedenen Quellen unterschiedliche Auffassungen über Systematik (d. h. auch über den zu benutzenden Taxonname) und/oder die Umschreibung des Taxons vertreten werden. Die Frage nach der Übertragbarkeit von Sachdaten, die an einem Taxonnamen aus einer Quelle gekoppelt sind, zu Taxonnamen aus einer anderen Quelle ist Gegenstand des Forschungsprojekts „MoreTax“.

ZURÜCK

Der „potential Taxon“-Graph

Eine Auffassung über ein Taxon in einer besonderen Quelle kann formal durch die Kopplung des benutzten Taxonnamens mit dem Quellenhinweis bezeichnet werden. Ein spezieller Editor (der taxonomische Editor) hat die Funktion, einerseits diese Paare (wir nennen sie „potential Taxon“) aus Taxonnamen und Quellenhinweis aufzulisten und andererseits einem Experten(-team) zu ermöglichen, die nach seiner Meinung existierenden Mengenbeziehungen zwischen den diesen potential Taxa zugrunde liegenden Umschreibungen der Taxa festzuhalten.

Folgende Grundbeziehungen aus der Mengenlehre sind für die Beschreibung der Beziehung zwischen zwei potential Taxa PT1 und PT2 relevant:

 

R1. PT1 und PT2 sind kongruent
PT1 º PT2                   xÎ PT1 Û xÎ PT2   

 

 

R2. PT1 ist enthalten in PT2  
PT1 Ì PT2                  xÎ PT1 Þ xÎ PT2, $yÎ PT2 | yÏ PT1

 

 

R3. PT1 enthält PT2
PT1 É PT2                  xÎ PT2Þ xÎ PT1, $yÎ PT1 | yÏ PT2

 

 

R4. PT1 und PT2 überlappen sich
PT1 Å PT2                  $xÎ PT1 | xÏ  PT2, $yÎ PT2 | yÏ PT1,                                     $zÎ PT1 | zÎ PT2

 

 

R5. PT1 und PT2 sind disjunkt  
PT1 ! PT2                    xÎ PT1 Þ xÏ PT2

 

Dadurch entsteht ein gerichteter Graph, dessen Knoten die „potential Taxa“ sind und dessen Kanten oder Senken, die Paare aus „potential Taxa“ sind, für welche vom Experten(-team) Mengenbeziehungen eingegeben worden sind:

 

 

ZURÜCK

Benutzerabfragen

Vorausgesetzt es gibt einen Pool von (mittels des taxonomischen Editors) verbundenen Quellen, dann sind vom Standpunkt eines Benutzers zwei grundsätzlich unterschiedliche sachdatenbezogene Abfragen möglich:

  • Für welche Taxa (de facto: „potential Taxa“) gelten bestimmte Sachdaten?

  • Welche Sachdaten gelten für bestimmte Taxonnamen (de facto: „potential Taxa“)?

Das Ergebnis soll zunächst davon unabhängig sein, an welche „potential Taxa“ diese Sachdaten ursprünglich gekoppelt waren. Hierfür muss ein auf dem Graph beruhendes Regelsystem aufgebaut werden. Darüber hinaus soll auch die Möglichkeit geschaffen werden, flexible Regeln zu formulieren, die das Ergebnis beeinflussen, und die von Datenquellen, vom Autor der Beziehung etc. abhängen können. Insgesamt muss der Benutzer über die Qualität der Sachdatenübertragung informiert werden.

ZURÜCK

Die Übertragbarkeit

Basierend auf dem Beziehungsgraph sind mindestens zwei Optionen für die Übertragbarkeit von am potential Taxon PT1 gekoppelten Sachdaten zum potential Taxon PT2 zu unterscheiden:

  • Voll übertragbar, wenn PT1 º PT2 oder PT1 É PT2

  • Partiell übertragbar, wenn PT1 Ì PT2 oder PT1 Å PT2

Wie man sieht, hängt die Qualität der Übertragbarkeit von der Art der Beziehung zwischen den potential Taxa ab.

Betrachtet man den Graph, so wird ersichtlich, dass es nicht für alle Paare von potential Taxa eine Kante gibt, obwohl es zwischen ihnen einen Weg (Aufeinanderfolge von Kanten) geben kann. Dies trifft in unserem Beispiel für PTi und PTk zu. Es muss also eine Regel geben, nach der aus zwei aufeinanderfolgenden Mengenbeziehungen eine resultierende Mengenbeziehung abgeleitet werden kann. Sind z. B. Bij und Bjk die Mengenbeziehung „Ì“, so ist es leicht zu sehen, dass die resultierende Beziehung zwischen PTi und PTk ebenfalls „Ì“ ist und dementsprechend Sachdaten von PTi zu PTk partiell übertragbar sind. Nehmen wir an, dass Bij „Ì“ bleibt aber Bjk „Å“ ist. Man kann dann feststellen, dass die resultierende Beziehung zwischen PTi und PTk nicht mehr eindeutig ist sondern „Ì“ oder „Å“ oder sogar „!“ sein kann. Dies erzwingt die Einführung von „zusammengesetzten“ Beziehungen und eine entsprechende Ausdehnung der Übertragbarkeiten samt deren Kriterien. Mit dieser erweiterten Regel kann dann für jeden Weg im Graph eine zugehörige zusammengesetzte Beziehung ermittelt werden.

Zwischen zwei potential Taxa kann es im Graph durchaus mehrere Wege geben. Dies trifft für PTi und PTl zu, denn es gibt einen „direkten“ Weg - nämlich die entsprechende Kante - und auch den (Um-)Weg über PTj. Zu jedem Weg gehört eine zusammengesetzte Beziehung. Zusätzliche Regel müssen also festlegen, wie zu verfahren ist, um aus zwei so entstandenen Beziehungen die resultierende zusammengesetzte Beziehung zu erhalten. Dies führt zu mindestens zwei alternativen Regeln.

Bedenkt man, dass zu jeder gerichtete Beziehung zwischen zwei potential Taxa PT1 und PT2 eine umgekehrte gerichtete Beziehung zwischen PT2 und PT1 ebenfalls durch eine entsprechende Regel definiert werden kann, so erhalten wir mindestens vier unterschiedliche Regeln.

Schließlich muss festgelegt werden, wie resultierende zusammengesetzte Beziehungen im Hinblick auf die Qualität der Übertragbarkeit zu interpretieren sind.

ZURÜCK

Die formale Beschreibung

Die Übertragbarkeit von ursprünglich an einem PTq gekoppelten Sachdaten zu einem PTz hängt also vom potential Taxon-Graph ab, oder präziser von der Menge aller Wege von PTq nach PTz und von den gerichteten Beziehungen, die den einbezogenen Kanten zugeordnet sind. Die Ableitung der Übertragbarkeit basiert also:

  • einerseits auf Algorithmen, die aus einem gerichteten Graph alle Wege von PTq nach PTz ermitteln und

  • andererseits auf einen Kern von Regeln, die jedem Weg eine Beziehung anhand der vorhandenen Beziehungen zuordnet und zu der Menge aller Wege von PTq nach PTz eine endgültige Beziehung ermittelt, die ihrerseits für die Qualität der Übertragbarkeit interpretiert wird.

Für die formale Beschreibung eines solchen Graphs sowie der Algorithmen und Regeln kann eine beliebige höhere Programmiersprache verwendet werden. Diese Regeln brauchen nicht editierbar zu sein, da sie nicht von den spezifischen Inhalten der einbezogenen Daten abhängen. Wir haben als Beispiel einen "Beziehungsdatentyp" sowie darauf basierende Regeln mit Visual Basic formuliert.

ZURÜCK

Beispiele

Definition eines Datentyps für "zusammengesetzte Beziehungen"-Objekte:

Public Type Relationship
   Congruent_to As Boolean
   Is_included_in As Boolean
   Includes As Boolean
   Overlaps As Boolean
   Excludes As Boolean
   Doubtful As Boolean
End Type

Regel für die Umkehrung "zusammengesetzter Beziehungen":

Public Function reverse(Rel1 As Relationship) As Relationship
   reverse = Rel1
   reverse.Is_included_in = Rel1.Includes
   reverse.Includes = Rel1.Is_included_in
End Function

Regel für die Zusammenführung zweier "zusammengesetzten Beziehungen" (enger Konsens):

Public Function cons(Rel1 As Relationship, Rel2 As Relationship) As Relationship
   If Rel1.Doubtful = Rel2.Doubtful Then
      cons.Congruent_to = Rel1.Congruent_to And Rel2.Congruent_to
      cons.Is_included_in = Rel1.Is_included_in And Rel2.Is_included_in
      cons.Includes = Rel1.Includes And Rel2.Includes
      cons.Overlaps = Rel1.Overlaps And Rel2.Overlaps
      cons.Excludes = Rel1.Excludes And Rel2.Excludes
      cons.Doubtful = Rel1.Doubtful
   ElseIf Rel1.Doubtful = False Then
      cons.Congruent_to = Rel1.Congruent_to
      cons.Is_included_in = Rel1.Is_included_in
      cons.Includes = Rel1.Includes
      cons.Overlaps = Rel1.Overlaps
      cons.Excludes = Rel1.Excludes
      cons.Doubtful = Rel1.Doubtful
   Else
      cons.Congruent_to = Rel2.Congruent_to
      cons.Is_included_in = Rel2.Is_included_in
      cons.Includes = Rel2.Includes
      cons.Overlaps = Rel2.Overlaps
      cons.Excludes = Rel2.Excludes
      cons.Doubtful = Rel2.Doubtful
   End If
End Function

Regel für die Zusammenführung zweier "zusammengesetzten Beziehungen" (breiter Konsens):

Public Function large_cons(Rel1 As Relationship, Rel2 As Relationship) As Relationship
   large_cons.Congruent_to = Rel1.Congruent_to Or Rel2.Congruent_to
   large_cons.Is_included_in = Rel1.Is_included_in Or Rel2.Is_included_in
   large_cons.Includes = Rel1.Includes Or Rel2.Includes
   large_cons.Overlaps = Rel1.Overlaps Or Rel2.Overlaps
   large_cons.Excludes = Rel1.Excludes Or Rel2.Excludes
   large_cons.Doubtful = Rel1.Doubtful Or Rel2.Doubtful
End Function

Regel für die Verkettung zweier aufeinanderfolgenden "zusammengesetzten Beziehungen":

Public Function concatenate(Rel1 As Relationship, Rel2 As Relationship) As Relationship
Dim RelNull As Relationship
Dim RelFull As Relationship
Dim TempRelResult As Relationship

   RelNull.Congruent_to = False
   RelNull.Is_included_in = False
   RelNull.Includes = False
   RelNull.Overlaps = False
   RelNull.Excludes = False
   RelNull.Doubtful = False

   RelFull.Congruent_to = True
   RelFull.Is_included_in = True
   RelFull.Includes = True
   RelFull.Overlaps = True
   RelFull.Excludes = True
   RelFull.Doubtful = False


   concatenate = RelNull
   TempRelResult = RelNull

   If Rel1.Congruent_to Then
      concatenate = Rel2
   End If
   If Rel2.Congruent_to Then
      TempRelResult = Rel1
      concatenate = large_cons(concatenate, TempRelResult)
      TempRelResult = RelNull
   End If
   If Rel1.Is_included_in Then
      If Rel2.Is_included_in Then
         TempRelResult.Is_included_in = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Includes Then
         TempRelResult = RelFull
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Overlaps Then
         TempRelResult.Is_included_in = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Excludes Then
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
   End If

   If Rel1.Includes Then
      If Rel2.Is_included_in Then
         TempRelResult.Congruent_to = True
         TempRelResult.Is_included_in = True
         TempRelResult.Includes = True
         TempRelResult.Overlaps = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Includes Then
         TempRelResult.Includes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Overlaps Then
         TempRelResult.Includes = True
         TempRelResult.Overlaps = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Excludes Then
         TempRelResult.Includes = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
   End If

   If Rel1.Overlaps Then
      If Rel2.Is_included_in Then
         TempRelResult.Is_included_in = True
         TempRelResult.Overlaps = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Includes Then
         TempRelResult.Includes = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Overlaps Then
         TempRelResult = RelFull
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Excludes Then
         TempRelResult.Includes = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
   End If

   If Rel1.Excludes Then
      If Rel2.Is_included_in Then
         TempRelResult.Is_included_in = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Includes Then
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Overlaps Then
         TempRelResult.Is_included_in = True
         TempRelResult.Overlaps = True
         TempRelResult.Excludes = True
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
      If Rel2.Excludes Then
         TempRelResult = RelFull
         concatenate = large_cons(concatenate, TempRelResult)
         TempRelResult = RelNull
      End If
   End If

   concatenate.Doubtful = Rel1.Doubtful Or Rel2.Doubtful

End Function

Regel für die Interpretation "zusammengesetzter Beziehungen":

Public Function evaluate(Rel1 As Relationship) As String
   If (Not Rel1.Congruent_to) And (Not Rel1.Is_included_in) And (Not Rel1.Includes) And (Not Rel1.Overlaps) And (Not Rel1.Excludes) Then
      evaluate = " Contradiction !"
   ElseIf (Not Rel1.Doubtful) Then
      If (Not Rel1.Excludes) Then
         If (Not Rel1.Is_included_in) And (Not Rel1.Overlaps) Then
            evaluate = " fully tansmit. !"
         Else
            evaluate = " partially tansmit. !"
         End If
      Else
         If (Rel1.Congruent_to Or Rel1.Is_included_in Or Rel1.Includes Or Rel1.Overlaps) Then
            evaluate = " dubiously tansmit. !"
         Else
            evaluate = " not tansmit. !"
         End If
      End If
   Else
      If (Not Rel1.Excludes) Then
         If (Not Rel1.Is_included_in) And (Not Rel1.Overlaps) Then
            evaluate = " fully tansmit. ?"
         Else
            evaluate = " partially tansmit. ?"
         End If
      Else
         If (Rel1.Congruent_to Or Rel1.Is_included_in Or Rel1.Includes Or Rel1.Overlaps) Then
            evaluate = " dubiously tansmit. ?"
         Else
            evaluate = " not tansmit. ?"
         End If
      End If
   End If
End Function

ZURÜCK

Editierbares Regelsystem

Es gibt Situationen in denen - in Abhängigkeit von spezifischen Merkmalen der einbezogenen Daten(-quellen) - das Einführen neuer Regeln bzw. Veränderungen schon existierender Regeln sinnvoll ist, z. B.:

  • Berücksichtigung bzw. Nichtberücksichtigung bestimmter im System verfügbarer Datenquellen

  • Bevorzugte Behandlung bestimmter Datenquellen in der Datenausgabe

  • Gewichtung von Beziehungen in Abhängigkeit von ihrer Quelle (z. B. höhere Gewichtung der von einem bestimmten Experten vertretenen Meinung zu einer bestimmten Gruppe)

  • Besondere Behandlung von Anfragen, deren Ergebnis ein besonderes Risiko beinhalten könnte (z. B. medizinische oder artenschutzrelevante Information)

Da Regeln dieser Art nicht grundsätzlich vorhersehbar sind, und sich z. B. auch direkt auf Dateninhalte und Metadaten der Quelle beziehen können, dürfen sie nicht fest im Kern der Auswertungsalgorithmen verankert sein, sondern müssen zur Laufzeit eingelesen und angewendet werden. 

Um die Anpassung dieser Regeln zu erleichtern, sollten sie in einer an die Aussagenlogik angelehnten formalen Sprache formuliert werden, die auch die Implementierung einer Benutzerschnittstelle zur Wartung dieser Regel erleichtert. Die Programmiersprache Prolog erfüllt diese Anforderungen und wird von uns zur weiteren Beschreibung des Systems benutzt werden. Für die Implementierung kommen aber auch andere Sprachen in Frage und es ist alternativ auch eine Entwicklung auf Basis einer komplexen Konfigurationsdatei denkbar, aus der Parameter beim Applikationsaufruf übermittelt werden.

ZURÜCK

Marc Geoffroy, Anton Güntsch & Walter G. Berendsohn, August 2001

__________________________________________________________________________

 

MoreTax (Modellierung von regelbasierten Funktionalitäten) ist ein vom
Bundesamt für Naturschutz (BfN) finanziertes  Forschungs- und Entwicklungsvorhaben 

Projektleiter: Walter Berendsohn
Wissenschaftlicher Mitarbeiter: Marc Geoffroy

Diese Seite wurde zuletzt am 19-06-2002 geändert

Abt. Biodiversitätsinformatik /
Dept. of Biodiversity Informatics
BGBM 
Index

© Freie Universität Berlin, Botanischer Garten und Botanisches Museum Berlin-Dahlem,
Seitenverantwortlicher / Page editor: M. Geoffroy.     BGBM Impressum / Imprint