Künstliche Intelligenz I - Exam

Aufgabe 1)

• 1950: Alan Turing stellt den Turing-Test vor
• 1956: Dartmouth-Konferenz, KI als eigenständiges Forschungsfeld
• 1966-1974: Erste Erfolge und Ernüchterung (KI-Winter)
• 1980er: Expertensysteme erleben Kurzlebige Hochphase
• 1997: IBM Deep Blue besiegt Schachweltmeister Garry Kasparov
• 2000er: Fortschritte in maschinellem Lernen und Big Data
• 2010er: Durchbruch durch Deep Learning, AlphaGo

a)

1. Erläutere die Bedeutung der Dartmouth-Konferenz von 1956 für die Entwicklung der Künstlichen Intelligenz. Welche wesentlichen Unterschiede gab es in den Zielen und Erwartungen der Forscher von damals im Vergleich zu heute? Beziehe dich in Deiner Antwort auf die spezifischen Meilensteine in der Entwicklung der KI bis heute.

Lösung:

Bedeutung der Dartmouth-Konferenz von 1956 für die Entwicklung der Künstlichen Intelligenz

Die Dartmouth-Konferenz im Jahr 1956 markiert einen entscheidenden Wendepunkt in der Geschichte der Künstlichen Intelligenz (KI). Diese Konferenz gilt als die Geburtsstunde der KI als eigenständiges Forschungsfeld. Organisiert von John McCarthy, Marvin Minsky, Nathaniel Rochester und Claude Shannon, brachten Wissenschaftler zusammen, die daran interessiert waren, Maschinen zu entwickeln, die intelligente Verhalten zeigen könnten. Hier wurden die Grundsteine gelegt für viele der heutigen Methoden und Technologien in der KI.

• Ambitionierte Ziele: Die Forscher bei der Dartmouth-Konferenz hatten sehr ehrgeizige Ziele. Sie waren überzeugt, dass Maschinen innerhalb weniger Jahrzehnte menschliche Intelligenz nachahmen könnten. Es herrschte eine optimistische Stimmung, dass bedeutende Fortschritte leicht erreichbar wären.
• Begrenzte Technologie: Im Vergleich zu heute waren die technischen Mittel damals sehr begrenzt. Rechenkapazitäten und Speicher waren minimal, und die Algorithmen standen noch am Anfang ihrer Entwicklung.

Unterschiede in den Zielen und Erwartungen damals und heute

• Realismus: Die Erwartungen der Forscher in den 1950ern waren stark optimistisch und oft unrealistisch. Es wurde angenommen, dass maschinelle Intelligenz schnell erreicht werden könne. Im Gegensatz dazu sind die heutigen Ziele oft spezialisierter und realistischer, und es ist ein klareres Verständnis der Herausforderungen vorhanden.
• Technologischer Fortschritt: Heute verfügen wir über weit fortgeschrittene Technologien wie Hochleistungsrechner, große Datenmengen (Big Data) und ausgefeilte Algorithmen (beispielsweise Deep Learning). Diese Fortschritte waren in den 1950ern unvorstellbar.
• Konkrete Anwendungen: Während die frühen Forscher von allgemeinen, menschenähnlichen Intelligenzen träumten, hat sich der Fokus heute auf spezifische und praxisnahe Anwendungen verlagert. Beispiele hierfür sind Sprachassistenten, Bild- und Spracherkennung sowie autonome Fahrzeuge.

Spezifische Meilensteine in der Entwicklung der KI

• 1966-1974: Die ersten KI-Erfolge führten zu übertriebenem Optimismus, gefolgt von Ernüchterung und den sogenannten „KI-Wintern“, als Fortschritte langsamer als erwartet verliefen.
• 1980er: Kurzlebige Hochphase der Expertensysteme, die nutzen aus regelbasierten Systemen und domänenspezifischem Wissen ziehen, aber letztlich nicht die erhoffte breite Anwendung fanden.
• 1997: IBM Deep Blue besiegt Schachweltmeister Garry Kasparov, ein Meilenstein in der Demonstration der Fähigkeiten von KI.
• 2000er: Fortschritte in maschinellem Lernen und Big Data ermöglichen neue Anwendungen und verbessern bestehende Methoden erheblich.
• 2010er: Durchbruch durch Deep Learning und der Sieg von AlphaGo über den besten Go-Spieler der Welt zeigen das Potenzial moderner, datengetriebener KI-Methoden.

