Work at SourceForge, help us to make it a better place! We have an immediate need for a Support Technician in our San Francisco or Denver office.

Close

[05a128]: doc / source / krb_syntax / bc_rule.txt Maximize Restore History

Download this file

bc_rule.txt    214 lines (167 with data), 7.5 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
.. $Id$
..
.. Copyright Š 2007 Bruce Frederiksen
..
.. Permission is hereby granted, free of charge, to any person obtaining a copy
.. of this software and associated documentation files (the "Software"), to deal
.. in the Software without restriction, including without limitation the rights
.. to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
.. copies of the Software, and to permit persons to whom the Software is
.. furnished to do so, subject to the following conditions:
..
.. The above copyright notice and this permission notice shall be included in
.. all copies or substantial portions of the Software.
..
.. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
.. IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
.. FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
.. AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
.. LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
.. OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
.. THE SOFTWARE.
restindex
crumb: Bc_rule
page-description:
The syntax of a backward-chaining rule.
/description
format: rest
encoding: utf8
output-encoding: utf8
include: yes
initialheaderlevel: 1
/restindex
=============================================
Bc_rule Syntax
=============================================
Bc_rule
==========
Backward-chaining_ rules_ have four parts:
#. A unique name.
#. A ``use`` clause.
#. An optional ``when`` clause.
#. An optional ``with`` clause.
::
bc_rule ::= IDENTIFIER ':' NL INDENT
use
[when]
[with]
DEINDENT
The ``IDENTIFIER`` is the unique name for this rule_ and is used as the
corresponding python function name in the generated <rb_name>_bc.py file.
Use Clause
============
The ``use`` clause is the **then** part of the rule_. It identifies the
*goal* that this rule_ is trying to prove.
use ::= 'use' IDENTIFIER '(' {pattern,} ')'
['taking' '(' <python_arg_spec> ')'] NL
Notice that it uses a single ``IDENTIFIER``. The `rule base`_ name is implied
as the `rule base category`_ name for the `rule base`_ containing this rule_.
Taking Clause
----------------
The ``use`` clause also defines parameters to the plan_ function (if one is
used for this rule_) with the optional ``taking`` sub-clause.
The *python_arg_spec* is not parsed by pyke, but simply copied to the
output plan_ function. Do **not** use ``$`` with these parameters.
When Clause
==============
The ``when`` clause is the **if** part of the rule_. It defines the
premises that must be true for this rule to succeed.
If the ``when`` clause is omitted, the only
requirement for the rule_ to succeed is that the ``use`` clause
patterns_ match the goal.
If the ``when`` clause is used, the rule_ succeeds for each
combination of true premises.
::
when ::= 'when' NL INDENT
{bc_premise NL}
DEINDENT
bc_premise ::= ['!'] goal_name '(' {pattern,} ')' plan_spec
| python_premise
goal_name ::= name '.' name
| name
name ::= IDENTIFIER
| '$'IDENTIFIER
Here are the links to the definitions for pattern_ and python_premise_.
If the *bc_premise* includes the ``!``, an exception will be raised if the
premise fails. This can help in debugging. Note that this does not apply
when backtracking_.
If a single *name* is used in the *bc_premise*,
the `rule base category`_ for the current `rule base`_ is assumed.
If two *names* are used in the *bc_premise*, the first may name a `rule
base category`_ or a `fact base`_.
If a `rule base category`_ name is used (or assumed),
the currently active_ `rule base`_ for that category_ is used to prove the
premise. Note that if the `rule base category`_ name is omitted, and
therefore assumed to be the current `rule base's`_ `rule base category`_,
the current `rule base`_ may not be the active_ `rule base`_ for that
category_. It could be the case, that a derived `rule base`_ is the
active_ `rule base`_. In that case, the derived `rule base`_ is used to
prove the premise.
Plan_spec
------------
A *plan_spec* is required for all premises that return plans_.
This shows what to do with the returned plan_ function::
plan_spec ::= step_opt NL
| step_opt NL INDENT
{<python_statement> NL}
DEINDENT
| 'as' '$'IDENTIFIER NL
step_opt ::=
| 'step' NUMBER
The plan_ function itself is indicated by ``$$`` in the *python_statement*.
The result of this function
may be assigned to a python variable, but not a `pattern variable`_
(``$variable``).
Parameters from the ``taking`` clause may be passed to the plan_ function.
With multiple premises, the *plan_specs* without ``step`` clauses are
executed first in the order that they appear. Then the *plan_specs*
with ``step`` clauses are executed in ascending sequence by the NUMBER in
the ``step`` clause. It is permissible for the NUMBER to be negative or a
float.
If the ``as`` clause is used, the plan_ function is bound to the
`pattern variable`_ as a python function. This allows you to call the
function (or not) as you please. The parameters required are defined in
the ``taking`` clause of the rule_ used to prove the premise.
With Clause
==============
The ``with`` clause contains python
statements for the plan_ produced by this rule_. These python statements may
include `pattern variables`_ whose values will be substituted into the
statements when finalizing the final plan_.
::
with ::= 'with' NL INDENT
{<python_statement> NL}
DEINDENT
These *python_statements* are included in the plan_ function after the
calls to all of the subordinate plan_ functions from all of the *plan_specs*
in the ``when`` clause.
If the ``with`` clause is omitted, but the ``when`` clause has *plan_specs*
(excluding ``as`` specs), a plan_ function is still generated for this
rule_ so that the subordinate plan_ functions may still be called.
The *python_statements* are not parsed. They are simply scanned for ``$``
`pattern variables`_ that don't occur in string literals or comments.
The resulting plan_ will substitute the values bound to these variables_
into the code.
But note that this substitution isn't done until after the entire
top-level goal has been proven. So it is permissible to use
unbound `pattern variables`_, so long as they will be bound to values by
subsequent rules_.
.. _active: ../using_pyke.html#setting-up-each-case
.. _backward-chaining: ../overview/rules/backward_chaining.html
.. _backtracking: ../overview/rules/backward_chaining.html#backtracking
.. _category: `rule base category`_
.. _fact base: ../overview/knowledge_bases/fact_bases.html
.. _pattern: pattern.html
.. _patterns: pattern_
.. _pattern variable: pattern.html#pattern-variable
.. _pattern variables: `pattern variable`_
.. _plan: ../overview/plans.html
.. _plans: plan_
.. _python_premise: python_premise.html
.. _rule: ../overview/rules/index.html
.. _rules: rule_
.. _rule base: ../overview/knowledge_bases/rule_bases.html
.. _rule base's: `rule base`_
.. _rule base category:
../overview/knowledge_bases/rule_bases.html#rule-base-categories
.. _variables: `pattern variable`_