Кіріспе
Формалды логикаға негізделген бағдарламалау парадигмасы
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 if B1 and … and 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 – нысандарды (немесе жеке тұлғаларды) атаушы термдер. Термдер «чарльз» сияқты тұрақтылар мен 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.
Клаузалардың денелеріндегі теріс шарттардың да процессуалдық түсіндірмесі бар, ол сәтсіздік ретінде теріске шығару деп аталады: 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-де Марвин Мински мен Сеймур Паперттің басшылығымен болды. Логиканың дәлелдеу әдістеріне негізделгенімен, Карл Хьюитт MIT-де дамытқан Планер осы процедуралық парадигма аясында пайда болған алғашқы тіл болды. Планер мақсаттардан (яғни мақсатты азайту немесе кері тізбектеу) және ассерциялардан (яғни алға тізбектеу) процедуралық жоспарларды үлгілік түрде шақыруды ұсынды. Планердің ең ықпалды іске асырылуы Джерри Суссман, Юджин Чарняк және Терри Виноград іске асырған Планердің микропланер деп аталатын кіші жиынтығы болды. Виноград SHRDLU табиғи тілді түсіну бағдарламасын іске асыру үшін Микропланерді пайдаланды. Тиімділік үшін Планер бір уақытта тек бір ғана ықтимал есептеу жолын сақтау үшін кері бақылау құрылымын қолданды. Планер QA4, Popler, Conniver, QLISP және бір мезгілде қолданылатын Ether бағдарламалау тілдерін тудырды. Эдинбургтегі Хейс пен Ковальски білімді бейнелеуге логикаға негізделген декларативтік тәсілді Планердің процедуралық тәсілімен үйлестіруге тырысты. Хейз (1973) теореманы дәлелдеушінің мінез-құлқын өзгерту арқылы әр түрлі процедураларды алуға болатын Golux теңдеу тілін жасады. Осы уақытта Ален Колмерауэр Марсельде табиғи тілді түсінуді, семантиканы бейнелеу үшін логиканы және сұрақ-жауап үшін шешімді қолдануды зерттеді. 1971 жылдың жазында Колмерауэр Ковальскиді Марсельге шақырды, олар логиканың клаузалық түрін ресми грамматиканы бейнелеу үшін және шешім теоремаларын дәлелдеушілерді талдау үшін пайдалануға болатынын анықтады. Олар кейбір теорема дәлелдеушілердің, мысалы гиперрезолюция, төменнен жоғары қарай талдаушы ретінде, ал SL resolution (1971) сияқты басқалары жоғарыдан төмен қарай талдаушы ретінде әрекет ететінін байқады. 1972 жылдың келесі жазында Ковальски, тағы да Колмерауэрмен жұмыс істеп, клаузалық түріндегі импликациялардың процедуралық интерпретациясын жасады. Сондай-ақ, мұндай клаузалар нақты клаузаларға немесе Хорн клаузаларына ғана шектелуі мүмкін екендігі және SL шешімі SLD шешіміне ғана (және жалпыланған) шектелуі мүмкін екендігі анық болды. Ковальскидің процедуралық интерпретациясы мен SLD 1974 жылы жарияланған 1973 жылғы меморандумда сипатталған. Колмерауэр Филипп Руссельмен бірге 1972 жылдың жазы мен күзінде іске асырылған Prolog негізін процедуралық интерпретация ретінде пайдаланды. Бірінші Prolog бағдарламасы, сондай-ақ 1972 жылы жазылған және Марсельде іске асырылған, француз сұрақ-жауап жүйесі болды. Prolog-ты практикалық бағдарламалау тілі ретінде қолдану 1977 жылы Эдинбургте Дэвид Х. Д. Уорреннің компиляторын жасауынан үлкен серпін алды. Тәжірибелер Эдинбург Prolog-тың Lisp сияқты басқа символикалық бағдарламалау тілдерінің өңдеу жылдамдығымен бәсекелесе алатынын көрсетті. Эдинбург 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
Логикалық бағдарламалауды ілгерілету үшін 1986 жылы Логикалық бағдарламалау қауымдастығы (ALP) құрылды. Оның 2000 жылға дейінгі ресми журналы Логикалық бағдарламалау журналы болды. Оның алғашқы бас редакторы Дж. Алан Робинсон болды. 2001 жылы журнал Логика және алгебралық бағдарламалау журналы деп аталды, ал ALP-ның ресми журналы Кембридж университетінің баспасынан шығатын Логикалық бағдарламалау теориясы және практикасы болды.
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.
Сызықтық логикалық бағдарламалау
Логикалық бағдарламалауды сызықтық логикаға негіздеу, классикалық логикаға негізделгенге қарағанда әлдеқайда кең мүмкіндіктерге ие логикалық бағдарламалау тілдерін жасауға әкелді. Horn clause бағдарламалары күйдің өзгеруін тек предикаттардың аргументтерінің өзгеруі арқылы ғана бейнелей алады. Сызықтық логикалық бағдарламалауда, күйді өзгертуді қолдау үшін қоршаған сызықтық логиканы пайдалануға болады. Сызықтық логикаға негізделген логикалық бағдарламалау тілдерінің алғашқы үлгілеріне 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 бағдарламалау тілін нысандар, протоколдар және басқа да объектіге бағытталған бағдарламалау (ООP) ұғымдарын қолдау арқылы кеңейтеді. Ол 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 жыл. Эхуд Шапиро (редактор). Параллель Prolog. MIT Press. 1987 жыл. Джеймс Слэгл. "Дедуктивті сұрақ-жауап бағдарламасымен тәжірибелер". CACM. 1965 жылдың желтоқсаны. Габбай, Дов М.; Хоггер, Кристофер Джон; Робинсон, Дж. А., ред. (1993–1998). Жасанды интеллект және логикалық бағдарламалау логикасының нұсқаулығы. 1–5 томдар, Оксфорд университетінің баспасы.
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.