Die Dartmouth-Konferenz legte den Grundstein für diese Entwicklungen, indem sie eine Plattform für den Austausch von Ideen und die Bildung einer neuen wissenschaftlichen Gemeinschaft schuf, die sich der Erforschung künstlicher Intelligenz widmete.

b)

2. Im Jahr 1997 besiegte IBM Deep Blue den Schachweltmeister Garry Kasparov. Analysiere, warum dieser Sieg als bedeutender Meilenstein in der Geschichte der Künstlichen Intelligenz gilt. Diskutiere dabei die technischen Voraussetzungen, die zu diesem Erfolg führten, und vergleiche diese mit den technologischen Fortschritten im Bereich des maschinellen Lernens und Deep Learning, die in den 2010er Jahren durch AlphaGo veranschaulicht wurden.

Lösung:

IBM Deep Blue besiegt Garry Kasparov: Ein bedeutender Meilenstein

Der Sieg von IBM Deep Blue über den damaligen Schachweltmeister Garry Kasparov im Jahr 1997 gilt als eines der herausragenden Ereignisse in der Geschichte der Künstlichen Intelligenz (KI). Dieser Erfolg zeigte erstmals auf dramatische Weise, dass Computer in der Lage sind, komplexe Denkaufgaben, die menschliche Intelligenz und Strategie erfordern, zu bewältigen.

Technische Voraussetzungen für den Erfolg von Deep Blue

• Hohe Rechenkapazität: Deep Blue war speziell für Schach programmiert und konnte Millionen von Schachzügen pro Sekunde analysieren. Diese immense Rechenleistung ermöglichte es dem System, zahlreiche potentielle Spielzüge und deren Konsequenzen zu evaluieren und die besten Entscheidungen zu treffen.
• Erweiterte Algorithmen: Das System verwendete fortschrittliche Algorithmen zur Spielbaumsuche, wie den Minimax-Algorithmus und Techniken zur Alpha-Beta-Suche, um die Anzahl der zu prüfenden Stellungen zu reduzieren und die effizientesten Wege zu finden.
• Domänenspezifisches Wissen: Deep Blue profitierte von einem großen Vorrat an gespeicherten Schachpartien und spezifischen heuristischen Regeln, um seine Entscheidungsfindung weiter zu verfeinern.

Vergleich mit technologischen Fortschritten durch AlphaGo in den 2010er Jahren

In den 2010er Jahren setzte AlphaGo, entwickelt von DeepMind, einen neuen Standard für KI durch den Durchbruch von Deep Learning und modernem Maschinenlernen. Der Sieg von AlphaGo über den weltbesten Go-Spieler symbolisiert die Fortschritte und Unterschiede im Vergleich zu Deep Blue.

• Tiefe neuronale Netze: Im Gegensatz zu Deep Blue, das auf reiner Rechenleistung und spezifischen Algorithmen basierte, nutzte AlphaGo tiefe neuronale Netze, um Muster zu erkennen und komplexe Spielstrategien zu erlernen. Dies ermöglichte eine höhere Flexibilität und Anpassungsfähigkeit.
• Reinforcement Learning: AlphaGo verwendete Reinforcement Learning, eine Technik, bei der es durch Selbstspiel kontinuierlich seine Strategie verbessern konnte. Dies unterschied sich stark von den statischen, regelbasierten Methoden von Deep Blue.
• Big Data und moderne Hardware: Die Fortschritte im Bereich Big Data und die Verfügbarkeit moderner, leistungsstarker Hardware spielten eine Schlüsselrolle. AlphaGo konnte umfangreiche Datenmengen verarbeiten und von ihnen lernen, was Deep Blue so nicht in diesem Umfang möglich war.

