Введение
Парадигма программирования, основанная на формальной логике
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Логическое программирование — это парадигма программирования, баз данных и представления знаний, основанная на формальной логике. Логическая программа — это набор предложений в логической форме, представляющий знания о некоторой проблемной области. Вычисления выполняются путем применения логических рассуждений к этим знаниям для решения проблем в области. К основным семействам языков логического программирования относятся Prolog, Answer Set Programming (ASP) и Datalog. Во всех этих языках правила записываются в виде предложения:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
A : B1, …, Bn. и читаются как декларативные предложения в логической форме:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
A если B1 и … и Bn. A называется головой правила, B1, …, Bn называется телом, а Bi называются литералами или условиями. Когда n = 0, правило называется фактом и записывается в упрощенной форме:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
A.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Запросы (или цели) имеют тот же синтаксис, что и тела правил, и обычно записываются в форме:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? B1, …, Bn. В простейшем случае клауз Хорна (или "определенных" клауз), все A, B1, …, Bn являются атомными формулами вида p(t1, …, tm), где p — предикатный символ, обозначающий отношение, например, "материнство", а ti — термы, обозначающие объекты (или индивидуумы). Термы включают как константные символы, такие как "charles", так и переменные, такие как X, которые начинаются с заглавной буквы. Рассмотрим, например, следующую программу клауз Хорна:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
mother(child(elizabeth, charles)).
father(child(charles, william)).
father(child(charles, harry)).
parent(child(X, Y)) : mother(child(X, Y)).
parent(child(X, Y)) : father(child(X, Y)).
grandparent(child(X, Y)) : parent(child(X, Z)), parent(child(Z, Y)).
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
При заданном запросе программа выдает ответы. Например, для запроса ? parent(child(X, william)), единственный ответ:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
X = charles.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Можно задавать различные запросы. Например, программа может быть запрошена как для генерации бабушек и дедушек, так и для генерации внуков. Ее можно использовать даже для генерации всех пар бабушек и дедушек и внуков, или просто для проверки, является ли данная пара такой парой:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? grandparent(child(X, william)).
X = elizabeth.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? grandparent(child(elizabeth, Y)).
Y = william;
Y = harry.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? grandparent(child(X, Y)).
X = elizabeth,
Y = william;
X = elizabeth,
Y = harry.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? grandparent(child(william, harry)).
no.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
? grandparent(child(elizabeth, harry)).
yes.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Хотя логические программы клауз Хорна являются Тьюринг-полными, для большинства практических приложений программы клауз Хорна необходимо расширить до "нормальных" логических программ с отрицательными условиями. Например, определение брата/сестры использует отрицательное условие, где предикат = определяется клаузой X = X:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
sibling(X, Y) : parent(child(Z, X)), parent(child(Z, Y)), not(X = Y).
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Логические языки программирования, которые включают отрицательные условия, обладают возможностями представления знаний немонотонной логики. В ASP и Datalog логические программы имеют только декларативное прочтение, и их выполнение осуществляется посредством процедуры доказательства или генератора моделей, поведение которых не предназначено контролироваться программистом. Однако в семействе языков Prolog логические программы также имеют процедурную интерпретацию как процедуры редукции цели. С этой точки зрения, клауза A : B1, …, Bn понимается как:
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
чтобы решить A, решить B1, и … и решить Bn.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Отрицательные условия в телах клауз также имеют процедурную интерпретацию, известную как отрицание как отказ: отрицательный литерал not B считается истинным, если и только если положительный литерал B не удается доказать. Большая часть исследований в области логического программирования была посвящена попыткам разработать логическую семантику для отрицания как отказа и разработке другой семантики и других реализаций для отрицания. Эти разработки, в свою очередь, были важны для поддержки разработки формальных методов логической верификации программ и трансформации программ.
Programming paradigm based on formal logic
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A : B1, , Bn. and are read as declarative sentences in logical form:
A if B1 and and Bn. A is called the head of the rule, B1, , Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
? B1, , Bn. In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, , Bn are atomic formulae of the form p(t1 , , tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter. Consider, for example, the following Horn clause program:
mother child(elizabeth, charles). father child(charles, william). father child(charles, harry). parent child(X, Y) :
mother child(X, Y). parent child(X, Y) :
father child(X, Y). grandparent child(X, Y) :
parent child(X, Z),
parent child(Z, Y). Given a query, the program produces answers. For instance for a query ? parent child(X, william), the single answer is
X = charles
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
grandparent child(X, william). X = elizabeth
? grandparent child(elizabeth, Y). Y = william;
Y = harry. ? grandparent child(X, Y). X = elizabeth
Y = william;
X = elizabeth
Y = harry. ? grandparent child(william, harry). no
? grandparent child(elizabeth, harry). yes
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X:
sibling(X, Y) :
parent child(Z, X),
parent child(Z, Y),
not(X = Y). Logic programming languages that include negative conditions have the knowledge representation capabilities of a non monotonic logic. In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal reduction procedures. From this point of view, clause A : B1, ,Bn is understood as:
to solve A, solve B1, and and solve Bn. Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold. Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic based program verification and program transformation.
История
Использование математической логики для представления и выполнения компьютерных программ также является особенностью лямбда-исчисления, разработанного Алонзо Черчем в 1930-х годах. Однако первое предложение использовать клаузальную форму логики для представления компьютерных программ было сделано Корделлом Грином. Это использовало аксиоматизацию подмножества LISP вместе с представлением отношения ввода-вывода для вычисления этого отношения путем моделирования выполнения программы в LISP. Absys, разработанный Фостером и Элкоком, с другой стороны, использовал комбинацию уравнений и лямбда-исчисления в ассерциональном языке программирования, который не накладывает ограничений на порядок выполнения операций. Логическое программирование, с его современным синтаксисом фактов и правил, восходит к дебатам конца 1960-х и начала 1970-х годов о декларативных и процедурных представлениях знаний в искусственном интеллекте. Сторонники декларативных представлений работали в Стэнфорде, в сотрудничестве с Джоном Маккарти, Бертрамом Рафаэлем и Корделлом Грином, а также в Эдинбурге с Джоном Аланом Робинсоном (приглашенным профессором из Сиракузского университета), Пэтом Хейсом и Робертом Ковальски. Сторонники процедурных представлений были сосредоточены главным образом в MIT под руководством Марвина Мински и Сеймура Паперта. Хотя Planner, разработанный Карлом Хьюитом в MIT, и основывался на методах доказательства логики, он стал первым языком, появившимся в рамках этой процедурной парадигмы. Planner включал в себя направленный образцом вызов процедурных планов из целей (т.е. сокращение цели или обратное распространение) и из утверждений (т.е. прямое распространение). Наиболее влиятельной реализацией Planner была его подмножество, Micro Planner, реализованное Джерри Суссманом, Юджином Чарняком и Терри Виноградом. Виноград использовал Micro Planner для реализации знаковой программы понимания естественного языка SHRDLU. Для повышения эффективности Planner использовал структуру управления с возвратом, чтобы одновременно хранить только один возможный путь вычислений. Planner послужил основой для языков программирования QA4, Popler, Conniver, QLISP и языка параллельного программирования Ether. Хейс и Ковальски в Эдинбурге попытались согласовать декларативный подход к представлению знаний, основанный на логике, с процедурным подходом Planner. Хейс (1973) разработал уравнительный язык Golux, в котором различные процедуры можно было получить, изменяя поведение решателя теорем. В то же время Ален Колмерауэр в Марселе работал над пониманием естественного языка, используя логику для представления семантики и разрешение для ответов на вопросы. Летом 1971 года Колмерауэр пригласил Ковальски в Марсель, и вместе они обнаружили, что клаузальная форма логики может быть использована для представления формальных грамматик и что решатели теорем на основе разрешения могут быть использованы для синтаксического анализа. Они заметили, что некоторые решатели теорем, такие как гиперразрешение, ведут себя как восходящие парсеры, а другие, такие как SL-разрешение (1971), ведут себя как нисходящие парсеры. Летом 1972 года Ковальски, снова работая с Колмерауэром, разработал процедурную интерпретацию импликаций в клаузальной форме. Также стало ясно, что такие клаузы могут быть ограничены определенными клаузами или клаузами Хорна, и что SL-разрешение может быть ограничено (и обобщено) до SLD-разрешения. Процедурная интерпретация Ковальского и SLD были описаны в меморандуме 1973 года, опубликованном в 1974 году. Колмерауэр вместе с Филиппом Русселем использовали процедурную интерпретацию в качестве основы для Prolog, который был реализован летом и осенью 1972 года. Первая программа на Prolog, также написанная в 1972 году и реализованная в Марселе, была французской системой ответов на вопросы. Использование Prolog в качестве практического языка программирования получило значительный импульс благодаря разработке компилятора Дэвидом Уорреном в Эдинбурге в 1977 году. Эксперименты показали, что Edinburgh Prolog может конкурировать по скорости обработки с другими символическими языками программирования, такими как Lisp. Edinburgh Prolog стал де-факто стандартом и оказал сильное влияние на определение стандарта ISO Prolog. Логическое программирование получило международное признание в 1980-х годах, когда японское Министерство международной торговли и промышленности выбрало его для разработки программного обеспечения для проекта "Компьютерные системы пятого поколения" (FGCS). Проект FGCS был направлен на использование логического программирования для разработки передовых приложений искусственного интеллекта на массивно-параллельных компьютерах. Хотя проект первоначально исследовал использование Prolog, позже он перешел на использование параллельного логического программирования, поскольку оно было ближе к компьютерной архитектуре FGCS. Однако функция "зафиксированного выбора" в параллельном логическом программировании противоречила логической семантике языка и его пригодности для представления знаний и решения задач. Кроме того, параллельные компьютерные системы, разработанные в рамках проекта, не смогли конкурировать с достижениями в разработке более традиционных компьютеров общего назначения. В совокупности эти два фактора привели к тому, что проект FGCS не достиг своих целей. Интерес как к логическому программированию, так и к искусственному интеллекту во всем мире пришел в упадок. В то же время более декларативные подходы к логическому программированию, включая те, которые основаны на использовании Prolog, продолжали развиваться независимо от проекта FGCS. В частности, хотя Prolog был разработан для объединения декларативных и процедурных представлений знаний, чисто декларативная интерпретация логических программ стала центральной для приложений в области дедуктивных баз данных. Работа в этой области стала заметной примерно в 1977 году, когда Эрве Галлаэр и Джек Минкер организовали семинар по логике и базам данных в Тулузе. Эта область в конечном итоге была переименована в Datalog. Этот акцент на логическом, декларативном прочтении логических программ получил дополнительный импульс благодаря развитию логического программирования с ограничениями в 1980-х годах и программирования с ответами на множества в 1990-х годах. Он также получает новое подтверждение в современных приложениях Prolog.
The use of mathematical logic to represent and execute computer programs is also a feature of the lambda calculus, developed by Alonzo Church in the 1930s. However, the first proposal to use the clausal form of logic for representing computer programs was made by Cordell Green. This used an axiomatization of a subset of LISP, together with a representation of an input output relation, to compute the relation by simulating the execution of the program in LISP. Foster and Elcock's Absys, on the other hand, employed a combination of equations and lambda calculus in an assertional programming language that places no constraints on the order in which operations are performed. Logic programming, with its current syntax of facts and rules, can be traced back to debates in the late 1960s and early 1970s about declarative versus procedural representations of knowledge in artificial intelligence. Advocates of declarative representations were notably working at Stanford, associated with John McCarthy, Bertram Raphael and Cordell Green, and in Edinburgh, with John Alan Robinson (an academic visitor from Syracuse University), Pat Hayes, and Robert Kowalski. Advocates of procedural representations were mainly centered at MIT, under the leadership of Marvin Minsky and Seymour Papert. Although it was based on the proof methods of logic, Planner, developed by Carl Hewitt at MIT, was the first language to emerge within this proceduralist paradigm. Planner featured pattern directed invocation of procedural plans from goals (i. e. goal reduction or backward chaining) and from assertions (i. e. forward chaining). The most influential implementation of Planner was the subset of Planner, called Micro Planner, implemented by Gerry Sussman, Eugene Charniak and Terry Winograd. Winograd used Micro Planner to implement the landmark, natural language understanding program SHRDLU. For the sake of efficiency, Planner used a backtracking control structure so that only one possible computation path had to be stored at a time. Planner gave rise to the programming languages QA4, Popler, Conniver, QLISP, and the concurrent language Ether. Hayes and Kowalski in Edinburgh tried to reconcile the logic based declarative approach to knowledge representation with Planner's procedural approach. Hayes (1973) developed an equational language, Golux, in which different procedures could be obtained by altering the behavior of the theorem prover. In the meanwhile, Alain Colmerauer in Marseille was working on natural language understanding, using logic to represent semantics and using resolution for question answering. During the summer of 1971, Colmerauer invited Kowalski to Marseille, and together they discovered that the clausal form of logic could be used to represent formal grammars and that resolution theorem provers could be used for parsing. They observed that some theorem provers, like hyper resolution, behave as bottom up parsers and others, like SL resolution (1971) behave as top down parsers. It was in the following summer of 1972, that Kowalski, again working with Colmerauer, developed the procedural interpretation of implications in clausal form. It also became clear that such clauses could be restricted to definite clauses or Horn clauses, and that SL resolution could be restricted (and generalised) to SLD resolution. Kowalski's procedural interpretation and SLD were described in a 1973 memo, published in 1974. Colmerauer, with Philippe Roussel, used the procedural interpretation as the basis of Prolog, which was implemented in the summer and autumn of 1972. The first Prolog program, also written in 1972 and implemented in Marseille, was a French question answering system. The use of Prolog as a practical programming language was given great momentum by the development of a compiler by David H. D. Warren in Edinburgh in 1977. Experiments demonstrated that Edinburgh Prolog could compete with the processing speed of other symbolic programming languages such as Lisp. Edinburgh Prolog became the de facto standard and strongly influenced the definition of ISO standard Prolog. Logic programming gained international attention during the 1980s, when it was chosen by the Japanese Ministry of International Trade and Industry to develop the software for the Fifth Generation Computer Systems (FGCS) project. The FGCS project aimed to use logic programming to develop advanced Artificial Intelligence applications on massively parallel computers. Although the project initially explored the use of Prolog, it later adopted the use of concurrent logic programming, because it was closer to the FGCS computer architecture. However, the committed choice feature of concurrent logic programming interfered with the language's logical semantics and with its suitability for knowledge representation and problem solving applications. Moreover, the parallel computer systems developed in the project failed to compete with advances taking place in the development of more conventional, general purpose computers. Together these two issues resulted in the FGCS project failing to meet its objectives. Interest in both logic programming and AI fell into world wide decline. In the meanwhile, more declarative logic programming approaches, including those based on the use of Prolog, continued to make progress independently of the FGCS project. In particular, although Prolog was developed to combine declarative and procedural representations of knowledge, the purely declarative interpretation of logic programs became the focus for applications in the field of deductive databases. Work in this field became prominent around 1977, when Hervé Gallaire and Jack Minker organized a workshop on logic and databases in Toulouse. The field was eventually renamed as Datalog. This focus on the logical, declarative reading of logic programs was given further impetus by the development of constraint logic programming in the 1980s and Answer Set Programming in the 1990s. It is also receiving renewed emphasis in recent applications of Prolog
Ассоциация логического программирования (ALP) была основана в 1986 году для продвижения логического программирования. Ее официальным журналом до 2000 года был The Journal of Logic Programming. Ее главным редактором-основателем был Дж. Алан Робинсон. В 2001 году журнал был переименован в The Journal of Logic and Algebraic Programming, а официальным журналом ALP стал Theory and Practice of Logic Programming, издаваемый Cambridge University Press.
The Association for Logic Programming (ALP) was founded in 1986 to promote Logic Programming. Its official journal until 2000, was The Journal of Logic Programming. Its founding editor in chief was J. Alan Robinson. In 2001, the journal was renamed The Journal of Logic and Algebraic Programming, and the official journal of ALP became Theory and Practice of Logic Programming, published by Cambridge University Press.
Понятия
Логические программы характеризуются богатым разнообразием семантик и методов решения задач, а также широким спектром применения в программировании, базах данных, представлении знаний и решении проблем.
Logic programs enjoy a rich variety of semantics and problem solving methods, as well as a wide range of applications in programming, databases, knowledge representation and problem solving.
Программирование логики с одновременными ограничениями
Конкурентное логическое программирование с ограничениями объединяет конкурентное логическое программирование и логическое программирование с ограничениями, используя ограничения для управления конкуренцией. Клауза может содержать охранное условие – набор ограничений, которые могут блокировать применимость этой клаузы. Когда охранные условия нескольких клауз выполнены, конкурентное логическое программирование с ограничениями делает однозначный выбор в пользу использования только одной из них.
Concurrent constraint logic programming combines concurrent logic programming and constraint logic programming, using constraints to control concurrency. A clause can contain a guard, which is a set of constraints that may block the applicability of the clause. When the guards of several clauses are satisfied, concurrent constraint logic programming makes a committed choice to use only one.
Логическое программирование высшего порядка
Несколько исследователей расширили логическое программирование возможностями программирования высшего порядка, заимствованными из логики высшего порядка, такими как переменные предикатов. К таким языкам относятся расширения Prolog HiLog и λProlog.
Several researchers have extended logic programming with higher order programming features derived from higher order logic, such as predicate variables. Such languages include the Prolog extensions HiLog and λProlog.
Линейное логическое программирование
Основание логического программирования на линейной логике привело к созданию логических языков программирования, которые значительно более выразительны, чем языки, основанные на классической логике. Программы, построенные на клаузах Хорна, могут представлять изменение состояния только посредством изменения аргументов предикатов. В логическом программировании с использованием линейной логики можно использовать окружающую линейную логику для поддержки представления изменения состояния. К ранним разработкам логических языков программирования, основанных на линейной логике, относятся LO, Lolli, ACL и Forum. Forum предоставляет целеориентированную интерпретацию всей линейной логики.
Basing logic programming within linear logic has resulted in the design of logic programming languages that are considerably more expressive than those based on classical logic. Horn clause programs can only represent state change by the change in arguments to predicates. In linear logic programming, one can use the ambient linear logic to support state change. Some early designs of logic programming languages based on linear logic include LO, Lolli, ACL, and Forum. Forum provides a goal directed interpretation of all linear logic.
Объектно-ориентированное логическое программирование
F-логика расширяет логическое программирование за счет объектов и синтаксиса фреймов. Logtalk расширяет язык программирования Prolog поддержкой объектов, протоколов и других концепций ООП. Он поддерживает большинство стандартно-совместимых систем Prolog в качестве бэкэнд-компиляторов.
F logic extends logic programming with objects and the frame syntax. Logtalk extends the Prolog programming language with support for objects, protocols, and other OOP concepts. It supports most standard compliant Prolog systems as backend compilers.
Программирование транзакционной логики
Логическая система обработки транзакций. Другие прототипы также имеются в наличии.
Transaction logic system. Other prototypes are also available.
Другие источники
Джон Маккарти. "Программы с здравым смыслом". Симпозиум по механизации мыслительных процессов. Национальная физическая лаборатория. Теддингтон, Англия. 1958. Эхуд Шапиро (редактор). Concurrent Prolog. Издательство MIT. 1987. Джеймс Слэгл. "Эксперименты с дедуктивной программой для ответов на вопросы". CACM. Декабрь 1965. Габбай, Дов М.; Хоггер, Кристофер Джон; Робинсон, Дж. А., редакторы (1993–1998). Handbook of Logic in Artificial Intelligence and Logic Programming. Тома 1–5, Oxford University Press.
John McCarthy. "Programs with common sense". Symposium on Mechanization of Thought Processes. National Physical Laboratory. Teddington, England. 1958. Ehud Shapiro (Editor). Concurrent Prolog. MIT Press. 1987. James Slagle. "Experiments with a Deductive Question Answering Program". CACM. December 1965. Gabbay, Dov M.; Hogger, Christopher John; Robinson, J. A., eds. (1993 1998). Handbook of Logic in Artificial Intelligence and Logic Programming. Vols. 1–5, Oxford University Press.