Informally, this rule could be written as: hasParent(?x1,?x2) and hasBrother(?x2,?x3) => hasUncle(?x1,?x3) Comparing RuleML and PrologĪ simple use of these rules would be to assert that the combination of the hasParent and hasBrother properties implies the hasUncle property. Let’s see AHO to compare it into the atom of Symbolic Analysis. | differentFrom '(' i-object i-object ')' | datavaluedPropertyID '(' i-object d-object ')' | individualvaluedPropertyID '(' i-object i-object ')' OWL’s atom is like this: atom ::= description '(' i-object ')' This principles leads to an atomistic approach, similar to Symbolic Analysis. As mentioned above, rules with conjunctive consequents could easily transformed into multiple rules each with an atomic consequent. Non-empty antecedents and consequents hold iff all of their constituent atoms hold, i.e., they are treated as conjunctions of their atoms. Rules with an empty antecedent can thus be used to provide unconditional facts however such unconditional facts are better stated in OWL itself, i.e., without the use of the rule construct. An empty antecedent is treated as trivially holding (true), and an empty consequent is treated as trivially not holding (false). Informally, a rule may be read as meaning that if the antecedent holds (is “true”), then the consequent must also hold. A rule axiom can also be assigned a URI reference, which could serve to identify the rule. axiom ::= ruleĪ rule axiom consists of an antecedent (body) and a consequent (head), each of which consists of a (posibly empty) set of atoms. It is proposed to extend this with rule axioms. Axioms may be of various kinds, e.g., subClass axioms and equivalentClass axioms. SWRL is a Semantic Web Rule Language, which combines OWL and RuleMLĪn OWL ontology in the abstract syntax contains a sequence of axioms and facts. non-object-based programs into atomistic ones, when the semantics is formal. This application shows that it is possible to translate “procedural”, i.e. To convert a procedural Prolog-derivation model into an atomistic one, there is only one definition needed to add into the original code:ĭ (ref ( SE ), X ) = SE:d ( X ). * this is a reference to a symbolic element, AHO */ Interface for the Symbol: interface symbol Model Weaver to create the atomistic model: differentiateExpression(Str) = OutputExpression:- S = s::new(), BuiltModel = sEModelBuilder::build(S:parse(Str)), ResultExpression = BuiltModel:d("x"), ResultElement = seData::new(ResultExpression), OutputExpression = ResultElement:reduce(). Let’s Symbol be the definition for the whole model semantics, here derivation. Let’s assume SE to be the base class for all atomistic objects. The Atomistic Correspondence for the Procedural Definition ResultStr = diff::writeexp(OutputExpression). OutputExpression = diff::reduce(DifferentiatedExpression), Starting derivation differentiate(STR) = ResultStr:-ĭifferentiatedExpression = diff::d(InputExpression,"x"), Procedural approach to Prolog, Derivation d(X,X,1) :- !. This example demonstrates the expressive power and ease-of-use of symbolic manipulation in Prolog (more examples here: ). symbolic analysis from the mathematical approach. Derivation is a popular example about symbolic computation, i.e.
0 kommentar(er)