Fazit

Der Sieg von Deep Blue im Jahr 1997 war ein Meilenstein, weil er demonstrierte, dass KI-Systeme spezifische, hochkomplexe Aufgaben bewältigen können, die bisher als Domäne des menschlichen Intellekts galten. Verglichen mit den späteren Fortschritten durch AlphaGo zeigt sich jedoch, wie dramatisch sich die Technologien weiterentwickelt haben. Während Deep Blue durch immense Rechenleistung und spezialisierte Algorithmen beeindruckte, basiert der Erfolg von AlphaGo auf der Fähigkeit moderner KI-Systeme, durch neuronale Netze und maschinelles Lernen von Erfahrungen zu lernen und komplexe, kreative Lösungen zu entwickeln.

Aufgabe 2)

Stell Dir vor, Du arbeitest an einem Roboterprojekt, bei dem ein Roboter den kürzesten Weg durch ein Labyrinth finden muss, das als ungewichteter Graph dargestellt wird. Implementiere die uninformierten Suchstrategien Breadth-First Search (BFS) und Depth-First Search (DFS), um zu vergleichen, welche Methode den kürzesten Pfad findet und warum.

a)

Teilaufgabe 1: Implementiere die beiden Suchalgorithmen BFS und DFS in Python für den gegebenen ungewichteten Graph. Der Graph ist als adjazenz-basierte Darstellung gegeben:

graph = {  'S': ['A', 'B'],  'A': ['C', 'D'],  'B': ['E'],  'C': [],  'D': ['G'],  'E': ['G'],  'G': []}

Basiere Deine Implementierung auf den genannten Komplexitätsbetrachtungen und berücksichtige sowohl die Zeit- als auch die Speicherkomplexität, wie sie im Kontext beschrieben sind. Zeige Deinen Python-Code und erläutere, welche Methode hier den kürzesten Pfad findet und warum.

Hinweis: Die Startknoten ist 'S' und das Zielknoten ist 'G'.

Lösung:

Teilaufgabe 1: Implementiere die beiden Suchalgorithmen BFS und DFS in Python für den gegebenen ungewichteten Graph. Der Graph ist als adjazenz-basierte Darstellung gegeben:

graph = {  'S': ['A', 'B'],  'A': ['C', 'D'],  'B': ['E'],  'C': [],  'D': ['G'],  'E': ['G'],  'G': []}

Hier ist die Implementierung der beiden Suchalgorithmen in Python:

def bfs(graph, start, goal):     queue = [[start]]     visited = set()     while queue:         path = queue.pop(0)         node = path[-1]         if node not in visited:             neighbours = graph[node]             for neighbour in neighbours:                 new_path = list(path)                 new_path.append(neighbour)                 queue.append(new_path)                 if neighbour == goal:                     return new_path             visited.add(node)     return Nonedef dfs(graph, start, goal):     stack = [[start]]     visited = set()     while stack:         path = stack.pop()         node = path[-1]         if node not in visited:             neighbours = graph[node]             for neighbour in neighbours:                 new_path = list(path)                 new_path.append(neighbour)                 stack.append(new_path)             if neighbour == goal:                     return new_path         visited.add(node)     return None

Jetzt werden wir die beiden Algorithmen testen, um den kürzesten Pfad vom Startknoten 'S' zum Zielknoten 'G' zu finden:

graph = {  'S': ['A', 'B'],  'A': ['C', 'D'],  'B': ['E'],  'C': [],  'D': ['G'],  'E': ['G'],  'G': []}# Breadth-First Searchbfs_path = bfs(graph, 'S', 'G')print(f'BFS Pfad: {bfs_path}')# Depth-First Searchdfs_path = dfs(graph, 'S', 'G')print(f'DFS Pfad: {dfs_path}')

Erläuterung:

