Första ordningens logik i Python

Denna handledning är en introduktion till första ordningens logik (FOL) i Python. Jag ska visa dig hur man skapar en kunskapsbas, hur man gör slutsatser med framåtkedjning och hur man gör slutsatser med bakåtkedjning.

Första ordningens logik (FOL) är ett språk med objekt, funktioner, variabler och symboler. FOL används för att representera kunskap och för att göra slutsatser utifrån kunskap. Du kan lägga till meningar (fakta och regler) i en kunskapsbas och sedan ställa frågor till kunskapsbasen. Anslutningssymbolerna som används i första ordningens logik listas nedan.

Symbol	Kod	Exempel	Förklaring
¬	~	~Has(Letter)	Negation, finns inte eller existerar inte
^	&	A & B	Och, alla termer måste vara sanna
∨	|	A | B	Eller, ett av villkoren måste vara sant
⇒	==>	Connected(x,y) ==> Connected(y,x)	Implicera, om den första termen är sann så är den andra termen sann
⇔	<=>	C <=> D	Ekvivalens, om och bara om. C är sann om och bara om D är sann.

En första ordens kunskapsbas för logik kan bara innehålla bestämda klausuler. En bestämd klausul är en klausul med högst en positiv bokstav, du kan använda parenteser för att säkerställa att dina klausuler är bestämda.

Jag använder kod från aima-python i den här handledningen (ladda ner paket), dessa moduler innehåller alla nödvändiga klasser och funktioner för första ordningens logik i Python. Kunskapsbasen skapas utifrån följande mening: Lagen säger att det är ett brott för en amerikan att sälja vapen till fientliga länder. Landet Nono, en fiende till Amerika, har några missiler, och alla dess missiler såldes till av överste West, som är amerikan.

Bakåtkedjning

En algoritm för bakåtkedjning börjar från målet och kedjar sig igenom regler för att hitta fakta som stöder målet. Denna algoritm hittar bara det första faktum som stöder målet, även om det finns flera svar i kunskapsbasen.

# Import libraries
import aima.utils
import aima.logic

# The main entry point for this module
def main():

    # Create an array to hold clauses
    clauses = []

    # Add first-order logic clauses (rules and fact)
    clauses.append(aima.utils.expr("(American(x) & Weapon(y) & Sells(x, y, z) & Hostile(z)) ==> Criminal(x)"))
    clauses.append(aima.utils.expr("Enemy(Nono, America)"))
    clauses.append(aima.utils.expr("Owns(Nono, M1)"))
    clauses.append(aima.utils.expr("Missile(M1)"))
    clauses.append(aima.utils.expr("(Missile(x) & Owns(Nono, x)) ==> Sells(West, x, Nono)"))
    clauses.append(aima.utils.expr("American(West)"))
    clauses.append(aima.utils.expr("Missile(x) ==> Weapon(x)"))

    # Create a first-order logic knowledge base (KB) with clauses
    KB = aima.logic.FolKB(clauses)

    # Add rules and facts with tell
    KB.tell(aima.utils.expr('Enemy(Coco, America)'))
    KB.tell(aima.utils.expr('Enemy(Jojo, America)'))
    KB.tell(aima.utils.expr("Enemy(x, America) ==> Hostile(x)"))

    # Get information from the knowledge base with ask
    hostile = KB.ask(aima.utils.expr('Hostile(x)'))
    criminal = KB.ask(aima.utils.expr('Criminal(x)'))

    # Print answers
    print('Hostile?')
    print(hostile)
    print('\nCriminal?')
    print(criminal)
    print()

# Tell python to run main method
if __name__ == "__main__": main()

Hostile?
{v_5: Nono, x: Nono}

Criminal?
{v_9: West, x: West, v_20: M1, v_10: M1, v_27: M1, v_11: Nono, v_39: Nono}

Framåtkedjning

En algoritm för framåtkedjning tittar på varje enskild regel i kunskapsbasen, detta för att se om målet kan uppfyllas. Denna algoritm använder sammanslagning för att bilda nya meningar, nya meningar läggs till i kunskapsbasen och denna process upprepas tills dess att frågan kan besvaras eller tills inga fler meningar kan läggas till. En fråga kan ha flera svar med framåtkedjning.

# Import libraries
import aima.utils
import aima.logic

# The main entry point for this module
def main():

    # Create an array to hold clauses
    clauses = []

    # Add first-order logic clauses (rules and fact)
    clauses.append(aima.utils.expr("(American(x) & Weapon(y) & Sells(x, y, z) & Hostile(z)) ==> Criminal(x)"))
    clauses.append(aima.utils.expr("Enemy(Nono, America)"))
    clauses.append(aima.utils.expr("Owns(Nono, M1)"))
    clauses.append(aima.utils.expr("Missile(M1)"))
    clauses.append(aima.utils.expr("(Missile(x) & Owns(Nono, x)) ==> Sells(West, x, Nono)"))
    clauses.append(aima.utils.expr("American(West)"))
    clauses.append(aima.utils.expr("Missile(x) ==> Weapon(x)"))

    # Create a first-order logic knowledge base (KB) with clauses
    KB = aima.logic.FolKB(clauses)

    # Add rules and facts with tell
    KB.tell(aima.utils.expr('Enemy(Coco, America)'))
    KB.tell(aima.utils.expr('Enemy(Jojo, America)'))
    KB.tell(aima.utils.expr("Enemy(x, America) ==> Hostile(x)"))

    # Get information from the knowledge base with ask
    hostile = aima.logic.fol_fc_ask(KB, aima.utils.expr('Hostile(x)'))
    criminal = aima.logic.fol_fc_ask(KB, aima.utils.expr('Criminal(x)'))

    # Print answers
    print('Hostile?')
    print(list(hostile))
    print('\nCriminal?')
    print(list(criminal))
    print()

# Tell python to run main method
if __name__ == "__main__": main()

Hostile?
[{x: Coco}, {x: Nono}, {x: Jojo}]

Criminal?
[{x: West}]