• BFS (Breadth-First Search): BFS untersucht alle Knoten auf der aktuellen Ebene, bevor es zur nächsten Ebene übergeht. Dies garantiert, dass der erste gefundene Weg auch der kürzeste Pfad ist. In diesem Fall liefert BFS den kürzesten Pfad: ['S', 'B', 'E', 'G'].
• DFS (Depth-First Search): DFS untersucht so tief wie möglich entlang jedes Zweigs, bevor es zurückgeht. Dies führt dazu, dass DFS nicht unbedingt den kürzesten Pfad findet. In diesem Fall liefert DFS den Pfad: ['S', 'A', 'D', 'G'].

Die BFS-Methode findet den kürzesten Pfad, weil sie die Knoten in aufsteigender Entfernung vom Startknoten 'S' durchläuft, während DFS möglicherweise längere Umwege nimmt.

b)

Teilaufgabe 2: Angenommen, der Graph wäre nun gewichtet. Erläutere, warum BFS und DFS in einem gewichteten Graphen möglicherweise nicht mehr optimal oder korrekt funktionieren, um den kürzesten Pfad zu finden. Gib an, welche Anpassungen oder alternativen Algorithmen verwendet werden sollten, um den kürzesten Pfad im gewichteten Graphen zu gewährleisten. Formuliere Deine Antworten auf der Grundlage der Zeit- und Speicherkomplexität.

Optional: Nach deiner Erklärung, implementiere den Dijkstra's Algorithmus in Python zur Veranschaulichung.

Lösung:

Teilaufgabe 2: Angenommen, der Graph wäre nun gewichtet. Erläutere, warum BFS und DFS in einem gewichteten Graphen möglicherweise nicht mehr optimal oder korrekt funktionieren, um den kürzesten Pfad zu finden. Gib an, welche Anpassungen oder alternativen Algorithmen verwendet werden sollten, um den kürzesten Pfad im gewichteten Graphen zu gewährleisten. Formuliere Deine Antworten auf der Grundlage der Zeit- und Speicherkomplexität.

• BFS (Breadth-First Search): BFS ist für ungewichtete Graphen ausgelegt und garantiert dort den kürzesten Pfad, da es die Knoten in aufsteigender Entfernung vom Startknoten durchläuft. In einem gewichteten Graphen berücksichtigt BFS jedoch nicht die unterschiedlichen Gewichte der Kanten. Daher kann BFS nicht garantieren, dass der gefundene Pfad der kürzeste ist.
• DFS (Depth-First Search): DFS sucht so tief wie möglich in jedem Zweig, bevor es zurückkehrt. Dies führt häufig dazu, dass DFS lange und möglicherweise ineffiziente Wege untersucht, ohne die Kantengewichte zu berücksichtigen. Daher kann DFS in einem gewichteten Graphen ebenfalls nicht den kürzesten Pfad garantieren.

Um den kürzesten Pfad in einem gewichteten Graphen zu finden, sollten spezifische Algorithmen verwendet werden, die die Kantengewichte berücksichtigen. Ein üblicher und sehr effizienter Algorithmus für diesen Zweck ist der Dijkstra's Algorithmus.

Dijkstra's Algorithmus:

• Zeitkomplexität: O((V + E) log V) unter Verwendung einer Prioritätswarteschlange (mit Fibonacci-Heaps sogar O(E + V log V)), wobei V die Anzahl der Knoten und E die Anzahl der Kanten ist.
• Speicherkomplexität: O(V), da wir Informationen über alle Knoten speichern müssen (Abstände, Vorgängerknoten etc.).

Implementierung von Dijkstra's Algorithmus in Python:

import heapqdef dijkstra(graph, start, goal):     queue = []     heapq.heappush(queue, (0, start))     distances = {node: float('infinity') for node in graph}     distances[start] = 0     previous_nodes = {node: None for node in graph}     while queue:         current_distance, current_node = heapq.heappop(queue)         if current_node == goal:             path = []             while previous_nodes[current_node] is not None:                 path.append(current_node)                 current_node = previous_nodes[current_node]             path.append(start)             return path[::-1]         for neighbor, weight in graph[current_node].items():             distance = current_distance + weight             if distance < distances[neighbor]:                 distances[neighbor] = distance                 previous_nodes[neighbor] = current_node             heapq.heappush(queue, (distance, neighbor))     return None# Beispielgraph mit Gewichtenweighted_graph = {  'S': {'A': 1, 'B': 4},  'A': {'C': 2, 'D': 5},  'B': {'E': 3},  'C': {},  'D': {'G': 2},  'E': {'G': 1},  'G': {}}# Dijkstra's Algorithmus verwendenshortest_path = dijkstra(weighted_graph, 'S', 'G')print(f'Dijkstra Pfad: {shortest_path}')

Zusammenfassend lässt sich sagen, dass BFS und DFS in gewichteten Graphen möglicherweise nicht den kürzesten Pfad finden. Um dies zu gewährleisten, sollte Dijkstra's Algorithmus oder ein ähnlicher Algorithmus verwendet werden, da er die Kantengewichte berücksichtigt und den effizientesten Pfad sucht.

Aufgabe 3)

A*-Algorithmus: Der A*-Algorithmus ist ein Suchalgorithmus, der sowohl die tatsächlichen Kosten vom Startknoten bis zum aktuellen Knoten ( g(n) ) als auch eine Heuristik, die die geschätzten Kosten vom aktuellen Knoten bis zum Zielknoten ( h(n) ) beschreibt, verwendet, um den optimalen Pfad zu finden. Die Gesamtkostenfunktion ist durch f(n) = g(n) + h(n) definiert. Geforderte Eigenschaften des Algorithmus:

• Die Heuristik h(n) muss zulässig sein, d.h., sie darf niemals die tatsächlichen Kosten überschätzen.
• Der Algorithmus ist vollständig und optimal, wenn die Heuristik zulässig ist.
• Es werden eine Prioritätswarteschlange (Open List) und eine Menge besuchter Knoten (Closed List) verwendet.
• Algorithmusablauf:
  1. Initialisiere die Open List mit dem Startknoten.
  2. Wiederhole den Prozess:
     • Entnimm den Knoten mit dem kleinsten f(n) aus der Open List.
     • Überprüfe, ob der Zielknoten erreicht ist. Wenn ja, gib den Pfad aus.
     • Erweitere den Knoten und berechne die f-Werte für alle Nachfolger.
     • Füge die Nachfolger zur Open List hinzu, wenn sie nicht in der Closed List sind oder niedrigere f-Werte haben.
     • Füge den betrachteten Knoten zur Closed List hinzu.

a)

Gegeben sei das folgende Graphdiagramm, in dem die Knotenpunkte durch die Angaben in Klammern und die Oberflächen und Kosten von durch Kanten verbundene Knoten dargestellt sind:

            (Start) A -----5---- B 

                |              |                         9              2                         |              |                         C -----3----  D 

                     Die Heuristik h(n) ist wie folgt gegeben:                      h(A) = 7,     h(B) = 4,     h(C) = 8,     h(D) = 2     h(End) = 0         Berechne mit Hilfe des A*-Algorithmus den optimalen Pfad von A nach D und gib den Pfad zusammen mit den f(n)-Werten für jeden Knoten an. 
 Lösung: 
A*-Algorithmus:
Der A*-Algorithmus ist ein Suchalgorithmus, der sowohl die tatsächlichen Kosten vom Startknoten bis zum aktuellen Knoten (g(n)) als auch eine Heuristik, die die geschätzten Kosten vom aktuellen Knoten bis zum Zielknoten (h(n)) beschreibt, verwendet, um den optimalen Pfad zu finden. Die Gesamtkostenfunktion ist durch f(n) = g(n) + h(n) definiert.
Geforderte Eigenschaften des Algorithmus:

• Die Heuristik h(n) muss zulässig sein, d.h., sie darf niemals die tatsächlichen Kosten überschätzen.
• Der Algorithmus ist vollständig und optimal, wenn die Heuristik zulässig ist.
• Es werden eine Prioritätswarteschlange (Open List) und eine Menge besuchter Knoten (Closed List) verwendet.
• Algorithmusablauf:
  1. Initialisiere die Open List mit dem Startknoten.
  2. Wiederhole den Prozess:
     • Entnimm den Knoten mit dem kleinsten f(n) aus der Open List.
     • Überprüfe, ob der Zielknoten erreicht ist. Wenn ja, gib den Pfad aus.
     • Erweitere den Knoten und berechne die f-Werte für alle Nachfolger.
     • Füge die Nachfolger zur Open List hinzu, wenn sie nicht in der Closed List sind oder niedrigere f-Werte haben.
     • Füge den betrachteten Knoten zur Closed List hinzu.

Gegeben sei das folgende Graphdiagramm:

 (Start) A -----5---- B |              | 9              2 |              | C -----3----  D 

Die Heuristik h(n) ist wie folgt gegeben:

• h(A) = 7
• h(B) = 4
• h(C) = 8
• h(D) = 2
• h(End) = 0

Schritte, um den optimalen Pfad von A nach D mit dem A*-Algorithmus zu berechnen:

1. Initialisiere die Open List mit dem Startknoten A:

• Open List: {A}
• Closed List: {}

• Open List: {}
• Closed List: {A}

• Berechnung der f(n)-Werte:
  • g(A) = 0, h(A) = 7, also f(A) = g(A) + h(A) = 0 + 7 = 7
  • g(B) = g(A) + Kosten(A, B) = 0 + 5 = 5, h(B) = 4, also f(B) = g(B) + h(B) = 5 + 4 = 9
  • g(C) = g(A) + Kosten(A, C) = 0 + 9 = 9, h(C) = 8, also f(C) = g(C) + h(C) = 9 + 8 = 17
• Open List: {B (f = 9), C (f = 17)}
• Closed List: {A}

• Open List: {C}
• Closed List: {A, B}

• g(D) = g(B) + Kosten(B, D) = 5 + 2 = 7, h(D) = 2, also f(D) = g(D) + h(D) = 7 + 2 = 9
• Open List: {C (f = 17), D (f = 9)}
• Closed List: {A, B}

• Da D der Zielknoten ist, ist der optimale Pfad gefunden.
• Pfad: A -> B -> D

Ergebnis:

Der optimale Pfad von A nach D ist A -> B -> D.

Die f(n)-Werte für jeden Knoten auf dem Pfad sind:

• A: f(A) = 7
• B: f(B) = 9
• D: f(D) = 9

b)

Die Heuristik spielt eine maßgebliche Rolle im A*-Algorithmus. Bestimme, ob die gegebene Heuristik h(n) zulässig ist und begründe deine Antwort. Zeige detailliert, warum oder warum nicht jede der Heuristiken die Anforderungen einer zulässigen Heuristik erfüllt.

Lösung:

Die Rolle der Heuristik im A*-Algorithmus:

Die Heuristik h(n) spielt eine entscheidende Rolle im A*-Algorithmus, da sie dazu dient, die geschätzten Kosten vom aktuellen Knoten bis zum Zielknoten zu bestimmen. Damit der A*-Algorithmus funktioniert und den optimalen Pfad findet, muss die Heuristik zulässig sein.

Zulässigkeit einer Heuristik:

Eine Heuristik h(n) ist zulässig, wenn sie die tatsächlichen Kosten zum Zielknoten niemals überschätzt. Das bedeutet, dass h(n) immer kleiner oder gleich den tatsächlichen minimalen Kosten von einem Knoten bis zum Zielknoten sein muss:

h(n) ≤ tatsächliche Kosten

Gegebene Heuristik:

• h(A) = 7
• h(B) = 4
• h(C) = 8
• h(D) = 2
• h(End) = 0

Überprüfung der Zulässigkeit der Heuristik:

Wir überprüfen nun die gegebene Heuristik, indem wir die geschätzten Kosten mit den tatsächlichen minimalen Kosten vergleichen.

Von Knoten A zum Ziel D:

• Tatsächliche minimalen Kosten: A → B → D = 5 + 2 = 7
• Heuristik: h(A) = 7
• h(A) ≤ tatsächliche Kosten (7 ≤ 7) ✔

Von Knoten B zum Ziel D:

• Tatsächliche minimalen Kosten: B → D = 2
• Heuristik: h(B) = 4
• h(B) ≤ tatsächliche Kosten (4 ≤ 2) ❌

Von Knoten C zum Ziel D:

• Tatsächliche minimalen Kosten: C → D = 3
• Heuristik: h(C) = 8
• h(C) ≤ tatsächliche Kosten (8 ≤ 3) ❌

Von Knoten D zum Ziel D:

• Tatsächliche minimalen Kosten: D → D = 0
• Heuristik: h(D) = 2
• h(D) ≤ tatsächliche Kosten (2 ≤ 0) ❌

Vom Ziel (End) zum Ziel D:

• Tatsächliche minimalen Kosten: End → D = 0
• Heuristik: h(End) = 0
• h(End) ≤ tatsächliche Kosten erfüllt immer ✔

Fazit:

Die gegebene Heuristik ist nicht zulässig, da die geschätzten Kosten für die Knoten B, C und D die tatsächlichen minimalen Kosten überschätzen. Eine zulässige Heuristik muss sicherstellen, dass die geschätzten Kosten immer kleiner oder gleich den tatsächlichen minimalen Kosten sind. Dies ist in diesem Fall nicht gegeben.

Aufgabe 4)

Im Rahmen der Vorlesung 'Künstliche Intelligenz I' haben wir logikbasierte Repräsentationen zur Wissensdarstellung und -verarbeitung in der KI behandelt. Diese umfassen die Prädikatenlogik als Erweiterung der Aussagenlogik mit Quantoren und Prädikaten, die Syntax und Semantik von Logiksprachen, sowie Techniken zur automatischen Beweisführung. Eine wichtige Methode ist die Umwandlung in die Skolemform, um Existenzquantoren zu eliminieren. Außerdem hast Du über gängige Schlussregeln wie Modus Ponens, Modus Tollens und Resolution sowie logikbasierte Repräsentationssysteme wie Prolog und Datalog gelernt.

c)

Implementiere eine einfache Prolog-Datenbank, die die oben gegebenen Prädikatenlogikaussagen repräsentiert. Füge eine Regel hinzu, die überprüft, ob Sokrates sterblich ist.

'write your code actual here'

mortal(X) :- human(X). human(socrates). ?- mortal(socrates).

Lösung:

Implementierung einer Prolog-Datenbank zur Repräsentation der Prädikatenlogikaussagen

Basierend auf den gegebenen Prädikatenlogikaussagen implementieren wir eine einfache Prolog-Datenbank. Die Aufgabe besteht darin, zu überprüfen, ob Sokrates sterblich ist. Hier ist der vollständige Prolog-Code:

  % Definition der Regel mortal(X) :- human(X).  % Fakten human(socrates).  % Anfrage %?- mortal(socrates).  

Erklärung:

• mortal(X) :- human(X). Diese Regel gibt an, dass X sterblich ist, wenn X ein Mensch ist. Dies entspricht der logischen Aussage: \(\forall x (Mensch(x) \rightarrow Sterblich(x))\).
• human(socrates). Dieser Fakt gibt an, dass Sokrates ein Mensch ist: \(Mensch(Sokrates)\).
• %?- mortal(socrates). Diese Anfrage überprüft, ob Sokrates sterblich ist. Kommentiere sie aus, um bei der Ausführung des Prolog-Codes eine Antwort zu erhalten.

Dieser Prolog-Code ermöglicht es der Datenbank, zu überprüfen, ob Sokrates sterblich ist, basierend auf den gegebenen Prädikatenlogikaussagen.