CN1659589A - 用于提供推理服务的系统和方法 - Google Patents

Abstract

一种用于提供推理服务的方法，包括接收指定域的多条规则。该方法还包括识别与这些规则相关联的前置条件和与这些规则相关联的后置条件。前置条件表示用于执行规则的输入，而后置条件表示来自规则执行的输出。该方法还包括接收对应于前置条件的输入值。另外，该方法包括使用输入值执行这些规则的至少一部分，以产生输出值。输出值对应于后置条件。

Description

用于提供推理服务的系统和方法

技术领域

本发明一般涉及专家系统领域，特别涉及一种用于提供推理服务的系统和方法。

背景技术

专家系统经常用来解决特定领域如医疗或法律领域内的问题。例如，专家系统可以接收识别病人症状的信息，分析症状，并且为病人识别可能的诊断。典型的专家系统包括体现专家系统所用逻辑的规则库或者一组规则。典型的专家系统还包括推理引擎。推理引擎典型地执行这些规则以分析一组输入，如病人所患症状。当执行这些规则时，推理引擎典型地试图赋值给一组输出值。输出值表示推理引擎的结论。

发明内容

本发明提供了一种用于提供推理服务的系统和方法。具体地说，推理引擎可结合灵活的接口，如应用程序接口(API)来使用。用户或应用程序可调用推理引擎来使用所标识的规则库，并且执行推理操作。规则库可使用可扩展标记语言(XML)来定义。然后，推理引擎可在所标识的规则库中执行指定域的规则，并且将推理结果返回给调用用户或应用程序。

在一个实施例中，一种用于提供推理服务的方法包括接收指定域的多条规则。该方法还包括识别至少一个与这些规则相关联的前置条件(precondition)和至少一个与这些规则相关联的后置条件(postcondition)。每个前置条件表示用于执行这些规则的输入，而每个后置条件表示来自规则执行的输出。该方法还包括接收对应于前置条件的输入值。另外，该方法包括使用该输入值执行这些规则的至少一部分，以产生输出值。该输出值对应于后置条件。

在另一个实施例中，一种用于提供推理服务的方法包括接收指定域的多条第一规则，该规则包括第一规则库的至少一部分。该方法还包括将第一规则装载到存储器中。该方法还包括将来自补充规则库的第二域装载到存储器中。另外，该方法包括在第二域内的规则上对第一规则进行子推理(sub-inferencing)。

在另一个实施例中，一种用于提供推理服务的方法包括执行指定域的多条规则中的至少一部分。这些规则中的至少之一包括表达式。该方法还包括当求解这些规则之一中的表达式所需的字段具有未知值时，挂起(pend)该规则，并且识别与导致决策树规则挂起的表达式相关联的二进制语句(binarystatement)。该方法还包括将已知值赋给导致该规则挂起的字段，并且使该规则解除挂起(unpending)。另外，该方法包括在识别出的二进制语句处重新启动该规则的执行。

附图说明

为了更全面理解本发明，现在结合附图参考下面描述，其中：

图1是示出根据本发明一个实施例的用于提供推理服务的示例系统的示例性方框图；

图2是示出根据本发明一个实施例的用于提供推理服务的另一个示例系统的示例性方框图；

图3是示出根据本发明一个实施例的用于提供推理服务的另一个示例系统的示例性方框图；

图4是示出根据本发明一个实施例的示例规则库架构的示例性方框图；

图5A和5B是示出根据本发明一个实施例的示例规则库构建器的示例性方框图；

图6A、6B、6C-1和6C-2是示出根据本发明一个实施例的示例推理引擎的示例性方框图；

图7是示出根据本发明一个实施例的示例核心应用程序的示例性方框图；

图8是示出根据本发明一个实施例的示例接口的示例性方框图；

图9A和9B是示出根据本发明一个实施例的示例规则类型的示例性方框图；

图10是示出根据本发明一个实施例的用于共享规则库的示例存储器布置的示例性方框图；

图11A到11D是示出根据本发明一个实施例的合并到统一(consolidated)规则库中的示例规则库组件的示例性方框图；

图12是示出根据本发明一个实施例的用于提供推理服务的示例方法的示例性流程图；

图13是示出根据本发明一个实施例的用于规则库构建的示例方法的示例性流程图；以及

图14是示出根据本发明一个实施例的用于合并规则库组件的示例方法的示例性流程图。

具体实施方式

图1是示出根据本发明一个实施例的用于提供推理服务的示例系统100的示例性方框图。在所示实施例中，系统100包括服务器102、数据库104、网络106、以及一个或多个客户端108。

在操作的一方面，服务器102可包括规则库构建器110和推理引擎112。规则库构建器110支持一个或多个规则库114的创建和修改。规则库114包括规则116，其体现由推理引擎112用来执行推理操作的逻辑。例如，规则库114可定义如何分析病人症状和为病人识别可能的诊断。推理引擎112可执行系统100中的推理操作。例如，推理引擎112可接收一个或多个输入值，使用规则库114分析输入值，并且产生一个或多个输出值。然后，输出值可例如通过使病人的诊断可用于用户来用于各种目的。

在所示实施例中，服务器102耦接于网络106。在本文中，术语“耦接”是指两个或更多组件之间的任何直接或间接通信，而不管这些组件是否相互物理接触。另外，术语“通信”可以是指物理上分离的组件之间或者单个物理单元内的组件之间的通信。服务器102执行与系统100中的规则库114的创建和使用相关的一个或多个功能。例如，服务器102可创建、修改和删除规则库114。服务器102还可使用规则库114来执行推理操作。服务器102可包括用于执行规则库构建和推理功能的任何硬件、软件、固件或其组合。

数据库104耦接于服务器102。数据库104存储并帮助检索由服务器102使用的信息。例如，数据库104可存储由规则库构建器110创建且由推理引擎112使用的一个或多个规则库114。数据库104可包括用于存储和帮助检索信息的任何硬件、软件、固件或其组合。另外，数据库104还可使用各种数据结构、布置和编译中的任一种，以存储和帮助检索信息。

网络106耦接于服务器102和客户端108。网络106帮助系统100的组件之间的通信。网络106可以在网络地址之间例如传送网际协议(IP)分组、帧中继帧、异步传输模式(ATM)信元或者其它适合信息。网络106可包括一个或多个局域网(LAN)、城域网(MAN)、广域网(WAN)、全球网络如因特网的全部或部分，或者处于一个或多个位置的任何其它通信系统。

客户端108耦接于网络106。客户端108可执行系统100中的各种功能中的任一种。例如，客户端108可包括客户端应用程序122，其可调用服务器102中的规则库构建器110和推理引擎112的功能性。作为特定例子，客户端应用程序122可以使推理引擎112使用由客户端应用程序122标识的规则库114执行推理操作。客户端108还可表示编程人员或其它用户通过其可使用规则库构建器110创建、修改和删除各个规则库114的终端。客户端108可包括用于与服务器102通信的任何硬件、软件、固件或其组合。

在所示例子中，服务器102包括处理器124和存储器126。处理器124执行指令和操纵数据以执行服务器102的操作。虽然图1在服务器102中示出单个处理器124，但是根据具体需要也可使用多个处理器124。存储器126存储和帮助检索由处理器124使用以执行服务器102的功能的信息。存储器126可以例如存储要由处理器124执行的指令和由处理器124使用的数据。存储器126可包括用于存储和帮助检索信息的任何硬件、软件、固件或其组合。

在所示实施例中，服务器102包括规则库构建器110、推理引擎112和工具128。在特定实施例中，当规则库构建器110或推理引擎112由客户端应用程序122调用时，服务器102创建规则库构建器实例或推理引擎实例。然后，可使用由服务器102实例化的实例来向客户端应用程序122提供服务。如果第二客户端应用程序122试图调用规则库构建器110或推理引擎112，则可为第二客户端应用程序122创建单独的实例。类似地，如果第一客户端应用程序122使用多个线程，并且在每个线程上调用规则库构建器110或推理引擎112，则可为每个线程实例化单独的实例。这允许服务器102同时向多个客户端108和在多个线程上提供规则库构建和推理功能性。在其它实施例中，服务器102无需为每个客户端应用程序122或线程创建实例。另外，在下面描述中，规则库构建器110和推理引擎112可被描述为执行特定功能。该描述包括由规则库构建器实例或推理引擎实例执行特定功能的情形。

规则库构建器110帮助系统100中的规则库114的创建、修改和删除。规则库114定义由推理引擎112使用以执行系统100中的推理功能的一条或多条规则116。例如，规则库114可定义存储信息的数据对象和指定作用于数据对象中的信息的方法和规则的逻辑对象。作为特定例子，数据对象可存储病人症状，而逻辑对象分析症状并且试图计算诊断。示例规则如下面描述的图9A和9B所示。

规则库114可包括使用任何格式定义的任何数目的规则116。在一个实施例中，规则库114包含使用可扩展标记语言(XML)定义的规则116。在特定实施例中，规则库114包含使用下面描述的规则定义语言(RDL)定义的规则116。另外，规则库114可分成多个区或部分。例如，规则库114可分成不同区，其中一个区定义数据对象，而另一个区定义在数据对象上操作的逻辑对象。作为另一个例子，规则库(rulebase)114可由多个规则集(ruleset)130形成，其中每个规则集130包含与公共问题(common issue)相关联的一条或多条规则116。规则库114还可由多个域130形成，其中域130可包括多个规则集130。示例规则库架构如下面描述的图4所示。

规则库构建器110通过将各个规则库组件合并到统一规则库114中来支持系统100中的规则库114的创建。例如，规则库构建器110可将一组规则116、规则集130和规则库114合并到单个规则库114中。规则库构建器110还可解析所得到的统一规则库114，以帮助确保规则116之间的完全性和一致性。作为特定例子，不同开发团队可单独创建不同规则116、规则库114或规则集130，并且规则库构建器110可将各个组件合并到单个规则库114中。作为另一个例子，一个开发团队可创建一组数据对象，而另一个开发团队可创建处理数据对象的一组逻辑对象。然后，规则库构建器110可将数据和逻辑对象合并到规则库114中。

合并到统一规则库114中的各个规则库组件可以若干形式存在。例如，正被合并的规则库114可作为未经编译的源规则库114或经过编译的二进制规则库114而存在。二进制规则库114的使用可允许第三方厂商创建可上市出售给顾客的二进制规则库114。由于规则库114采用二进制形式，因此规则库114的实际内容可以在更大程度上受到保护。获得二进制规则库114的顾客可简单地将其与其它规则库114进行合并。顾客无需访问形成二进制规则库114的实际规则116。

规则库构建器110还可将各个规则库组件转换成标准格式。例如，系统100中的规则库114可具有缺省或标准格式，如采用XML的规则定义语言。如果客户端应用程序122请求规则库构建器110使用具有不同格式的组件创建统一规则库114，则规则库构建器110可将该组件转换并重新格式化成标准格式。然后，规则库构建器110可使用重新格式化的组件生成统一规则库114。这可允许用户采用与由规则库构建器110和推理引擎112使用的标准格式不同的格式编写规则库114。

规则库构建器110还编译源规则库114以创建二进制规则库114。作为例子，规则库构建器110可编译在遵循规则定义语言的XML文档中定义的源规则库114。作为编译结果，规则库构建器110创建规则库114的二进制版本，推理引擎112可使用其来执行推理操作。编译规则库114可帮助提高推理引擎112的工作效率，并且它还可帮助保护规则库114的隐私和提高围绕其的安全性。下面描述如何可将信息合并到由规则定义语言定义的统一规则库114中的描述。

规则库构建器110可包括用来创建和维护规则库114的任何硬件、软件、固件或其组合。例如，规则库构建器110可包括由处理器124执行的一个或多个软件例程。规则库构建器的示例实施例如下面描述的图5A和5B所示。

推理引擎112实现服务器102的推理功能性。例如，推理引擎112可访问一个或多个规则库114，并且识别所要使用的规则116。推理引擎112还可从客户端应用程序122接收输入值，并且使用这些输入来执行规则116。在本文中，术语“执行”最少是指推理引擎112检查规则116的至少一部分以确定是否应执行规则116中的操作。然后，推理引擎112可将推理操作结果返回给客户端应用程序122。

在一个实施例中，由推理引擎112使用的规则116包含或引用属性或字段。具有已知或既定值的字段可称作以“已知状态”存在的“已知字段”，而具有未知或不定值的字段可称作以“未知状态”存在的“未知字段”。在推理期间，推理引擎112使用规则116以尝试将已知值赋给未知字段。

在操作的一方面，推理引擎112可检查规则库114中的规则116，并且触发(fire)、舍弃(fail)或挂起规则116。当推理引擎112检查规则116中的前提，发现前提为真，并且执行在规则116中指定的操作时，它“触发”规则116。当推理引擎112检查规则116中的前提，发现前提为假，并且拒绝执行在规则116中指定的操作时，它“舍弃”规则116。当推理引擎112检查规则116中的前提，并且确定前提不能被求解为真或假时，它“挂起”规则116。这可发生于前提包括具有未知值的字段时。推理引擎112可以以后在将已知值赋给该字段之后试图触发或舍弃该挂起规则116。

推理引擎112可使用一个或多个策略以执行规则库114中的规则116。在一个实施例中，推理引擎112支持规则库114中的规则116的前向链接(forward-chaining)和后向链接(backward-chaining)。一般而言，前向链接涉及推理引擎112试图最大化置于已知状态的规则库114中的未知字段数。在前向链接中，推理引擎112触发规则116，并且作为触发结果确定哪些字段被求解成已知状态。然后，推理引擎112重新访问任何挂起规则116，并且确定这些挂起规则116是否现在可被触发或舍弃。推理引擎112继续该过程，直到推理引擎112不能触发或舍弃任何更多规则116或者执行任何挂起规则116。

后向链接一般涉及推理引擎112试图求解初级目标，例如确定某些前置条件是否保证特定结果或者求解所标识的字段。推理引擎112最初访问可以潜在求解所标识目标的规则116。如果规则116由于未知字段而挂起，则推理引擎112将未知字段添加到次级目标列表。然后，推理引擎112访问可以潜在求解任何初级或次级目标的规则116。推理引擎112继续该过程，直到求解出初级目标或者不再有任何可被执行的规则116。

在执行推理操作中，推理引擎112执行规则库114中的规则116。在一个实施例中，执行规则116的次序至少部分依赖于与规则116相关联的优先级。如上所述，规则116可处于规则集130内，并且规则集130可处于域131内。当客户端应用程序122识别在推理期间所要使用的域131时，推理引擎112将包含在该域131中的无条件规则集130装载到存储器126中。然后，推理引擎112确保包含在域131中的规则116根据其优先级来排序。此后，推理引擎112按照它们的优先级次序执行规则116。

在一个实施例中，当执行推理操作时，推理引擎112实施(enforce)单调推理。单调推理假定一旦推理引擎112由于字段值而触发或舍弃了规则，则在随后推理期间不应改变该字段的值；否则，推理完整性可能遭到损害-因为结果可能反映冲突规则的操作。推理引擎112可检测字段值何时由规则前提测试。如果该字段的值随后发生变化，则推理引擎可将此视作单调推理违例，并且向用户警告该违例。

字段可称作“首次定值字段(first-valued field)”，因为字段的值在分配了初始值之后就不可改变。其它字段可称作“最后定值字段(final-valued field)”，其具有可多次改变的值。例如，当在规则库114中需要计数器时，使用最后定值字段可以是有用的。作为特定例子，规则库114可以包括一组规则集130，并且每个规则集130可确定是否允许纳税人要求特定税豁免。规则库114还可包括记录允许纳税人要求豁免的数目的计数器。当推理引擎112执行每个规则集130时，如果纳税人有资格豁免，则可递增计数器。在本例中，计数器的有用值是未知的，直到所有规则集130都被执行，并且推理引擎112可递增计数器很多次。

首次定值字段与最后定值字段之间的区别可影响在推理期间执行规则116的次序。例如，大量规则116可改变最后定值字段的值。推理引擎112可能不能触发或舍弃在前提中使用最后定值字段的规则116，直到可改变最后定值字段的值的所有规则116都被执行为止。返回到税例子，推理引擎112可以被迫挂起计算由纳税人拥有的税的任何规则116，直到处理豁免次数的所有规则集130都被执行为止。

推理引擎112还可支持补充的规则116、规则库114和规则集130的使用。补充规则库114表示在推理期间除了基本规则库114之外还可使用的规则库。例如，保险公司可具有由其公司总部建立的基本规则库114，并且每个分支机构可具有定义本地政策的补充规则库114。为了使用补充规则库114，推理引擎112可接收基本规则库114，并将其装载到存储器126中。然后，基本规则库114内的规则可从补充规则库装载域，并且在这些域内的规则上进行子推理。在一个实施例中，基本规则库114与补充规则库114之间的通信可通过补充规则库的前置条件和后置条件来发生。在特定实施例中，补充规则库114可以不直接引用基本规则库114中的任何对象，这可帮助使基本规则库114隔离于可能的“恶劣”补充规则库114。补充规则库114还可与不同于基本规则库114的不同推理引擎实例相关联。在本例中，基本规则库114可担当驱动补充规则库114的“应用程序”。从补充规则库114的角度来看，基本规则库114与应用程序可以是不可区分的。基本规则库114可装载一个或多个补充规则库114，然后每个补充规则库114可装载一个或多个另外的补充规则库114。

推理引擎112还可支持系列化的推理和子推理。在系列化推理中，推理引擎112使用第一域131执行推理操作，并且产生一组输出值。然后，推理引擎112使用这些输出值作为第二域131的输入值，并且推理引擎112使用第二域131执行推理操作。例如，当第一域131计算纳税人有权接受的豁免数时，这可以是有用的，并且第二域131根据豁免数计算纳税人所拥有的税。在子推理中，推理引擎112使用第一域131执行推理操作，并且第一域131中的规则116之一可使用第二域131来调用推理。当触发该规则116时，推理引擎112装载第二域131，并且使用第二域131执行推理操作。一旦推理引擎112使用第二域131完成推理，推理引擎112就可返回到使用第一域131。第二域131中的规则116的执行可使第一域中的规则116解除挂起，推理引擎112在返回到第一域131时执行该规则。

推理引擎112可包括用于执行一个或多个推理操作的任何硬件、软件、固件或其组合。推理引擎112例如可包括由处理器124执行的一个或多个软件例程。推理引擎112的示例实施例如下面描述的图6A到6C所示。

为了帮助客户端应用程序122与规则库构建器110之间的通信，规则库构建器110可包括应用程序接口(API)118，或者与之相关联。类似地，推理引擎112可包括API 120，或者与之相关联。API 118、120可以允许客户端应用程序122调用规则库构建器110和推理引擎112的功能。例如，客户端应用程序122可通过API 118将规则库114的标识提供给规则库构建器110而指示规则库构建器110合并两个规则库114。以类似方式，客户端应用程序122可通过API 120将规则库114的标识和输入值提供给推理引擎112而调用推理引擎112的推理功能。

在特定实施例中，规则库构建器110可与无状态(stateless))API 118、有状态(stateful)API 118或两者相关联。类似地，推理引擎112可与无状态API220、有状态API 220或两者相关联。有状态API 118、120可保持面向会话的、涉及与服务器102通信的客户端应用程序122的状态信息。状态信息例如可表示在服务器102与客户端应用程序122在其上运行的客户端108之间发生的会话的当前状态。无状态API 118、120可以不保持面向会话的、涉及与服务器102通信的客户端应用程序122的状态信息。

无状态API 118、120可用来在网络106上作为远程服务调用规则库构建器110或推理引擎112。有状态API 118、120可允许服务器102向访问服务器102的客户端应用程序122提供附加功能性。例如，有状态API 118、120的使用允许服务器102提供“回调(callback)”。在回调期间，规则库构建器110或推理引擎112在规则库构建或推理期间向客户端应用程序122请求附加信息或者向其提供信息。例如，当发生字段值改变时，这可允许服务器102通知客户端应用程序122。

回调还可允许服务器102定义服务器102可调用以初始化前置条件值或其它值的方法。例如，服务器102可请求客户端应用程序122提供特定字段的已知值，这可发生于“最后机会处理”期间。在推理期间，推理引擎112可能由于字段具有不能求解的未知值而不能完成推理。当此发生时，推理引擎112可请求客户端应用程序122提供未知字段的值。如果客户端应用程序122提供该值，则推理引擎112可能能够继续或完成推理操作。在另一个实施例中，规则库114可提供最后机会值，以在最后机会处理期间使用。在本实施例中，当推理引擎112在推理期间不能求解字段的值时，推理引擎112使用该字段的最后机会值。也可使用这些方法的组合，例如推理引擎112从客户端应用程序122请求第一值，并且当客户端应用程序122未提供第一值时，使用来自规则库114的第二值。

工具128帮助开发和维护系统100中的规则库114。例如，规则编辑器132帮助用户创建规则116。规则编辑器132可允许用户创建和编辑规则116。作为特定例子，规则编辑器132可允许用户创建包含规则116的XML文档，编辑包含规则116的现有XML文档，并且删除包含规则116的XML文档。

工具128还可包括一个或多个变换器133。变换器133将规则116从一种格式转换成不同格式。例如，变换器133可接收使用自然语言定义的规则116，并且将规则116转换成XML格式。这可允许用户使用简单表示法或语法来输入规则116。在一个实施例中，变换器133可包括Infix到XML Java编码工具应用程序。可使用其它变换器133如图形编辑器或下拉式机制。

工具128还可包括一个或多个分析器134。分析器134检查二进制或源规则库114，并且识别数据对象与规则116之间的关系。例如，用户可识别特定数据对象，并且分析器134可识别从数据对象读取值或者向数据对象写入值的任何规则116。

工具128还可包括一个或多个调试器136。调试器136在推理期间监视规则116的执行。例如，调试器136可识别提供给推理引擎112的输入值、在推理期间触发的规则116、触发规则116的次序、以及触发每条规则116的原因。然后，可使用该信息来分析所发生的推理操作。当规则库114没有提供适当结果，并且用户想要识别规则库114为什么不能按照预期那样工作时，这可以是有用的。

另外，工具128可包括一个或多个测试器138。测试器138帮助用户确保规则库114、规则集130或一组规则116按照计划的那样工作。例如，测试器138可接收识别规则库114的信息、一组输入值和一组预期输出值。然后，测试器138使用所识别的规则库114和输入值调用推理引擎112，从推理引擎112接收算出的输出值，并且确定算出的输出值是否匹配预期输出值。在特定实施例中，测试器138可访问包含多组输入值和对应输出值的库，以测试所识别的规则库114。

每个工具128可包括用于执行系统100中的一个或多个功能的任何硬件、软件、固件或其组合。另外，每个工具128可使用API 118、120调用规则库构建器110或推理引擎112中的功能。

在一个实施例中，规则库114可定义其自己的数据对象，并且规则库114可独立于依赖于嵌入在规则库114中的逻辑的应用程序来开发和使用。例如，专用客户端应用程序122可由一组用户开发，而另一组用户开发要由客户端应用程序122使用的规则库114。作为特定例子，规则库114或规则库114中的域131可定义前置条件或输入值，以及后置条件或输出值。开发规则库114的用户可识别前置条件和后置条件，并且开发客户端应用程序122的用户可以简单地确保客户端应用程序122被设计成将适当的前置条件传送给推理引擎112，并且从推理引擎112接收适当的后置条件。另外，由于规则库114可以与使用规则库114调用推理的客户端应用程序122分开地定义其自己的数据对象，因此多个客户端应用程序122可以共享规则库114。即使一个客户端应用程序122的推理与另一个客户端应用程序122的推理部分或完全重叠，这些客户端应用程序122也可使用相同规则库114调用推理。

虽然图1示出用于提供推理服务的示例系统100，但是也可对系统100进行各种改变。例如，图1示出服务器102的一个示例功能划分。根据具体需要，可组合或省略服务器102的各个组件，并且可增加另外的组件。作为特定例子，可从服务器102中省略规则库构建器110或推理引擎112，或者规则库构建器110和推理引擎112可驻留在单独平台上。另外，数据库104可存储系统100中所需的任何其它信息，并且数据库104和存储器126可驻留在可由服务器102访问的任何一个或多个位置。此外，服务器102可支持其它或附加工具128，并且规则库114可驻留在数据库104以外的其它位置。另外，推理引擎112可支持规则116的前向链接或后向链接，并且在系统100中可使用与规则库构建器110和推理引擎112的其它接口。

图2是示出根据本发明一个实施例的用于提供推理服务的另一个示例系统200的示例性方框图。在所示实施例中，系统200包括服务器202、数据库204、网络206和一个或多个客户端208。

服务器202、数据库204、网络206和客户端208可相同或类似于图1的服务器102、数据库104、网络106和客户端108。在本实施例中，规则库构建器210和推理引擎212形成服务器应用程序250的一部分。服务器应用程序250表示可在网络206上由客户端应用程序222调用的应用程序。服务器应用程序250例如可表示专家应用程序，如与医疗或法律领域相关联的应用程序。

在操作的一方面，服务器应用程序250可从客户端应用程序222接收请求以构建规则库214或执行推理操作。服务器应用程序250可创建规则库构建器210或推理引擎212的实例，并且允许该实例执行适合操作。

在所示实施例中，服务器应用程序250包括服务器API 252。服务器API252允许客户端应用程序222调用服务器应用程序250的功能。例如，客户端应用程序222可调用创建规则库构建器实例的服务器应用程序250的功能，并且客户端应用程序222可识别多个源规则库214。服务器应用程序250可将通过服务器API 252接收的信息传给规则库构建器实例，并且允许规则库构建器实例合并和编译所识别的规则库214。服务器API 252可表示有状态接口、无状态接口、或者其它接口或接口的组合。

在特定实施例中，服务器应用程序250表示Java应用程序、J2EE小服务程序(servlet)、企业版Java组件(EJB)应用程序、Java服务器页面(JSP)应用程序、或者其它适合应用程序。在本实施例中，API 218、220可包括可作为本地服务由服务器应用程序250调用的有状态接口。另外，服务器应用程序250可作为远程服务由客户端应用程序222通过API 252来调用。

虽然图2示出用于提供推理服务的示例系统200，但是也可对系统200进行各种改变。例如，虽然图2示出服务器202的一个示例功能划分，但是根据具体需要，可组合或省略服务器202的各个组件，并且可增加另外的组件。作为特定例子，可从服务器202中省略规则库构建器210或推理引擎212。

图3是示出根据本发明一个实施例的用于提供推理服务的另一个示例系统300的示例性方框图。在所示实施例中，系统300包括执行应用程序362的主机计算机360。

在所示实施例中，主机360可采用任何公知的MS-DOS、PC-DOS、OS-2、MAC-OS、WINDOWS、UNIX、LINUX或其它适合操作系统执行。主机360可表示桌面计算机、膝上型计算机、服务器计算机或其它适合计算或通信设备。主机360可包括输入设备364、输出设备366、随机存取存储器(RAM)368、只读存储器(ROM)370、CD-ROM、硬盘驱动器或者其它磁或光存储设备372以及一个或多个处理器374。输入设备364例如可包括键盘、鼠标、图形输入板、触摸屏、压敏板、操纵杆、光笔、麦克风或者其它适合输入设备。输出设备366例如可包括视频显示器、打印机、盘驱动器、绘图仪、扬声器或其它适合输出设备。

图3的虚线内的项目表示系统300的关联组件的示例性功能操作和数据组织。在所示实施例中，主机360包括应用程序362和数据库304。数据库304可相同或类似于图1和2的数据库104和数据库204。

应用程序362可表示使用规则库构建和推理功能性的专家应用程序或其它应用程序。在所示例子中，应用程序362包括规则库构建器310、推理引擎312以及其它编程逻辑374。规则库构建器310可相同或类似于图1和2的规则库构建器110和规则库构建器210。同样，推理引擎312可相同或类似于图1和2的推理引擎112和推理引擎212。另外，规则库构建器310和推理引擎312可以但无需包括API 318和320。

附加编程逻辑374可表示调用规则库构建器310和推理引擎312的应用程序362中的逻辑。例如，逻辑374可实现从用户接收病人症状并且将症状传给推理引擎312的医疗专家程序。在推理引擎312执行推理之后，逻辑374可使诊断可用于用户。应用程序362中的逻辑374可执行任何其它适合功能。

在特定实施例中，应用程序362可表示Java应用程序。另外，API 318、320可包括作为应用程序362中的本地服务调用的有状态接口。

虽然图3示出用于提供推理服务的示例系统300，但是也可对系统300进行各种改变。例如，虽然图3示出主机360的一个示例功能划分，但是根据具体需要，可组合或省略主机360的各个组件，并且可增加另外的组件。作为特定例子，可从主机360中省略规则库构建器310或推理引擎312。另外，虽然图3示出主机360为桌面计算机，但是也可使用其它计算或通信设备。另外，虽然图1-3示出各种示例操作环境，但是规则库构建器110、210、310和推理引擎112、212、312也可用于任何其它适合环境中。

图4是示出根据本发明一个实施例的示例规则库架构400的示例性方框图。在本实施例中，规则库架构400包括规则库级元素402、域级元素404、以及规则集级元素406。虽然规则库架构400可以关于图1的系统100来描述，但是规则库架构400也可与其它系统一起使用，并且系统100也可使用其它规则库架构。

在图4中，规则库级元素402包括类408、初始化方法410、关联412、约束414以及域416。类408定义存储信息的数据对象和可以处理数据对象中的信息的方法对象。例如，类408可定义Person(人)对象，其包括人名、年龄及其配偶姓名(若有的话)的字段。作为另一个例子，类408可定义Retirement(退休)方法，其分析Person实例，比较该人的年龄与65的值，并且根据比较来设置识别该人是否达到退休年龄的标志。

初始化方法410定义服务器102如何初始化各个对象中的字段。例如，初始化方法410可将一组数据对象中的任何整数字段初始化为零值，并且将任何字符串字段初始化为空(NULL)值。初始化方法410还可例如通过将最大年龄字段设为120的值来设置约束值。

关联412定义字段之间的关系。例如，Person实例可以是另一个Person实例的配偶，并且关联可以表示Person实例之间的一对一关系。作为另一个例子，Person实例可拥有多个Duck(鸭子)实例，并且关联可表示Person与Duck实例之间的一对多关系。在一个实施例中，相关字段处于架构400的相同级别，例如在两个类408中。在特定实施例中，关联由两个角色定义。每个角色指定类和由该类拥有的实例引用字段。一个对象中的实例引用字段指向或者识别另一个对象。例如，Ownership(拥有关系)关联可对Person类的Owns(拥有)字段定义一个角色，并且对Duck类的IsOwnedBy(被拥有)字段定义另一个角色。

约束414定义关于赋给字段的值应为真的条件。约束414还定义如果违反条件则发生的操作。例如，约束414可指定存储人年龄的字段应当具有0到120之间的值。如果Person实例被赋为800的年龄，则违反与年龄字段相关联的约束414，并且可执行由该约束414定义的操作。该操作可包括推理引擎112停止推理，使用替代值，或者使用有状态接口120，以从客户端应用程序122请求正确值。

域416将规则分成称作域的不同组。在每个域416中，规则库可包括初始化方法418、关联420、约束422、类424以及规则集426。初始化方法418、关联420、约束422和类424可相同或类似于初始化方法410、关联412、约束414和类408。这些域级元素404可具有不同于规则库级元素402的范围。例如，虽然关联412可定义处于规则库级别的两个类之间的关系，但是关联420也可定义处于域级别的类之间的关系。在某些实施例中，前置条件和后置条件可以在主要级别定义。

规则集426还将规则分成称作规则集的不同组。在每个规则集426中，规则库可包括初始化方法428、关联430、约束432、类434以及规则436。这些规则集级元素406可具有与对应规则库级元素402和域级元素404不同的范围。例如，关联430可定义处于规则集级别的类之间的关系。

规则436定义用来分析输入值并产生输出值的逻辑。规则436可处理数据对象，如使用类408、424、434创建的对象中的信息。规则436还可使用在方法对象中定义的方法，以赋值给数据对象中的字段。在一个实施例中，规则436包括决策树规则和模式匹配规则。示例模式匹配规则如下面描述的图9A所示。示例决策树规则如下面描述的图9B所示。

虽然图4示出规则库架构400的一个例子，但是可对规则库架构400进行各种改变。例如，根据具体需要，可以向架构400的各个级别增加另外的元素，并且可以省略当前元素。

图5A和5B是示出根据本发明一个实施例的示例规则库构建器的示例性方框图。具体地说，图5A示出无状态规则库构建器500，而图5B示出有状态规则库构建器550。虽然图5A和5B可以关于图1的系统100来描述，但是规则库构建器500、550也可与其它系统一起使用。

在图5A中，无状态规则库构建器500允许应用程序调用各种函数调用502，并且函数调用502使用各种数据结构504作为输入和输出。在所示实施例中，函数调用502包括构造器函数506以及构建函数508。构造器函数506创建规则库构建器500的实例，以由请求规则库构建服务的应用程序使用。例如，客户端应用程序122可在网络106上调用构造器函数506。服务器102执行构造器函数506，并且实例化规则库构建器500的实例，从而创建规则库构建器实例。然后，来自客户端应用程序122的另外函数调用被引导到该规则库构建器实例。如果多个客户端应用程序122请求规则库构建服务，则服务器102可执行构造器函数506，以创建规则库构建器500的多个实例。

构建函数508使规则库构建器实例将各个输入，如规则库、规则以及规则集合并到统一规则库中。构建函数508可接受二进制规则库510、字符串512a-512b，以及控制对象513作为输入。输入字符串512a表示XML字符串，其包括未经编译的或源规则、规则库和规则集。输入字符串512b表示统一资源定位符(URL)，其识别经编译或未经编译的规则、规则库和规则集的远程位置。在构建统一规则库之前，规则库构建器实例可访问由URL识别的远程位置，并且在该位置检索任何规则、规则库或规则集。

服务器102使用包含在控制对象513中的值528，以标识当执行构建函数508时规则库构建器实例应执行的不同功能。例如，值528a指示规则库构建器实例是否生成应用程序接口文档522。值528b指示规则库构建器实例是否生成二进制规则库516。值528c指示规则库构建器实例是否生成装载图(load map)524。值528d-528f指示规则库构建器实例是否跟踪各种事件，其可以在消息526中描述。在本例中，事件可分成高级别或L1事件、低级别事件或L2事件以及装载器事件。也可使用其它事件划分。

当调用构建函数508时，规则库构建器实例可以试图组合输入规则、规则库和规则集，并且产生输出结果514。输出结果514可包括统一二进制规则库516。规则库516表示将这些输入合并到统一规则库中并且进行编译时所形成的规则库。输出结果514还可包括错误计数518和警告计数520。错误计数518识别当创建统一规则库516时所识别的错误数，而警告计数520识别所产生的警告数。

输出结果514还可包括应用程序接口文档522和装载图524。应用程序接口文档522描述由规则库516使用的输入值和由规则库516产生的输出值。当二进制规则库516将结合正被开发的应用程序一起使用时，应用程序接口文档522可以是有用的。应用程序接口文档522可描述与规则库516相关联的输入和输出，并且创建应用程序的开发者可确保应用程序向规则库516发送适当的输入，并且从规则库516预期适当的输出。

装载图524识别规则库516中的各个对象。装载图524还识别规则库516中的对象之间的关系，以及规则库516中影响该对象的任何规则。例如，对于给定对象，装载图524可识别从该对象读取值或向其写入值的任何规则。装载图524还可例如由系统100中的另一个组件处理以生成规则库报告。规则库报告可识别规则库516中的规则、规则之间的交互、或者其它适合信息。

输出结果514还可包括零个或更多消息526的集合。消息526可包括在统一规则库516的创建期间产生的错误和警告消息。消息526还可包括跟踪消息，如用来识别在统一规则库516的创建或编译期间发生的不同事件的消息。

在操作的一方面，输出结果514的内容可根据值528而变化。例如，如果值528a具有假值，则输出结果514将不包括应用程序接口文档522。类似地，如果值528c具有真值，则输出结果514将包括装载图524。如果值528b具有假值，则输出结果514将不包括二进制规则库。例如，当需要用于现有二进制规则库的应用程序接口文档522或装载图524时，这可以是有用的。

在图5B中，有状态规则库构建器550允许应用程序调用使用数据结构554作为输入和输出的各种函数调用552。在所示实施例中，函数调用552包括构造器函数556。构造器函数556创建规则库构建器550的实例，以由请求规则库构建服务的应用程序使用。构造器函数556包括两个输入值，即跟踪掩码(tracemask)568和消息处理程序(handler)570。为跟踪掩码568提供的值确定提供给客户端应用程序122的跟踪消息的详细级别。详细级别可识别是否提供跟踪消息，并且如果提供，则应在什么情形下提供跟踪消息。如下所述，消息处理程序570识别用来在客户端应用程序122与规则库构建器实例之间传送信息的处理程序。例如，消息处理程序570允许规则库构建器550执行回调操作，并且从客户端应用程序122请求信息。

增加规则库函数558a-558c识别要合并到统一规则库中的不同规则库、规则和规则集。增加规则库函数558a接受当生成统一规则库时要使用的二进制规则库、规则或规则集。增加规则库函数558b接受当生成统一规则库时要使用的源或未经编译规则库、规则或规则集。增加规则库函数558c接受URL，其识别当生成统一规则库时要使用的规则库、规则或规则集的远程位置。当使用增加规则库函数558a-558c增加每个规则库、规则或规则集时，将其与先前增加的规则库、规则和规则集进行合并。编译函数560编译所合并的规则库以创建二进制规则库。

生成应用程序接口文档函数562生成应用程序接口文档。生成二进制规则库函数564通过输出流向客户端应用程序122提供二进制规则库，并且客户端应用程序122可将输出流存储到缓冲器或其它存储器中。生成装载图函数566生成规则库的装载图。

由于有状态规则库构建器550维护会话信息，因此由规则库构建器550支持的各种函数调用552可以由客户端应用程序122单独调用。例如，使用客户端应用程序122的用户可能想要现有二进制规则库的应用程序接口文档。客户端应用程序122可使用增加规则库函数之一558a将二进制规则库提供给构建器550。然后，客户端应用程序122可通过调用函数562来生成应用程序接口文档。如果用户以后决定生成装载图，客户端应用程序122可调用函数566，以使用相同规则库构建器实例生成装载图。

虽然图5A和5B示出示例规则库构建器500、550，但是可对规则库构建器500、550进行各种改变。例如，根据具体需要，可从构建器500、550中省略各种函数调用502、552。另外，可以向构建器500、550增加另外的函数调用502、552。另外，虽然图5A、5B示出与函数调用502、552一起使用的示例数据结构504、554，但是也可使用其它或附加的数据结构。

图6A到6C是示出根据本发明一个实施例的示例推理引擎的示例性方框图。具体地说，图6A示出无状态推理引擎600，而图6B和6C示出有状态推理引擎650。虽然图6A到6C可以关于图1的系统100来描述，但是推理引擎600、650也可与其它系统一起使用。

在图6A中，无状态推理引擎600允许应用程序调用使用数据结构604作为输入和输出的函数调用602。在所示实施例中，函数调用602包括创建推理引擎600的实例以由应用程序使用的构造器函数606。函数调用602还包括两个推理函数608、610。

推理函数608使用提供给引擎600的规则库612和控制对象613作为输入来调用引擎600的推理。规则库612可包括如图4中的域416所示的多个域。结果，推理函数608还接收域名614作为输入，其中域名614识别在推理期间要使用哪个域416。推理函数608还接收在推理期间要创建和使用的任何动态实例616的标识。推理函数608还接收任何有条件规则集618，其表示要与由域名614标识的域一起使用的附加规则。另外，推理函数608可接收前置条件值620a-620b作为输入。前置条件值620被赋予所标识规则库612中的适当字段，并且在推理期间被使用。前置条件值620可采取前置条件值文档620a或前置条件值数组620b的形式。

控制对象613定义由服务器102使用的值632a-632f，以控制由推理引擎实例执行的操作。值632a指示推理引擎实例生成字段值数组626b，而值632b指示推理引擎实例生成字段值文档626a。值632c指示推理引擎实例生成规则快照630。值632d-632f指示推理引擎实例跟踪可在消息628中描述的各种事件。在本例中，这些事件分成L1事件、L2事件和推理事件。也可使用其它的事件划分方法。

推理函数610接收很多与推理函数608相同的输入。推理函数608接收二进制规则库612，而推理函数610接收标识在推理期间所要使用的规则库的位置的URL输入622。

推理函数608、610返回输出结果624。输出结果624可包括零个或多个字段值626a-626b的集合。字段值626表示在推理期间由推理引擎600赋给后置条件的值。根据值632a和632b，字段值626可采取字段值文档626a或字段值数组626b的形式。输出结果624还可包括零个或更多消息628的集合。消息628可包括在推理操作期间产生的错误消息、警告消息和跟踪消息。

输出结果624还可包括规则快照630。规则快照630提供特定时间点的当前规则状态信息。规则快照630可标识规则、与规则相关联的任何规则集、规则的优先级、与规则相关联的规则类型、规则状态、以及规则中导致规则挂起的任何字段。

在图6B和6C中，有状态推理引擎650允许应用程序调用使用数据结构654作为输入和输出的各种函数调用652。在所示实施例中，构造器函数654a-654c创建推理引擎650的实例。具体地说，函数654a创建使用采用输入流定义的二进制规则库的推理引擎实例，并且函数654b创建使用采用URL定义的二进制规则库的推理引擎实例。如下所述，多个推理引擎实例可使用相同规则库，并且函数654c根据使用相同规则库的另一推理引擎实例创建一个推理引擎实例。

域函数656a-656b控制在推理期间使用哪个域416。域函数656a标识在推理期间所要使用的域416，并且域函数656b删除域416，从而在推理期间不再使用它。输入函数658a-658b将前置条件的值提供给推理引擎650。具体地说，函数658a提供特定前置条件的值，而函数658b提供与当前域416相关联的一组前置条件的值。有条件规则集函数660将附加规则集提供给推理引擎650以与当前域416一起使用。动态实例函数662创建在推理期间所要使用的动态实例。推理函数664使用包含在当前域416中的规则开始推理过程。输出函数666提供由推理引擎650计算的后置条件值。具体地说，函数666a创建包含一组后置条件的值的输出值文档，函数666b提供特定后置条件的值，并且函数666c提供所有前置条件和后置条件的值。快照函数668生成和输出当前域的规则快照。

由于有状态推理引擎650维护会话信息，因此可由推理引擎650提供附加函数。例如，推理引擎650可提供说明性服务，其用来确定在推理期间如何向特定字段赋值。开始说明函数670接收字段标识作为输入，并且识别将最终值赋给该字段的规则。说明规则触发函数672使用由开始说明函数670识别的规则，并且确定是什么导致触发该规则。这可包括识别导致规则触发的任何字段以及这些字段的值。说明字段求解函数674使用由说明规则触发函数672识别的字段，并且确定如何向该字段赋值。这些函数670-674允许客户端应用程序122跟踪在推理期间如何和为什么赋值给字段。这些函数670-674可要求服务器102对在推理期间执行的各个步骤进行监视和归档。由于该监视在推理期间可施加附加处理要求，因此跟踪函数676a-676b允许客户端应用程序122指定服务器102何时应监视在推理期间执行的步骤。这允许客户端应用程序122控制何时需要该附加处理。

有状态推理引擎650的使用还可允许服务器102向客户端应用程序122提供真实维护(truth maintenance)(“TM”)功能。在推理期间，将已知值赋给字段可触发一连串后果。例如，如果规则由于字段没有已知值而先前被挂起，则向该字段赋值可导致推理引擎650使该规则解除挂起，然后触发该规则。所触发的规则可能又求解出其它字段，该其它字段又导致推理引擎650使另外规则解除挂起，并且触发该另外规则。真实维护是指允许客户端应用程序122撤消或撤回对字段的赋值，从而撤消该赋值的后果的机制。这意味着真实维护功能性可以有用于“假设分析(what-if)”型推理。作为特定例子，在贷款核定应用程序中，借款人可能想要以若干不同变量如贷款金额、贷款期限和利率来试验。在这些情形下，由于存在一组假设场景，因此“答案”是不确定的，并且只有在以可选场景试验之后才可能知道答案。

为了支持真实维护，设置TM值函数678表示特定字段可被赋予可撤消值。可撤消值表示在能被否决的赋值期间所赋的值。客户端应用程序122可将多个值赋给选定字段。确认TM值函数680将特定字段的当前值设为那个字段的不可撤消值。不可撤消值表示在不能被否决的赋值期间所赋的值。撤消TM值函数682将字段撤消回到其最后的不可撤消值。在操作中，客户端应用程序122可将五个可撤消值赋给字段。客户端应用程序122然后可将不可撤消值赋给该字段，随后是七个以上可撤消值。在本例中，赋给字段的最后七个值可被撤消，但是前五个不能。不可撤消值的存在防止推理引擎650撤消在赋予不可撤消值之前所赋的任何值。回到贷款例子，选定字段可表示借款人想要接收的最大金额。在一些试验中，该字段可被赋予多个可撤消的值。逐渐地，用户可以识别借款者被允许接收的最大金额。该最大金额可被赋为不可撤消值。可以完成将附加的可撤消值赋给字段的附加试验。这些附加值中的任一个都可被接受为贷款金额，或者可以将这些值撤回为被标识为不可撤消值的最后最大贷款金额。

除了这些函数之外，处理程序函数684a-684b向推理引擎实例登记各个通信处理程序。如下所述，处理程序函数允许推理引擎实例在推理期间与客户端应用程序122通信。复位函数686将推理引擎实例复位到初始状态。例如，这可包括推理引擎650将所有字段值复位到未知状态，删除所有动态实例，弹出(popping)所有域，并且运行任何规则库级初始化方法410。

虽然图6A到6C示出示例推理引擎600、650，但是可对推理引擎600、650进行各种改变。例如，根据具体需要，可从推理引擎600、650中省略各种函数调用602、652。另外，可向推理引擎600、650增加另外的函数调用602、652。另外，虽然图6A到6C示出与函数调用602、652一起使用的示例数据结构604、654，但是也可使用其它或附加数据结构。

图7是示出根据本发明一个实施例的示例核心对象700的示例性方框图。核心对象700表示由规则库构建器500、550和推理引擎600、650共享的对象。虽然图7可以关于图2的系统200来描述，但是核心对象700也可与其它系统一起使用。

在图7中，核心对象700使用各种数据结构702以与规则库构建器500、550和推理引擎600、650通信。数据结构702包括消息处理程序704。消息处理程序704表示用来与客户端应用程序222通信的处理程序。例如，消息处理程序704可用来截取来自规则库构建器500、550或推理引擎600、650的消息706。这可允许消息处理程序704捕获由规则库构建器500、550或推理引擎600、650产生的错误、警告、跟踪或其它消息706。数据结构702还包括异常708。异常708标识在规则库构建或推理期间检测的错误。

数据结构702还可包括跟踪掩码710。跟踪掩码710表示如何跟踪由服务器102执行不同功能。为跟踪掩码710提供的整数值确定提供给客户端应用程序222的跟踪消息的详细级别。详细级别可标识是否提供跟踪消息，并且如果提供，则应在什么情形下提供跟踪消息。例如，零值可导致服务器202不提供任何跟踪消息，并且一的值可导致服务器202提供较一般的跟踪消息，并且较高的值可导致服务器202提供较特定的跟踪消息。在本例中，事件分成推理事件、L1事件和L2事件和装载器事件。也可使用其它事件划分方法。

虽然图7示出核心对象700的一个例子，但是也可对核心对象700进行各种改变。例如，可使用任何其它或附加数据结构702。

图8是根据本发明一个实施例的示例接口800的示例性方框图。在本实施例中，接口800包括初始化处理程序802和改变处理函数804。虽然图8可关于图1的系统100来描述，但是接口800也可与其它系统一起使用。

初始化处理程序802允许客户端应用程序122初始化字段值。例如，推理引擎650可试图在推理期间执行规则，但是该规则可能包括未知字段。推理引擎650可挂起该规则，并且检查未知字段是否以后被求解。作为挂起规则的替代或补充，推理引擎650可调用初始化处理程序802，并且向客户端应用程序122询问是否客户端应用程序122想要为未知字段提供值。如果客户端应用程序122提供值，则推理引擎650可使用该值并且继续推理。

当规则库存在大量前置条件时，初始化处理程序802的使用可以是有用的。例如，规则库可具有1,000个前置条件。在不使用初始化处理程序802的情况下，在推理开始之前，客户端应用程序122将为所有1,000个前置条件提供输入值。在使用初始化处理程序802的情况下，客户端应用程序122可为一些前置条件提供输入值，并且推理引擎650可以使用这些值尝试完成推理。如果推理引擎650不能完成推理并且需要更多前置条件的值，则客户端应用程序122可使用初始化处理程序802以提供必要前置条件的输入值。

当推理引擎650改变各个数据对象时，改变处理函数804允许服务器102通知客户端应用程序122。例如，当改变字段值时，函数806通知客户端122。当创建对象时，函数808通知客户端应用程序122，并且当删除对象时，函数810通知客户端应用程序122。

当在推理期间由推理引擎650计算大量后置条件时，改变处理程序804的使用可以是有用的。例如，规则库可具有1,000个后置条件。在不使用改变处理程序804的情况下，在从推理引擎650接收1,000个输出值的集合之前，客户端应用程序122可能需要等待直到推理引擎650完成推理。在使用改变处理程序804的情况下，每当后置条件之一被赋值时，就可通知客户端应用程序122。这样，即使当推理尚未完成时，客户端应用程序122也了解各个后置条件何时被赋值。

虽然图8示出示例接口800，但是也可对接口800进行各种改变。例如，可使用任何其它或附加通信处理程序。另外，每个处理程序802、804可支持任何其它或附加功能。

图9A和9B是示出根据本发明一个实施例的示例规则类型的示例性方框图。具体地说，图9A示出模式匹配规则900，而图9B示出决策树规则950。也可使用其它或附加类型的规则。另外，虽然图9A和9B可关于图1的系统100来描述，但是规则900、950也可与其它系统一起使用。

在图9A中，模式匹配规则900包括前提902、操作904以及绑定区906。前提902表示确定是否应执行操作904的条件。例如，前提902可包括一个或多个表达式908。服务器102可检查前提902中的表达式908，并且确定表达式908是真还是假。使用这些结果，如果表达式908为真，则服务器102可通过执行操作904来触发规则900，而如果表达式908为假，则舍弃规则900，或者如果不能确定表达式908的值，则挂起规则900。

操作904表示如果规则900的前提902为真、则要由服务器102执行的一个或多个操作。例如，操作904可表示服务器102应将特定值赋给字段。操作904还可使服务器102执行功能或调用不同规则库域上的子推理。

绑定区906标识要由服务器102监视的数据对象。由于规则900是模式匹配规则，因此它可应用于满足前提902的实例或对象的整个集合。绑定区906包括一个或多个绑定变量910。推理引擎112将绑定变量910与绑定类的一个或多个候选实例相关联。然后，推理引擎112将绑定变量910应用于前提904，以确定任何候选实例是否满足前提902。这样，推理引擎112确定候选实例是否应受进一步的关注。如果任何候选实例满足前提902，则服务器102使用这些候选实例执行操作904。

在所示例子中，P的绑定变量910与Person类相关联，而D的另一个绑定变量910与Duck类相关联。当人的年龄大于鸭子并且该人不拥有任何其它鸭子时，规则900用来将表示该人的Person对象与表示该鸭子的Duck对象相关联。服务器102将Person对象绑定于P变量910，并且将Duck对象绑定于D变量910。使用绑定变量910，服务器102检查现有Person和Duck对象，并且确定是否有任何对象满足前提902。如果有任何对象满足前提902，则服务器102将规则900的操作904施加于这些数据对象的每一个。操作904增加由该人拥有的鸭子的数目，并且将该人与该鸭子相关联。

在特定实施例中，服务器102将模式匹配规则900保持于就绪状态，并且不舍弃或挂起模式匹配规则900。在另一个特定实施例中，模式匹配规则900可用作单触发规则。在本实施例中，推理引擎112等待直到阈值数目的对象绑定于绑定变量910。一旦满足阈值数目，则推理引擎112使用这些对象执行模式匹配规则900一次。然后可以由推理引擎112忽略所执行的模式匹配规则900。

由于规则库可包括大量对象，因此服务器102可使用一种或多种算法来提高处理模式匹配规则900的效率。例如，服务器102可使用神经网络(Rete)算法。使用神经网络算法，服务器102检测何时创建、修改或删除对象。然后，服务器102执行具有使用受影响于创建、修改或删除的字段的前提902的任何模式匹配规则900。服务器102可检查所定位的任何模式匹配规则900的前提902，并且如果满足前提902，则执行操作904。

在一个实施例中，当应用第一模式匹配规则900的操作904时，服务器102可创建、修改或删除对象。这些对象可以受影响于同一模式匹配规则900或另一模式匹配规则900。结果，操作904可引起新对象与一条或多条规则900的绑定。

在图9B中，决策树规则950包括求值语句952或子树，随后是两个或更多树节点954a-954e。每个子树可被命名成使其可以容易地与规则相关联。求值语句952计算和确定表达式956的值。根据表达式956的算出值，执行树节点954之一。

每个树节点954包括所要执行的操作之前的case语句958或otherwise语句960。case语句958标识表达式956的可能值或可能值的范围。如果表达式956的值匹配case语句958的值或者落在其值范围内，则执行与case语句958相关联的树节点954。otherwise语句960标识如果不能执行任何其它树节点954则执行的树节点954。

要在树节点954中执行的操作还可包括附加子树。例如，树节点954a包括另一个求值语句962和两个树节点964a-964b。这样，规则950可分成子树的分级层，并且服务器102可遍历(traverse through)这些子树以到达要执行的适当操作。

在所示例子中，表达式956计算年龄，并且根据算出的年龄选择树节点954之一。如果算出的年龄具有已知值，则可根据该值选择树节点954a、954b或954c。如果算出的年龄是未知的，例如当该值依赖于具有未知值的字段时，选择树节点954d。如果算出的年龄是已知的但是落在树节点954a-954c中的case语句的范围之外，则可选择树节点960。

在特定实施例中，服务器102可为决策树规则950使用即时存储器分配方案。在即时分配方案中，服务器102仅将决策树规则950的一部分装载到存储器如存储器126中。所装载的规则950的该部分允许服务器102识别要遍历的树节点954。在服务器102识别要遍历的树节点954之后，服务器102将那个树节点954的内容装载到存储器中。如果所装载的树节点954包括附加子树964，则服务器102仅装载规则950的一部分，其中该部分允许服务器102选择要遍历的下一个子树964。在选择下一个子树964之后，服务器102将那个子树964的内容装载到存储器中。该过程继续直到服务器102触发或舍弃规则950，此时，服务器102可释放由规则950使用的存储器。使用即时分配方案可减少由决策树规则950使用的存储器量。由于决策树规则950可包含数百或数千个嵌入子树，因此使用即时分配方案可帮助减少处理决策树规则950的存储器需求。

在一个实施例中，服务器102可被迫挂起决策树规则950。例如，服务器102在推理期间可选择树节点954b，但是字段Fact3可能具有未知值。在本例中，由于服务器102不能完成规则950的执行，因此服务器102将挂起规则950。在特定实施例中，服务器102执行定点重新启动(pinpoint restart)，以使规则950解除挂起并完成其执行。当规则950挂起时，服务器102可获得规则950的快照。该快照标识规则950的上下文，如用于规则950中的字段的值，以及使规则950挂起的语句的精确位置。在上面例子中，该快照可标识求值语句966的位置，因为其是使规则950挂起的语句。当使规则950挂起的字段被赋予已知值时，服务器102可使规则950解除挂起，并且在存储于快照中的位置开始执行规则950。这可允许服务器102更高效地挂起可能包含大量子树的决策树规则950和使其解除挂起。

虽然图9A和9B示出示例规则900、950，但是也可对规则900、950进行各种改变。例如，规则900可包括任何数目的绑定变量910，并且规则950可包括任何数目的子树。另外，还可使用其它或附加类型的规则。

图10是示出根据本发明一个实施例的用于共享规则库的示例存储器布置的示例性方框图。具体地说，图10示出用于图1的服务器102中的存储器1026，其中多个客户端应用程序122在推理期间使用相同规则库114。在本实施例中，存储器1026包括规则库114的只读映像1050以及一个或多个客户端特定信息块1052。虽然图10可关于图1的系统100来描述，但是存储器1026也可与其它系统一起使用。

只读映像1050表示规则库114中的规则116的副本。服务器102可通过将规则库114从数据库104或其它位置装载到存储器1026中来创建只读映像1050。由于规则库114可定义其自己的、由服务器102使用的数据对象，因此规则库114可以不捆绑于任何特定应用程序。结果，规则库114可同时由多个客户端应用程序122使用。在特定实施例中，只读映像1050包含规则库114的副本，而不带任何客户端特定信息。

客户端特定信息，如实际前置条件值和后置条件值，可存储在客户端特定信息块1052中。客户端特定信息块1052包括客户端特定信息1054和指针1056。客户端特定信息1054表示前置条件值、后置条件值、挂起规则116的快照，以及特定于客户端应用程序122的任何其它信息。指针1056指向与客户端特定信息1054相关联的只读映像1050。

在操作的一方面，当客户端应用程序122请求使用规则库114进行推理时，服务器102可确定该规则库114的只读映像1050是否已经存在于存储器1026中。如果否，则服务器102可将规则库114作为只读映像1050装载到存储器1026中。然后，推理引擎112可使用只读映像1050执行推理操作。如果客户端应用程序122请求使用已经作为只读映像1050装载到存储器1026中的规则库114进行推理，则推理引擎112可使用先前创建的只读映像1050执行推理操作。在推理期间，要为特定客户端应用程序122存储的任何值置于客户端特定信息块1052的客户端特定信息1054中。这样，即使当推理涉及不同输入值并且以不同次序执行规则116时，服务器102也可使用相同规则库114来执行多个客户端应用程序122的推理操作。

在一个实施例中，可以限制如上所述存储器1026的使用。例如，在特定实施例中，补充规则116、规则库114和规则集130可以不在多个推理引擎实例之间共享。在本实施例中，补充规则116、规则库114和规则集130的映像可以不由多个推理引擎实例使用。

虽然图10示出为了在多个客户端应用程序122之间共享规则库114而布置的存储器1026的一个例子，但是也可对存储器1026进行各种改变。例如，每个客户端特定信息块1052可存储在单独存储器结构中。另外，可以使用允许或不允许客户端应用程序122共享规则库114的其它存储器布置。

图11A到11D是示出根据本发明一个实施例的合并到统一规则库中的示例规则库组件的示例性方框图。具体地说，图11A到11C表示规则库组件1150a-1150c，而图11D表示统一规则库组件1150d。虽然图11A到11D可关于图1的系统100来描述，但是规则库组件1150也可与其它系统一起使用。

在图11A中，组件1150a表示规则1152。规则1152包含在形成域1156的一部分的规则集1154中。规则1152引用名称为Father(父亲)和Mother(母亲)的Person类的两个实例1158。

在图11B中，组件1150b表示包含在域1156中的Person类1160的部分声明。类1160包括称作Name(姓名)的字段1162的声明。组件1150b还包括Father实例1158a的声明。

在图11C中，组件1150c表示包含在域1156中的Person类1160的另一部分声明。类1160还包括称作Age(年龄)的字段1164的声明。组件1150c还包括Mother实例1158b的声明。

规则库构建器110可通过在多个阶段中执行活动来合并组件1150a-1150c。在一个实施例中，在第一阶段期间，规则库构建器110检查组件1150a-1150c，以收集定义数据对象和逻辑对象的类。在该阶段期间，规则库构建器110可创建一个或多个内部数据结构，其标识由组件1150定义的所有类。在第二阶段，规则库构建器110解析来自阶段一的内部数据结构，以帮助确保类声明之间的完全性和一致性。例如，如果类定义在名称为Brother(兄弟)的实例上操作的规则，则规则库构建器110可确保名称为Brother的实例由组件1150创建。在第三阶段期间，规则库构建器110可编译所解析的数据结构，以产生二进制规则库114。

在第一阶段期间，由规则库构建器110检查的组件1150均可定义类的一部分。在所示例子中，组件1150b和1150c定义Person类1160的不同部分。结果，在合并过程的第一阶段期间，规则库构建器110记录当分析每个组件1150时遇到的类声明。如果两个组件1150定义单个类的多个部分，则规则库构建器110将这些声明组合成单个类声明。这可在图11D中看出，其中图11D示出规则库1150d中的Person类1160的完全声明。

假定规则库构建器110检查组件1150b然后是组件1150c，规则库构建器110将访问组件1150b，并且确定组件1150b包含类1160的声明。规则库构建器110将检查包含所有先前遇到的声明的内部数据结构，确定类1160尚未由先前检查的组件1150声明，并且将类1160和字段1162添加到内部数据结构。规则库构建器110将继续至组件1150c，并且定位类1160的另一个声明。规则库构建器110可检查其内部数据结构，确定类1160已在先前检查的组件1150中声明，并且将字段1164添加到数据结构中的类1160。这将产生图11D所示的类1160的全面声明，其包括具有字段1162、1164的类1160的单个声明。以类似方式，规则库构建器110可定位在组件1150中遇到的实例1158的每个声明，并且形成如图11D所示的单个声明。

如上面关于图4所述，规则库114可在规则库114的多个级别(规则库级、域级、或规则集级)定义类。另外，具有相同名称的类可存在于规则库4中的不同级别。因此，在合并过程的阶段一期间创建的内部数据结构指定类的范围。例如，在图11D中，类1160被示出为存在于域1156中。如果在规则集1154中声明了另一个Person类，则结果规则库1150将包含作为规则集1154的一部分出现的另一个类定义。如果在规则库级别还声明了另一个Person类，则结果规则库1150d将在域1156的外部包含作为规则库1150d的一部分出现的另一个类定义。

在第一阶段期间，规则库构建器110可检测包括相同字段的类声明。在一些情况下，这些声明可能相互匹配，例如当多个组件1150声明Person类1160包括Name字段1162时。在其它情况下，这些声明可能相互冲突，并且规则库构建器110可能不能解决该冲突。例如，组件1150c可作为数字定义Age字段1164，而另一个组件1150作为字符串定义Age字段1164。这些声明相互冲突，并且规则库构建器110可产生错误消息。在其它情况下，这些声明可能相互冲突，但是可由规则库构建器110解决。作为例子，组件1150c可作为数字定义Age字段1164，而另一个组件1150作为限定于0与120之间的值的数字来定义Age字段1164。规则库构建器110可通过使用更受限的声明来解决该冲突，在本例中，更受限的声明将是带约束的声明。

在一个实施例中，当在合并过程的第一阶段期间访问组件1150时，规则库构建器110使用不定次序。结果，规则库构建器110可以在定义类1160的结构之前，处理使用该类1160的实例1158的规则1152。在特定实施例中，由规则库构建器110使用的内部数据结构帮助在规则库合并过程期间减少或消除前向声明的使用。

在创建统一规则库1150d之后，规则库构建器110解析规则库1150d。例如，规则库构建器110分析规则1152，以确定Father和Mother是否是已经声明的实例。规则库构建器110还确定与Father和Mother实例相关联的类是否包括Age字段。规则库构建器110还确定与Age字段相关联的数据类型是否适于在规则1152中执行的操作。在本例中，将Age的值与65的值相比较，从而规则库构建器110确定Age是否已被声明为数字数据类型。另外，规则库构建器110检查合并结果，并且确定所声明的每个方法是否具有关联实现。在本例中，方法可声明于一个规则库组件1150中，并且该组件1150的开发者假定另一个组件1150的开发者可提供方法实现。如果没有开发者定义要如何实现该方法，则规则库构建器110可产生错误消息。规则库构建器110可采取其它或附加步骤以解析统一规则库1150d。

在第三阶段期间，规则库构建器110编译经过解析的规则库1150d。在一个实施例中，规则库1150d采用禁止表达式具有任何副作用(side effect)的格式来定义。“副作用”发生于当推理引擎112正在对表达式进行求值时字段值发生改变的时候。例如，在图9B中，推理引擎112通过调用称作“GetAge”的函数来对表达式956进行求值。在本实施例中，推理引擎112不允许在执行“GetAge”函数时修改任何字段的值。为了帮助减少或消除规则库1150d中的副作用的存在，规则库构建器110识别方法是否返回值。如果方法返回值，则该方法不可包括任何改变字段值的步骤(用于该方法中的局部变量除外)。另外，返回值的方法不可调用改变字段值的第二方法(用于第二方法中的局部变量除外)。在另一个实施例中，规则库构建器110可允许规则库中的表达式具有副作用。

在规则库构建过程期间，规则库构建器110还可产生与最后定值字段相关联的表。如上所述，首次定值字段是应当仅被赋值一次的字段，而最后定值字段是可随着时间被赋予多个值的字段。在推理期间，最后定值字段的有用值典型地是未知的，直到触发或舍弃了可改变最后定值字段值的所有规则为止。在规则库构建过程期间，规则库构建器110可为最后定值字段生成一个表。该表可标识可能改变最后定值字段值的规则以及使用最后定值字段的最终值的规则。这样，推理引擎112可使用该表来触发或舍弃可能改变最后定值字段值的所有规则。一旦所有这些规则都被执行，则推理引擎112可触发或舍弃使用最后定值字段的最终值的规则。在特定实施例中，决策树规则可使用最后定值字段，而模式匹配规则不能。在本实施例中，在规则库构建期间构造的表将仅标识与最后定值字段相关联的决策树规则。

图12是示出根据本发明一个实施例的用于提供推理服务的示例方法1200的示例性流程图。虽然方法1200可关于图1的系统100来描述，但是也可使用其它系统。

服务器102在步骤1202接收识别一条或多条规则116的信息。例如，这可包括API 120接收具有一个或多个域131的二进制规则库114以及API 120接收域131选择。这还可包括API 120接收二进制规则库114的位置。该信息可来自任何适合源，例如试图调用推理引擎112的推理服务的客户端应用程序122。

服务器102在步骤1204识别与所标识的规则116相关联的任何前置条件和任何后置条件。例如，这可包括推理引擎112使用包含在域131中的信息来识别与该域131相关联的任何前置条件和后置条件。

服务器102在步骤1206接收所识别前置条件的值。例如，这可包括API120从调用推理引擎112的客户端应用程序122接收前置条件的值。推理引擎112可以逐个地从客户端应用程序122、作为XML文档中的组、通过初始化处理程序、或者采用其它适合方式接收前置条件值。

服务器102在步骤1208使用前置条件值来执行规则116。例如，这可包括推理引擎112触发、舍弃和挂起各规则116以试图将后置条件字段从未知状态求解为已知状态。这还可包括：在字段值发生改变之后，推理引擎112重新访问挂起规则116，以确定该改变是否允许推理引擎112触发或舍弃任何挂起规则116。这还可包括推理引擎112执行规则116的前向链接或后向链接。

服务器102在步骤1210返回任何后置条件的值。例如，这可包括推理引擎112将所识别后置条件的值传送到客户端应用程序122。推理引擎112可以逐个地向客户端应用程序122、作为XML文档中的组、通过改变处理程序、或者采用其它适合方式传送后置条件值。推理引擎112可以成功地确定所有后置条件、一些后置条件的值，或者没有确定任何后置条件的值。

虽然图12示出用于提供推理服务的方法1200的一个例子，但是可以对方法1200进行各种改变。例如，推理引擎112可以在接收实际规则116之前接收任何前置条件和后置条件的值。另外，推理引擎112可以在推理期间产生附加信息，如规则快照。另外，图12中的一些步骤可重叠。作为例子，推理引擎112可使用改变处理程序将后置条件值传送给客户端应用程序122。在这种情况下，可以在推理完成之前将后置条件值发送到客户端应用程序122。

图13是示出根据本发明一个实施例的用于规则库构建的示例方法1300的示例性流程图。虽然方法1300可关于图1的系统100来描述，但是也可使用其它系统。

服务器102在步骤1302接收标识一个或多个规则库组件的信息。例如，这可包括规则库构建器110接收源或二进制规则116、规则集130或规则库114。这还可包括规则库构建器110接收源或二进制规则116、规则集130或规则库114的位置。该信息可来自任何适合源，例如试图调用规则库构建器110的规则库构建服务的客户端应用程序122。

服务器102在步骤1304确定所接收的规则库组件是否具有适当的格式。例如，这可包括服务器102确定所接收的规则库组件是否包含在XML文档中。这还可包括服务器102确定所接收的规则库组件是否遵循采用规则定义语言定义的格式。如果否，则服务器102在步骤1306将所接收的规则库组件转换且重新格式化成适当的格式。例如，这可包括服务器102将规则库组件转换成XML文档，并且重新格式化规则库组件以使其遵循规则定义语言。

服务器102在步骤1308将规则库组件合并到统一规则库114中。例如，这可包括服务器102识别规则库组件中的类或其它数据对象的声明。这还可包括服务器102在内部数据结构中查找，以确定先前检查的规则库组件是否包括相同类或其它数据对象的另一个声明。如果否，则服务器102将声明添加到内部数据结构。否则，服务器102将来自当前声明的元素插入到包含在内部数据结构内的先前声明中。当服务器102完成生成内部数据结构时，服务器102可生成包含内部数据结构中的元素的统一规则库114。

服务器102在步骤1310编译统一规则库114。例如，这可包括服务器102将统一规则库114解析成各个结构，每个结构对应于采用规则定义语言定义的XML元素。这还可包括服务器102识别结构的各元素之间的链接、以创建结构之间的互连。这还可包括服务器102创建统一规则库114的二进制版本。

虽然图13示出用于规则库构建的方法1300的一个例子，但是也可对方法1300进行各种改变。例如，规则库构建器110只能接收具有适当格式的规则库组件，并且规则库构建器110无需转换规则库组件。另外，规则库构建器110可产生附加信息，如装载图和应用程序接口文档。

图14是示出根据本发明一个实施例的用于合并规则库组件的示例方法1400的示例性流程图。虽然方法1400可关于图1的系统100来描述，但是也可使用其它系统。

服务器102在步骤1402选择规则库组件。例如，这可包括规则库构建器110选择由客户端应用程序122提供的一个或多个规则库组件1150之一。服务器102在步骤1404将所选规则库组件解析成一个或多个规则库元素。例如，这可包括规则库构建器110将规则库组件1150分成各个声明，如类声明。

服务器102在步骤1406选择规则库元素。例如，这可包括规则库构建器110选择在所选规则库组件1150中首先出现的规则库元素。服务器102在步骤1408创建对应于所选规则库元素的标准元素。例如，这可包括规则库构建器110创建对应于规则库元素，如XML规则库元素的内部对象。

在服务器102创建对应标准元素之后，服务器102在步骤1410确定先前遇到的标准元素是否具有相同名称且处于相同规则库级别。例如，这可包括规则库构建器110分析包含先前遇到的标准元素的内部数据结构。这还可包括规则库构建器110确定先前遇到的标准元素是否具有相同名称，处于相同分级规则库级别，并且表示与所选标准元素具有相同类型的元素。如果这些条件中的任一个不为真，则服务器102在步骤1418将所选标准元素插入到内部数据结构中。例如，这可包括规则库构建器110根据标准元素所处的分级级别而将标准元素插入到内部数据结构的适当位置中。

如果在步骤1410满足所有三个条件，则两个单独的标准元素在相同规则库级别定义相同的规则库结构。服务器102在步骤1412确定两个标准元素的仅一个是否定义规则库逻辑。规则库逻辑可包括用来确定是否满足约束的表达式的定义，所声明方法的实现以及规则的实现。如果多于一个标准元素定义相同规则库结构的规则库逻辑，则服务器102在步骤1414产生错误。例如，这可包括规则库构建器110产生由消息处理程序捕获且传送到客户端应用程序122的错误消息。如果标准元素的仅一个定义相同规则库结构的规则库逻辑，则服务器102在步骤1416合并标准元素。例如，这可包括规则库构建器110将来自选定标准元素的部分插入到包含在内部数据结构内的标准元素中。

服务器102在步骤1420确定是否还有选定规则库组件的另外规则库元素有待处理。如果仍然存在另外的规则库元素，则服务器102返回到步骤1406，并且选择另一个规则库元素。否则，服务器102在步骤1422确定是否还有另外的规则库组件有待处理。如果存在另外的规则库组件，则服务器102返回到步骤1402，并且选择另一个规则库组件。

在处理了规则库组件之后，由服务器102创建的内部数据结构包含对应于这些规则库组件的各元素的标准元素。然后，服务器102可使用内部数据结构采取任何其它适合操作。例如，服务器102可在语义上分析对应于逻辑的内部数据结构，并且产生该逻辑的二进制指令。

虽然图14示出用于合并规则库组件的方法1400的一个例子，但是也可对方法1400进行各种改变。例如，规则库构建器110可一次接收一个规则库组件，从而规则库构建器110无需在步骤1402选择规则库组件。另外，规则库构建器110可以在将任何标准元素插入到内部数据结构中之前创建所有规则库组件的标准元素。另外，虽然规则库构建器110被描述为处理单个内部数据结构，但是也可以使用其它类型或数目的数据结构。此外，规则库构建器110可直接比较规则库XML元素与预先存在的标准元素，从而避免创建冗余的标准元素。

规则定义语言(RDL)

在一个实施例中，规则库使用规则定义语言来定义。规则定义语言定义形成规则库的一个或多个XML文档的结构和内容。具体地说，规则定义语言支持对象定义，如类、字段、方法和静态实例的定义，以及组织成域的约束和规则的定义。

虽然下面可以参照图1的系统100来描述规则定义语言，但是其它系统也可使用规则定义语言。另外，系统可以使用其它语言来定义规则库。

1.概述

一般而言，规则定义语言允许用户指定规则库114中的哪些对象，如类、实例、字段、域和规则集可作为公共对象与客户端应用程序122共享。缺省地，在规则库114中指定的其它对象可为该规则库114私有。对于共享字段，用户可指定每个字段是作为前置条件还是作为后置条件可被访问。

规则定义语言支持两种规则116，即模式匹配规则和决策树规则。在前向链接期间使用这两种规则，而在后向链接期间使用决策树规则。

规则定义语言支持多种不同数据类型，包括Number(数字)、Boolean(布尔型)、String(字符串)、Association instance(关联实例)、Set(集合)和InstanceReference(实例引用)。Number表示不区分整数和浮点值的通用数值数据类型。这些值可具有任意大小，并且Number的精度可使用精度标志来指定。值也可根据具体需要而舍入到最近相邻值。在一个实施例中，如果两个相邻值等距，则推理引擎112可总是舍入到最近偶数邻近值或最近奇数邻近值。Boolean表示TRUE(真)或FALSE(假)值。String表示Unicode字符序列，并且不区分大小写。

关联实例定义规则库实例之间的关系。例如，Person实例可以是另一个Person实例的配偶，或者Person实例可拥有Duck实例。规则定义语言可支持任何适合类型的关联，例如一对一、一对多、多对一以及多对多关联。作为特定例子，规则定义语言可支持Ownership(Owns和IsOwnedBy)关联、Managership(管理关系)(Manages(管理)和IsManagedBy(被管理))关联、Spousalship(配偶关系)(IsSpouse Of(是...的配偶))关联以及Siblingship(同胞关系)(IsSibling Of(是...的同胞))关联。例如，Duck实例的字段可定义与Person实例的IsOwnedBy关联，从而表示Duck由所标识的Person拥有。

一个实例中的实例引用表示对另一个实例的引用。例如，Duck类可定义对Person的实例引用，从而标识拥有给定Duck实例的Person实例。在本例中，实例引用担当指向其它实例的指针。如同其它数据类型一样，实例引用可以处于已知或未知状态。如果处于已知状态，则实例引用值可引用实例，或者为空。空值可以区别于未知值，因为未知值表示未知关系，而空值表示已知的不存在关系。

集合表示唯一元素的无序集合。这些元素可以为上述数据类型中的任一种。在特定实施例中，所有元素都应为相同数据类型。规则定义语言可以或不可以支持集合的集合。规则定义语言还可支持其它数据类型，例如列表、日期和时间。

规则定义语言可将要由推理引擎112作出的决策分类成规则前提或约束表达式。这有助于将决策作出限于更小、更好限定的上下文。这还有助于鼓励开发者创建规则库114或规则库114的一部分以编写更干净、更原子的规则。这还可减少或消除在规则库114中使用IF-THEN(如果-则)规则。规则定义语言还可禁止表达式具有任何副作用。

规则定义语言还可限制指针和动态分配对象的使用。例如，规则定义语言可将指针的使用限制于关联实例中的字段和用于模式匹配规则中的绑定变量中的字段。这有助于在推理开始和使用指针之前帮助分析规则库114中的规则116。在特定实施例中，规则库114的分析可发生于规则库构建器110正在构建规则库114时，而不是在推理开始之前由推理引擎112进行。在另一个实施例中，指针的使用可以不受到限制，或者可以采用其它方式进行限制。

另外，为了允许第三方厂商向规则库114增加功能性和附加信息，第三方厂商可以向他们在规则库114中定义和使用的元素和字段添加前缀。在某些实施例中，前缀可以是XML命名空间前缀。推理引擎112可处理采用规则定义语言定义的任何元素和字段，并且忽略任何其它元素和字段，如具有前缀的元素和字段。

规则定义语言的下面描述假定规则库114包括一个或多个XML文档。在下面描述中，XML文档的内容使用巴克斯-诺尔形式(Backus-Naur Form，BNF)表示法来描述，并且规则库逻辑的例子使用中缀表示法。这仅是为了示例说明的目的。也可使用用来描述XML文档内容和例子的其它表示法。另外，在其它实施例中，规则库114可包括其它类型的信息并且不限于XML文档。

2.元素属性

规则定义语言支持以下属性：

AbortMsg_Attrib

　　  ::＝abort_msg＝″＜StringVal＞″//无缺省值

　　AppShared_Attrib
				
				<dp n="d35"/>
　　  ::＝appshared＝″true″

　　  ::＝appshared＝″false″           //缺省值

　　CaseSensitivity_Attrib

　　  ::＝case_snes＝″true″

　　  ::＝case_snes＝″fasle″           //缺省值

　　Collection Attrib

　　  ::＝coll_type＝″set″

　　  ::＝coll_type＝″none″            //缺省值

　　DataType_Attrib                    //无缺省值

　　  ::＝type＝″number″

　　  ::＝type＝″boolean″

　　  ::＝type＝″string″

　　  ::＝type＝″inst_ref″

　　Enabled_Attrib

　　  ::＝enabled＝″true″              //缺省值

　　  ::＝enabled＝″false″

　　Intrinsic_Attrib

　　  ::＝intrinsic＝″true″

　　  ::＝intrinsic＝″false″           //缺省值

　　LocTag_Attrib

　　  ::＝loc_tag＝″＜String Val＞″      //无缺省值

　　Name_Attrib

　　  ::＝name＝″＜Identifier＞″          //无缺省值

　　ParamIOType_Attrib

　　  ::＝iotype＝″in″                 //缺省值

　　  ::＝iotype＝″out″

　　PMOptions_Attrib

　　  ::＝options＝″＜Options＞″         //缺省值(least-recent(最不近)，多次触发)

　　Post_Attrib

　　  ::＝post_type＝″conditional″

　　  ::＝post_type＝″unconditional″   //缺省值
				
				<dp n="d36"/>
　　Precision_Attrib

　　  ::＝precision＝″＜IntegerVal＞″    //缺省值：“0”

　　Priority_Attrib

　　  ::＝priority＝″＜IntegerVal＞″     //缺省值：“0”

　　Resolution_Attrib

　　  ::＝res_type＝″first_valued″     //缺省值

　　  ::＝res_type＝″final_valued″

　　ResumeVal_Attrib

　　  ::＝resume_val＝″＜Value＞″        //无缺省值

　　Value_Attrib

　　  ::＝value＝″＜Value＞″             //无缺省值

后面的章节引用这些属性。在很多情况下，该列表定义属性可具有的实际值，如TRUE或FALSE。在其它情况下，该列表反映符号值，在这种情况下，符号值加有尖括号(<>)，并且下面将对其进行更全面的说明。

3.根元素

该元素是XML文档的根元素，并且定义规则库114的总体结构。它具有以下格式：

Rulebase_Element

　　  ::＝(′rulebase′RB_Attribs+)

　　    RB_Section*

　　Rulebase_Attribs

　　  ::＝Name_Attrib                    //必需

　　  ::＝LocTag_Attrib                   //可选

　　Rulebase_Section

　　  ::＝InitMethodDef_Element

　　  ::＝Assoc_Element

　　  ::＝ConstraintSet_Element

　　  ::＝ExternalLib_Element

　　  ::＝Class_Element

　　  ::＝Domain_Element

Name_Attrib(名称属性)指定规则库114的名称，如字母数字字符串。推理引擎112可在错误和跟踪消息中使用该名称。Rulebase(规则库)_Section(部分)包括零个或更多子元素，并且这些子元素定义规则库114内暴露于全局范围的对象。例如，InitMethodDef_Element定义规则库级初始化方法，Assoc_Element定义规则库级类之间的规则库级关系，并且ConstraintSet_Element定义用于约束对规则库级字段的赋值的规则库级方法集合。ExternalLib_Element定义可从规则库114调用的外部库，并且Class(类)_Element(元素)定义字段、方法和静态实例的规则库级类。Domain(域)_Element定义规则库级域资源。

所有这些子元素可以是可选的，因为如上文和下文更详细所述，规则定义语言支持合并不完全规则库的片断，以形成完全规则库114。另外，如下所述，每个子元素可指定Name_Attrib(属性)。这些名称在规则库级别可以是唯一的，但是在更低级别可被覆盖。如果规则库114在给定级别定义具有相同名称的对象，则规则库构建器110可以在合并过程期间将这些对象合并到单个规则库对象中。

4.InitMethodDef_Element

该元素定义用于初始化规则库114中的对象的方法，并且具有以下格式：

InitMethodDef_Element

  ::＝(′init_method′InitMethodDef_Attribs+)

     [InitMethodBody_Element]

InitMethodDef_Attribs

  ::＝Name_Attrib                    //必需

  ::＝LocTag_Attrib                  //可选

InitMethodDef_Element定义初始化级别特定字段和外部库的方法逻辑。

例如，该元素可初始化随后由规则和约束引用的各个字段。当首先装载该级别的资源时，推理引擎112调用该方法。在一个实施例中，推理引擎112可调用该方法一次。当在给定级别存在多个InitMethodDef_Element时，则推理引擎112可以任何适合次序调用这些元素。在该元素中定义的初始化方法可以不接受任何参数，并且不返回任何值。这些方法可以自由地调用其它方法，并且访问其范围级别内的任意和所有对象。在一个实施例中，这些方法可能不能启动推理或者试图读取未知状态下的字段。在本实施例中，当检测到任何这些操作时，推理引擎112可用错误消息立即中止推理。

该元素可在规则库114中的若干不同级别指定。例如，它可以在规则库级别、域级别和规则集级别指定。在给定级别，可以存在该元素的多个指定，但是每一个应当具有不同的名称。另外，多个子规则库可在相同规则库级别贡献InitMethodDef_Element。

在一个实施例中，字段初始化受支配于字段约束。该方法应敏感于这些约束以及该约束所依赖的字段。例如，字段约束可依赖于字段MaximumAge(最大年龄)，从而初始化方法应帮助确保在根据该约束设置任何字段之前，该字段已被初始化。

样例规则库114可如下定义处于规则库级别的InitMethodDef_Element：

<init_method_name＝″RulebaseConstantsInitializer″>

  <method_body>

   <！[CDATA[

   constants.max_age＝120

   constant.adult_age＝21

   constant.ValidSymptoms＝set(″symptom1″，″symptom2″，″symptom3″)

   ]]>

  </method_body>

</init_method>

该方法初始化以后由规则和约束使用的各个常数字段。

5.Assoc_Element

该元素定义字段之间的关系，并且具有以下格式：

Assoc_Element

　　  ::＝(′assoc′ Assoc_Attribs+)

　　     FieldRef_Element       //关联角色1

　　     FieldRef_Element       //关联角色2

　　Assoc_Attribs

　　 ::＝Name_Attrib            //关联名称-必需

　　 ::＝LocTag_Attrib          //可选

　　FieldRef_Element

　　 ::＝(′field_ref′FieldRef_Attribs+)

　　     IdentifierSpec         //字段的类
				
				<dp n="d39"/>
　　FieldRef_Attribs

　　  ::＝Name_Attrib      //字段名称-必需

　　  ::＝LocTag_Attrib    //可选

该元素可以在规则库114中的若干不同级别指定。例如，它可在规则库级别、域级别和规则集级别指定。在一个实施例中，关联具有反映其意义的名称。例如，Ownership关联可能定义人如何拥有鸭子，Managership关联可能定义人如何管理其它人，并且Spousalship关联可能定义人之间的配偶关系。

Assoc_Element指定其成员字段为FieldRef_Element。这些子元素的每一个指定字段名称和拥有或继承该字段的类。在其各自的类中，这些字段的每一个可以采用实例引用数据类型来声明(参见下述DataTypeInstRef_Element)。该指定字段可以属于相同类或不同类。例如，用户可以定义Duck类的IsOwnedBy字段与Person类的Owns字段之间的关联。作为另一个例子，用户可以定义Person类的IsManagedBy字段与Person类的Manages字段之间的关联。用户还可为关联角色指定相同的字段，例如Person类的IsSpouseOf字段用作两个关联角色。

在一个实施例中，关联的多样性(一对一、一对多、多对一、多对多)可根据指定字段是否是集合而变化。例如，如果Person类的Owns字段是集合，但是Duck类的IsOwnedby字段不是集合，则关联是Person和Duck之间的一对多关系。

Assoc_Element元素可关联对象的超类。例如，它可关联Person和Bird(鸟)，并且推理引擎112可以以多态方式(polymorphically)将该关系解释为Person与任何种类的Bird(Duck、Vulture(秃鹰)等)之间的关系。

在特定实施例中，Assoc_Element指定其类处于与其本身相同的规则库级别(全局、域、规则集)的字段。在本实施例中，域级关联只可引用域级类的字段，而不可引用全局级类的字段。

样例规则库114可如下定义处于规则库级别的两个Assoc_Element：

<assoc name＝″Ownership″>

  <field_ref name＝″Owns″>

    <identifier name＝″Person″/>

  </field_ref>

  <field_ref name＝″IsOwnedBy″>

    <identifier name＝″Duck″/>

  </field_ref>

</assoc>

<assoc name＝″Siblingship″>

  <field_ref name＝″IsSiblingOf″>

     <identifier name＝″Person″/>

  </field_ref>

  <field_ref name＝″IsSiblingOf″>

    <identifier name＝″Person″/>

  </field_ref>

</assoc>

另外，规则库114可定义关联字段。这些字段对维护特定于关联而非特定于关联的各个成员的信息可能是又用的。例如，Spousalship关联可能具有DateOfMarriage(结婚日期)字段。为了使用关联字段，推理引擎112可维护关联实例，并且其它实例可访问这些关联实例。例如，Person实例可能需要确定他/她的结婚日期。这可采用诸如以下的内部方法来发生：

marriage_date＝@getAssocValue(Father.spouse，

spousalship.marriage_date)

@setAssocValue(Father..spouse，Spousalship.marriage_date，20010708)其中第一自变量(argument)指定关联所涉及的实例，而第二自变量表示相关关联字段。

在另一个实施例中，关联可视作将其字段“借”给参与实例。例如，Person类可根据Person是Spousalship关联中的角色类的事实而继承marriage_date(结婚日期)字段。在这种情况下，上面例子可能被记录为：

marriage_date＝Father.marriage_date

Father.marriage_date＝20010708

在这种方法下，关联实例的字段名称可以与Person类(及其祖先类)的字段名称重叠。同样地，Person类(及其祖先类)可能不能定义用作不同关联实例的Spousalship角色的两个字段。此外，如果Person用作多个不同关联中的类角色，则关联可能需要采用不同字段名称。可选的特殊前缀可用于关联字段，以避免这些问题中的一些，例如：

marriage_date＝Father.Spousalship：marriage_date

Father.Spousalship：marriage_date＝20010708

6.ConstraintSet_Element

该元素指定约束定义的集合，并且具有以下格式：

ConstraintSet_Element

　　 ::＝(′ConstraintSet_Element′ConstraintSet_Attribs+)

　　     ConstraintSet_Element*

　　ConstraintSet_Attribs

　　 ::＝Name_Attrib      //必需

　　 ::＝LocTag_Attrib    //可选

　　Constraint_Element

　　 ::＝(′Constraint′Constraint_Attribs+)

　　     GeneralExpr      //Boolean表达式

　　Constraint_Attribs

　　     ::＝Name_Attrib      //必需

　　     ::＝LocTag_Attrib    //可选

ConstraintSet_Element指定用于限制如何可以赋值给字段的准则。推理引擎112在赋值给目标字段之前可以对约束进行求值。这些约束可以通过字段声明(使用FieldDcl_Element)或通过静态实例字段修饰符(使用StaticInstDef_Element)与字段相关联。每个约束的GeneralExpr可表示Boolean表达式。该表达式引用内部标识符(candidat_value(候选值))作为对字段建议新值的符号引用。当对表达式进行求值时，推理引擎112可用内部标识符替换任何符号引用。表达式值表示候选值是否满足约束。如果表达式值为真，则推理引擎112可允许继续赋值。否则，推理引擎112可根据字段声明(或字段修饰符)指定来采取操作。

表达式可调用方法，并且访问其范围级别内的任意对象。在一个实施例中，表达式不可试图读取处于未知状态的字段或者产生任何副作用。在本实施例中，当检测到这些操作中的任一操作时，推理引擎112可用错误消息立即中止推理。

该元素可定义多个约束，并且这些约束的每一个可以在约束集合内具有唯一名称。该元素也可在规则库114中的若干不同级别指定。例如，它可在规则库级别、域级别和规则集级别指定。推理引擎112可以代表若干不同字段，如相同数据类型的字段，对相同约束进行求值。

样例规则库114可如下定义处于规则库级别的两个ConstraintSet_Element：

<constraint_set name＝″ThingConstraints″>

 <constraint name＝″CheckAgeConstraints″>

  <！[CDATA[

   @candidate_value>＝0 and @candidate_value<＝max_age

  ]]>

 </constraint>

</constraint_set>

<constraint_set name＝″PersonConstraints″>

 <constraint name＝″CheckSympConstraints″>

   <！[CDATA[

    @candidate_value<＝ValidSymptoms

   ]]>

 </constraint>

</constraint_set>

7.ExternalLib_Element

该元素允许用户采用由一个或多个“外部”库，如采用Java或C++编码的库提供的功能性补充规则定义语言功能性。这些用户然后可以随同规则库114一起发行外部库。ExternalLib_Element向外部库提供入口。从规则库114的角度，外部库可作为提供带有输入参数、输出参数和返回值的方法的“黑盒”出现。规则库114可以如同调用在规则库114自身中定义的方法一样调用外部库中的方法。推理引擎112可以负责将调用映射到目标环境。ExternalLib_Element的定义可以要求指定语言特定、平台特定、或环境特定的设置。结果，推理引擎112可以或不可以需要包括一些目标特定代码。

8.Class_Element

该元素定义字段、方法和静态实例的类。它具有以下格式：

Class_Element

　　  ::＝(′class′Class_Attribs+)

　　     Class_Item*

　　Class_Attribs

　　  ::＝Name_Attrib      //必需

　　  ::＝LocTag_Attrib    //可选

　　Class_Item

　　  ::＝Parent_Element

　　  ::＝FieldDcl_Element

　　  ::＝ClassMethodDef_Element

　　  ::＝StaticInstDef_Element

　　Parent_Element

　　  ::＝(′parent′[LocTag_Attrib])

　　      IdentifierSpec   //父类

该元素可在规则库114中的若干不同级别指定。例如，它可在规则库级别、域级别和规则集级别指定。一些或所有子元素可指定Name_Attrib。除了方法重载之外，这些名称在类级别可以是唯一的，但是可以覆盖处于更高级别的名称并且在更低级别被覆盖。另外，除了方法重载(overload)之外，如果类定义具有相同名称的对象，则规则库构建器110可以在合并过程期间将这些对象合并成单个规则库对象。Class_Element可以可选地指定父Class_Element，从而类可组织成继承分级结构。在一个实施例中，类可以具有最多一个父类。在特定实施例中，如果类具有父，则父类和子类处于相同规则集级别(全局、域、规则集)。在本实施例中，域级类将从另一个域级类派生，并且不能从全局级类派生。

在特定实施例中，字段和方法处于实例级别而非类级别，并且字段和方法处于公共而非私有或保护访问级别。另外，在特定实施例中，叶子而非父类可被实例化。可以或可以不存在对类包含的支持。

样例规则库114可以定义处于规则库级别的若干Class_Element，例如：

<class name＝″Duck″>

  <parent>

    <identifier name＝″Thing″/>

  </parent>

  <field name＝″IsOwnedBy″>

    <datatype coll_type＝″none″type＝″inst_ref″>

      <identifier name＝″Person″/>

    </datatype>

  </field>

</class>

8.1FieldDcl_Element

Class_Element的该元素定义类数据对象，并且具有以下格式：

FieldDcl_Element

　　  ::＝(′field′FieldDcl_Attribs+)

　　     DataType_Element

　　     [ConstrainedBy_Element]

　　FieldDcl_Attribs

　　  ::＝Name_Attrib             //必需

　　  ::＝ResolutionType_Attrib   //可选

　　  ::＝LocTag_Attrib           //可选

　　ConstrainedBy_Element

　　  ::＝(′constrained_by′[LocTag_Attrib])

　　     ConstrainerList_Element

　　     [ConstraintViolation_Element]

　　ConstrainerList_Element

　　  ::＝(′constrainer_list′[LocTag_Attrib])

　　     IdentifierSpec*          //适用的约束

　　ConstraintViolation_Element

　　  ::＝(′constraint_violation′[LocTag_Attrib])

　　     ConstraintViolation_Option

　　ConstraintViolation_Option
				
				<dp n="d45"/>
　　  ::＝ConstraintAbort_Element

　　  ::＝ConstraintResume_Element

　　ConstraintAbort_Element

　　  ::＝(′constraint_abort′ConstraintAbort_Attribs*)

　　ConstraintAbort_Attribs

　　  ::＝LocTag_Attrib      //可选

　　  ::＝AbortMsg_Attrib    //可选

　　ConstraintResume_Element

　　  ::＝(′constraint_resume′ConstraintResume_Attribs*)

　　ConstraintResume_Attribs

　　  ::＝LocTag_Attrib      //可选

　　  ::＝ResumeVal_Attrib   //可选

FieldDcl_Element可包括字段求解类型，其是可以可选地指定“求解类型”的字段。求解类型应用于推理引擎112在处理决策树规则时的行为，并且可被指定为“first_valued(首次定值)”(缺省值)或“final_valued(最后定值)”。该设置确定推理引擎112是否假定字段的首次值为其求解值，或者推理引擎112是否预期字段在得到其求解值的过程中可能被赋予中间值。例如，Age字段将典型地是“first_valued”字段，而SetOfResults(结果集合)字段可能是“final_valued”字段。

FieldDcl_Element还可以可选地指定字段值分配应受到约束。在赋值给字段之前，推理引擎112可以以由ConstrainerList(约束列表)_Element指定的次序对一个或多个约束进行求值。如果任何约束求值为Boolean FALSE值，则推理引擎112可以根据ConstraintViolation(约束违例)_Element执行违例操作。如果ConstraintViolation_Element指定ConstraintAbort(约束中止)_Element，推理引擎112可以中止推理。如果那个元素指定AbortMsg_Attrib，则属性值可以是错误消息文本。否则，错误消息可以反映缺省文本。如果ConstraintViolation_Element指定ConstraintResume(约束恢复)_Element，则推理引擎112可以恢复推理。如果那个元素指定ResumeVal_Attrib，则推理引擎112可以用属性值替代字段当前值。否则，该字段可以保持其当前值。如果没有ConstraintViolation_Element，则推理引擎112可以缺省错误消息中止推理。在FieldDcl_Element级别指定的约束可应用于字段类的所有实例。用户还可以指定实例特定约束。

来自样例规则库114的样例字段声明可以是：

<field name＝″Symptoms″>

  <datatype coll_type＝″set″type＝″string″/>

  <constrained_by>

    <constrainer_list>

      <identifier name＝″CheckSympConstraints″/>

    </constrainer_list>

    <constraint_violation>

      <constraint_abort abort_msg＝″Invalid symptoms

    specified″/>

    </constraint_violation>

  </constrained_by>

</field>

8.2 ClassMethodDef_Element

该Class_Element元素定义类方法对象，并且具有以下格式：

ClassMethodDef_Element

　　  ::＝(′method′ ClassMethodDef_Attribs+)

　　      [DataType_Element]    //方法返回类型

　　      [ClassMethodParams]

　　      [ClassMethodBody_Element]

　　ClassMethodDef_Attribs

　　  ::＝Name_Attrib           //必需

　　  ::＝LocTag_Attrib         //可选

　　ClassMethodParams

　　  ::＝ClassParam_Element

　　  ::＝ClassParamList_Element

　　ClassParam_Element

　　  ::＝(′param′ClassParamAttribs+)

　　      DataType_Element
				
				<dp n="d47"/>
　　ClassParamAttribs

　　  ::＝Name_Attrib          //必需

　　  ::＝ParamIOType_Attrib   //可选

　　  ::＝LocTag_Attrib        //可选

　　ClassParamList_Element

　　  ::＝(′method_params′[LocTag_Attrib])

　　      ClassParam_Element*

　　ClassMethodBody_Element

　　  ::＝(′method_body′[LocTag_Attrib])

　　      Statement*

方法可以可选地接受任何数目的具有任何数据类型的变量，并且该方法可以将每个参数归类为输入(“in”)参数或输出(“out”)参数。在一个实施例中，参数可以缺省地是输入参数或输出参数。在特定实施例中，参数不可既是输入参数又是输出参数。规则定义语言可以支持方法重载，从而类可以定义多个具有相同名称的方法，只要其参数表是可区分的即可。该区分可以不考虑ClassParamAttribs(类参数属性-如ParamIOType_Attrib)或数字精度。方法可以可选地返回一个或多个任何数据类型的值。如果方法返回值，则服务器102可以将其归类为函数方法。否则，服务器102可以将其归类为过程方法。服务器102对函数方法施加可以不对过程方法施加的限制。这是因为函数方法是表达式，并且表达式可以不具有任何负作用。因此，服务器102可以禁止函数方法支持输出参数、赋值给字段、调用过程方法、或者创建或删除动态实例。

如果没有指定ClassMethodBody(类方法主体)_Element，则服务器102可以假定另一个规则库114将要定义方法实现，并且在推理之前该另一个规则库114将与当前规则库114合并。

来自样例规则库114的样例方法定义可以是：

<method name＝″Has1stSymptomButNot2ndOne″>

  <datatype coll_type＝″none″type＝″boolean″/>

  <method_params>

    <param name＝″symp1″iotype＝″in″>

      <datatype coll_type＝″none″type＝″string/>

     </param>

     <param name＝″symp2″iotype＝″in″>

        <datatype coll_type＝″none″type＝″string″/>

     </param>

  </method_params>

  <method_body>

  <！[CDATA[

  return Symptoms.@Set_DoesIncludeVal(symp1)

    and not Symptoms.@set_DoesIncludeVal(symp2)

  ]]>

  </method_body>

</method>

8.3 StaticInstDef_Element

Class_Element的该元素定义类静态实例对象，并且具有以下格式：

StaticInstDef_Element

　　  ::＝(′instance′StaticInst_Attribs+)

　　    [FieldModifiers_Element]

　　StaticInst_Attribs

　　  ::＝Name_Attrib      //必需

　　  ::＝LocTag_Attrib    //可选

　　FieldModifiers_Element

　　  ::＝(′field_modifiers′[LocTag_Attrib])

　　     FieldModifier_Element*

　　FieldModifier_Element

　　  ::＝(′field_modifier′FieldModifier_Attribs+)

　　    [ConstrainedBy_Element]

　　    [LastChanceValue_Element]

　　FieldModifier_Attribs

　　  ::＝Name_Attrib      //必需

　　  ::＝LocTag_Attrib    //可选
				
				<dp n="d49"/>
　　LastChanceValue_Element

　　  ::＝(′lastchance_value′[LocTag_Attrib])

　　      lastchancevalue

　　lastchancevalue

　　  ::＝LiteralConstant_Element

　　  ::＝UnaryExpr        //具有LiteralConstant_Element

　　  ::＝SetConstant_Element

　　  ::＝IdentifierSpec   //实例名称

当推理引擎112装载实例类时，它可以创建静态实例，并且当它卸载实例类时，它可以删除该实例。在一个实施例中，规则库逻辑可能不能显式创建或删除静态实例。该元素可以可选地指定FieldModifiers(字段修饰符)_Element，其指定实例特定字段特征，如最后机会值和约束。FieldModifiers_Element的Name_Attrib表示受影响的实例字段。该名称可以标识由实例类声明或继承的字段。

LastChanceValue(最后机会值)_Element指定字段的最后机会值。对于实例引用数据类型，最后机会值可以是另一个静态实例或者一组这样的实例的标识符。对于另一种数据类型的字段，该值可以是字面常量、集合常量或者字面常量上的一元操作符。在后者情况下，字面常量可以是数字或布尔常量。推理引擎112可以在涉及决策树规则的特定完善定义情形中应用最后机会值，从而最后机会值的静态实例定义本身不可保证推理引擎112将会应用它们。

约束子元素指定字段赋值应受到约束。有关约束的进一步信息可以在上面FieldDcl_Element章节内的ConstrainedBy_Element描述中找到。在StaticInstDef_Element级别指定的约束可以仅应用于那个实例。例如，用户可为Father.Age指定与Mother.Age不同的约束。用户还可指定应用于类的所有实例的类级约束。如果对于给定字段用户指定了这两个级别的约束，则推理引擎112可以在实例特定约束之前应用类级约束。

来自示例规则库114的样例StaticInstDef_Element可以是：

<instance name＝″CurrentPatient″>

  <field_modifiers>

    <field_modifier name＝″age″>

      <lastchance_value>

         <literal_constant value＝″55″/>

      </lastchance_value>

    </field_modifier>

  </field_modifiers>

</instance>

9.Domain_Element

该元素定义规则库级域资源，并且具有以下格式：

Domain_Element

　　  ::＝(′domain′Domain_Attribs+)

　　      Domain_Items*

　　Domain_Attribs

　　  ::＝Name_Attrib         //必需

　　  ::＝AppShared_Attrib    //可选

　　  ::＝LocTag_Attrib       //可选

　　Domain_Items

　　  ::＝DomainGoal_Element

　　  ::＝DomainAppSharedFlds_Element

　　  ::＝InitMethodDef_Element

　　  ::＝Assoc_Element

　　  ::＝ConstraintSet_Element

　　  ::＝Class_Element

　　  ::＝Ruleset_Element

该元素可以可选地指定域可通过使用AppShared(应用程序共享)_Attrib字段由客户端应用程序122装载。否则，域可使用dmn_push()内部方法从规则库逻辑装载。规则库114可以与客户端应用程序122共享至少一个域，但是它可与客户端应用程序122共享多个域。

大多数子元素可以指定Name_Attrib。这些名称在域级别可以是唯一的，但是可以覆盖处于更高级别的名称，并且在更低级别被覆盖。如果域在给定级别定义具有相同名称的对象，则规则库构建器110可以在合并过程期间将这些对象合并成单个规则库对象。

若干域子元素，如InitMethodDef_Element、Assoc_Element、ConstraintSet_Element、以及Class_Element可以与先前描述的规则库级子元素相同。其它子元素，如DomainGoal(域目标)_Element、DomainAppSharedFlds(域应用程序共享字段)_Element、以及Ruleset_Element特定于域，并且在下面进行描述。

9.1 DomainGoal_Element

Domain_Element的该元素指定域的目标字段，并且具有以下格式：

DomainGoal_Element

  ::＝(′domain_goal′[LocTag_Attrib])

      IdentifierSpec     //后向链接目标(字段)

如果Domain_Element指定DomainGoal_Element，则推理引擎112可以后向链接域的规则，以便求解目标字段。否则，推理引擎112可以前向链接域的规则。

来自样例规则库114的样例DomainGoal_Element可以是：

<domain name＝″PerformConclusionAnalysis″appshared＝″true″>

<domain_goal>

<identifier name＝″OverallConclusion″/>

</domain_goal>

...

</domain>

9.2 DomainAppSharedFlds_Element

Domain_Element的该元素指定要与客户端应用程序122共享的字段，并且具有以下格式：

DomainAppSharedFlds_Element

　　  ::＝(′appshared_fields′[LocTag_Attrib])

　　    [DomainPreConditionList_Element]

　　    [DomainPostConditionList_Element]

　　DomainPreConditionList_Element

　　  ::＝(′precondition_list′[LocTag_Attrib])

　　     ConditionIistItem*
				
				<dp n="d52"/>
　　DomainPostConditionList_Element

　　  ::＝(′postcondition_list′[LocTag_Attrib])

　　      ConditionListItem*

　　ConditionListItem        //限于全局字段

　　  ::＝IdentifierSpec

　　  ::＝FieldRef_Element

如果域包括DomainAppSharedFlds_Element子元素，则域本身可以自动地与客户端应用程序122共享。DomainAppSharedFlds_Element指定两个子元素：一个用于推理前置条件，而另一个用于推理后置条件。每个子元素指定零个或更多规则库级字段。在一个实施例中，该列表可以指定规则库级别而非域级字段。如果为两个列表都指定相同字段，则字段可以假定为前置条件字段。

DomainPreConditionList(域前置条件列表)_Element标识客户端应用程序122既可读又可写的字段。DomainPostConditionList(域后置条件列表)_Element标识对于客户端应用程序122是只读的字段。推理引擎112可以拒绝客户端应用程序122不正确访问字段的尝试。在一个实施例中，不同规则库域由于其输入和输出可以不同，而可指定不同的DomainAppSharedFlds_Element。

来自样例规则库114的样例DomainAppSharedFlds_Element可以是：

<domain name＝″PerformConclusionAnalysis″appshared＝″true″>

...

<appshared_fields>

  <precondition_List>

     <identifier name＝″Fact1″/>

     <identifier name＝″Fact2″/>

     <identifier name＝″Fact3″/>

     <identifier name＝″Fact4″/>

  </precondition_List>

  <postcondition_List>

    <identifier name＝″OverallConclusion″/>

  </postcondition_List>

</appshared_fields>

...

</domain>

上面例子示出四个前置条件字段和一个后置条件字段的定义。对于每个字段，仅指定了一个标识符，因为仅存在一个为这些字段定义的类实例(从而不存在引用歧义)。一般而言，共享字段可以特定于单个静态实例，以便例如域可以共享Father.Age而非Mother.Age。如果域需要共享多个实例的字段，则DomainAppSharedFlds_Element可以以每个实例一个的方式指定多个字段，例如：

<precondition_List>

  <identifier_path>

    <identifier name＝″Father″/>

    <identifier name＝″Age″/>

  </identifier_path>

  <identifier_path>

    <identifier name＝″Mother″/>

    <identifier name＝″Age″/>

  </identifier_path>

</precondition_List>

域还可选择共享类的所有实例的字段。为此，DomainAppSharedFlds_Element使用FieldRef_Element来指定这些字段，例如：

<precondition_List>

  <field_ref name＝″Age″>

    <identifier name＝″Person″/>

  </field_ref>

</precondition_List>

该例子指定Age字段应为Person的所有实例共享。当与动态实例一起使用时，这可以是有用的，其中逐项列举给定字段的所有实例可能是不实际或不可能的。

FieldRef_Element可以指定父类以及叶子类，例如：

<precondition_List>

  <field_ref name＝″Age″>

    <identifier name＝″Bird″/>

  </field_ref>

</precondition_List>

该形式是从那个父类派生的所有叶子类的简写形式，例如：

<precondition_List>

  <field_ref name＝″Age″>

     <identifier name＝″Duck″/>

  </field_ref>

  <field_ref name＝″Age″>

    <identifier name＝″Vulture″/>

  </field_ref>

  <field_ref name＝″Age″>

    <identifier name＝″Robin″/>

  </field_ref>

</precondition_List>

9.3 Ruleset_Element

Domain_Element的该元素定义规则集级资源，并且具有以下格式：

Ruleset_Element

　　 ::＝(′ruleset′Ruleset_Attribs+)

　　     RuleSet_Item*

　　Ruleset_Attribs

　　 ::＝Name_Attrib      //必需

　　 ::＝Post_Attrib      //可选

　　 ::＝AppShared_Attrib //可选

　　 ::＝LocTag_Attrib    //可选

　　RulesetItem

　　 ::＝InitMethodDef_Element

　　 ::＝Assoc_Element

　　 ::＝ConstraintSet_Element

　　 ::＝Class_Element
				
				<dp n="d55"/>
　　::＝Rule_Element

该元素可以使用Post_Attrib字段可选地指定推理引擎112应当根据客户端应用程序122或规则库逻辑的控制，有条件地将规则集的规则张贴(post)到域的规则议程(agenda)。缺省地，当装载规则集时，推理引擎112可以无条件地将规则张贴到议程。该元素也可使用AppShared_Attrib字段可选地指定规则集可访问客户端应用程序122。否则，规则集仅可访问规则库逻辑。

域可以与客户端应用程序122共享多个规则集。如果域共享任何规则集，则域本身也可自动地与客户端应用程序122共享。如果规则集与应用程序共享，则Post_Attrib可以设为“conditional(有条件)”。否则，服务器102可以用语法错误拒绝该元素。如果规则集不与客户端应用程序122共享，则PostS_Attrib可以设为“conditional”或“unconditional(无条件)”。

所有子元素可以指定Name_Attrib。这些名称在规则集级别可以是唯一的，但是可以覆盖处于更高级别的名称，并且可以在更低级别被覆盖。如果规则集在给定级别定义具有相同名称的对象，则规则库构建器110可以在合并过程期间将这些对象合并成单个规则库对象。

若干规则集子元素，如InitMethodDef_Element、Assoc_Element、ConstraintSet_Element、以及Class_Element与上面描述的规则库级子元素相同。Rule_Element可以特定于规则集，并且在下面进行描述。

样例规则库114中的样例Ruleset_Element可以是：

<domain name＝″PerformConclusionAnalysis″appshared＝″true″>

  ...

  <ruleset name＝″ConclusionAnalysis″>

    ...

  </ruleset>

  ...

</domain>

10.Rule_Element

该元素定义规则，并且具有以下格式：

Rule_Element

　　  ::＝(′rule′Rule_Attribs+)
				
				<dp n="d56"/>
　　    RuleBody

　　Rule_Attribs

　　  ::＝Namez_Attrib      //必需

　　  ::＝Priority_Attrib   //可选

　　  ::＝Enabled_Attrib    //可选

　　  ::＝LocTag_Attrib     //可选

　　RuleBody

　　  ::＝DecisionTree_Element

　　  ::＝PatternMatching_Element

该元素可以使用Priority_Attrib字段可选地指定优先级级别。推理引擎112可以通过优先级次序，例如从最高值到最低值或者从最低值到最高值，对域议程中的规则进行定序。如果该元素没有指定优先级级别，则推理引擎112可以赋予零或其它适合值的缺省优先级。

该元素还可以通过Enabled(使能)_Attrib可选地指定是否应启用规则以进行推理。如果启用，则该规则参与推理。否则，推理引擎112忽略该规则。在一个实施例中，缺省地，规则被启用。

规则定义语言内在地支持两种规则，即决策树规则和模式匹配规则。不同类型在相同规则集内可以混合。规则编辑器和转换器，如规则编辑器132和变换器133可以选择支持附加类型的规则。例如，Infix(中缀)到XML工具还可支持IF-THEN规则。由于IF-THEN规则可表示决策树规则的简单特殊化，因此Infix到XML工具可从IF-THEN规则生成决策树规则。这对于决策表规则同样为真，因为如同IF-THEN规则它们可以表示决策树规则的特殊化。

来自样例规则库114的一些样例Rule_Element可以是：

<domain name＝″PerformConclusionAnalysis″appshared＝″true″>

  ...

  <ruleset name＝″ConclusionAnalysis″>

    <rule name＝″Overall_status″>

      ...

    </rule>

    <rule name＝″Conclusion1_status″>

      ...

      </rule>

      <rule name＝″Conclusion2_status″>

        ...

      </rule>

   </ruleset>

</domain>

10.1 DecisionTree_Element

Rule_Element的该元素定义决策树规则的主体。

10.1.1 结构元素

决策树包括一个或多个具有以下形式的决策：

DecisionTree_Element

  ::＝(′dec_tree_body′[LocTag_Attrib])

        Decision_Element+

10.1.1.1 决策

每个决策由标识符(Name_Attrib)命名，并且包括以下子元素：

Decision_Element

  ::＝(′decision′Decision_Attribs+)

      GeneralExpr

      DecTestGroup_Element^*

      [DecOtherwise_Element]

      [DecUnknown_Element]

Decision_Attribs

  ::＝Name_Attrib       //必需

  ::＝LocTag_Attrib     //可选

虽然不同规则内的决策可以共享相同决策名称，但给定规则内的决策可以具有唯一名称。决策可以定义任何数据类型的基本表达式(GeneralExpr)。该表达式可以引用字段并且调用方法。决策也可以定义一个或多个测试组(DecTestGroup(决策树组)_Element)。它还可以可选地定义otherwise(否则)子句(DecOtherwise_Element)和/或未知子句(DecUnknown_Element)。

10.1.1.2 决策测试组

每个测试组指定一个或多个case(情况)表达式和action(操作)子句，并且它具有以下形式：

DecTestGroup_Element

  ::＝(′dec_test_group′[LocTag_Attrib])

      DecCaseExpr+

      DecAction

推理引擎112比较情况表达式(DecCaseExpr)的值与决策基本表达式的值。如果推理引擎112发现至少一个“相等”比较，则推理引擎112执行由该组的操作子句(DecAction)指定的操作。

10.1.1.3 决策否则子句

否则子句指定当前决策的缺省操作子句，并且具有以下形式：

DecOtherwise_Element

   ::＝(′dec_otherwise′[LocTag_Attrib])

       DecAction

如果没有决策测试组或者它们都没有产生“真”比较，则推理引擎112执行由该子句的操作子句(DecAction)指定的操作。

10.1.1.4 决策未知子句

未知子句如同否则子句，是当前决策的特殊情况操作子句，并且具有以下形式：

DecUnknown_Element

   ::＝(′dec_unknown′[LocTag_Attrib])

       DecAction

如果推理引擎112由于未知字段引用而不能对决策的基本表达式进行求值，则推理引擎112执行由该子句的操作子句(DecAction)指定的操作。

10.1.1.5 决策操作子句

操作子句可以指定两种操作之一，并且具有以下形式：

DecAction

　　 ::＝DecStatements_Element

　　 ::＝DecRef_Element      //嵌套决策

　　DecStatements_Element

　　 ::＝(′dec_statements′[LocTag_Attrib])
				
				<dp n="d59"/>
　　    Statement*

　　DecRef_Element

　　  ::＝(′dec_ref′DecRef_Attribs+)

　　DecRef_Attribs

　　  ::＝Name_Attrib     //决策名-必需

　　  ::＝LocTag_Attrib   //可选

语句-操作子句(DecStatements_Element)指定要执行的零个或更多语句。当执行这些操作时，推理引擎112以“触发”或“挂起”状态(如果子句指定一些语句)否则以“舍弃”状态(如果子句没有指定任何语句)终止规则。

决策操作子句(DecRef_Element)对当前决策树规则内的另一个决策进行命名。推理引擎112继续执行(pursue)该命名决策作为当前决策的子决策。对于给定规则，多个决策操作子句(不管是在相同决策中还是在不同决策中)全都可以引用相同的决策作为子决策。

10.1.1.6 测试组情况表达式

每个测试组情况表达式指定部分比较，并且具有以下形式：

DecCaseExpr

  ::＝PartComp_EQ_Element    //＝GeneralExpr

  ::＝PartComp_NE_Element    //＜＞GeneralExpr

  ::＝PartComp_LT_Element    //＜GeneralExpr

  ::＝PartComp_LTEQ_Element  //＜＝GeneralExpr

  ::＝PartComp_GT_Element    //＞GeneralExpr

  ::＝PartComp_GTEQ_Element  //＞＝GeneralExpr

  ::＝PartComp_Range_Element //在范围以内：(GeneralExpr1..

                                  GeneralExpr2)

部分比较(PartComp_xxx_Element)在后面进行描述。在一个实施例中，这些表达式不需要是常数表达式。例如，它们可以自由地引用字段和调用方法。这些表达式与决策的基本表达式也可以是类型兼容的。

10.1.2 动态标识符路径中的空

在一个实施例中，动态标识符路径可以包括空值。例如，在以下语句中：

Duck1.OwnedBy.SpouseOf.Name＝″fred″

SpouseOf可能具有空值。如果在基本表达式求值期间检测到空值，则推理引擎112可以舍弃该规则(除非它指定otherwise(否则)语句)。如果在test-case(测试情况)求值期间检测到空值，则推理引擎112可以舍弃该测试情况，并且继续其它测试情况。如果在执行操作时检测到空值，则推理引擎112可以用错误中止推理。

推理引擎112还可考虑操作语句。例如，在这些语句中：

isTrue＝Duck1.OwnedBy.SpouseOf.Name＝＝″fred″

                    //SpouseOf为空

isTrue＝Duck1.owner.age＞5 and Duck1.spouse.age＜5

                    //Owner(所有者)和/或Spouse(配偶)为空

不中止，推理引擎112可以将关系子表达式求值为假。同样地，对于基本表达式前提，例如：

eval Duck1.owner.age＜5 or Duck1.spouse.age＜5//Owner为空

推理引擎112可以舍弃单独比较。然而，如果Owner为空，Spouse不为空，并且Spouse年龄足够小，则推理引擎112可以仍然将基本表达式求值为真。

10.1.3 示例规则和行为

决策树决策可以类似于C、C++和Java内的switch语句。决策的基本表达式可以对应于switch表达式，测试组情况表达式可以对应于switch的case(情况)语句，并且决策的otherwise(否则)子句可以对应于switch的缺省情况。

下面是反映单个决策的非常简单决策树规则的中缀代码例子：

<rule name＝″Factl_is_true″>

  <！[CDATA[

    decision main

  eval Fact2

  then

    case＝false；

      do Fact1＝true end

  end

]]>

</rule>

本例等价于更传统的IF规则。如果Fact2为FALSE(假)，则该规则将Fact1设为TRUE(真)。

下面是反映多个决策的另一个例子：

<rule name＝″Determine_Fact4_status″>

<！[CDATA[

  decision main

  eval age

  then

    case＜21.5：

      decision sub1

    case＞＝30..＜＝32：

    case＞＝41..＜＝55.5：

      decision sub2

    case＞32..＜41：

     do end

    otherwise：

     do Fact4＝false end

    unknown：

     do Fact4＝true end

end

  decision sub1

  eval Fact2

  then

    case＝true：

      do Fact4＝false end

    otherwise：

     do Fact4＝true end

end

  decision sub2

  eval Fact3

then

  case＝false：

    do Fact4＝true end

  otherwise：

    do Fact4＝false end

end

]]>

</rule>

该规则对年龄进行求值，并且根据结果有条件地执行操作。在一些情况(如年龄15)下，操作是处理另一个决策(向该规则给出其独特树状行为)。在其它情况(如年龄35)下，不存在要执行的操作。

在本例中，决策测试组可以“堆叠”多种情况，以便共享操作(例如，对于年龄35和45)。使用未知子句捕获年龄未知的情形，并且使用否则子句捕获未被决策测试组覆盖的情形。

10.1.4 另外行为

10.1.4.1 规则库编译期间

在一个实施例中，规则库构建器110可以确保对于给定决策树规则，所有决策是唯一命名的。在本实施例中，规则库构建器110还可确保正好一个规则决策不被任何其它决策引用为子决策。规则库构建器110可以将该决策区别为规则的根决策。规则可以任何次序指定决策，而不管决策可以如何引用另一个决策作为子决策。多个决策操作子句可以指定相同决策作为子决策。规则库构建器110可以禁止自引用决策和决策之间的“循环”引用。

10.1.4.2 推理期间

在一个实施例中，推理引擎112在根决策中开始规则处理。在本实施例中，推理引擎112然后可以根据此结果进入那个决策的嵌套决策中的最多之一。决策可以嵌套至任意层数，但是在每一层，推理引擎112的行为可以是类似的。

对于给定决策，推理引擎112首先对该决策的基本表达式进行求值。如果其由于未知字段引用而失败，则推理引擎112执行未知子句(如果指定了一个的话)的操作。如果不存在这样的子句，则推理引擎112立即以挂起状态终止规则处理。

如果推理引擎112成功地对决策的基本表达式进行求值，则推理引擎112下一步将该表达式的值应用于任何测试组情况表达式。推理引擎112按照由决策指定的次序访问测试组。在每个测试组内，推理引擎112按照由测试组指定的次序访问情况表达式。

当检测到真情况时，推理引擎112执行那个拥有组的操作。如果任何测试组中的情况都不适用，则推理引擎112执行否则子句的操作(如果定义的话)，否则以舍弃状态终止规则处理。

语句-操作子句可以为空或非空。如果为空，则推理引擎112以舍弃状态终止规则处理。否则，推理引擎112以触发或挂起状态终止规则处理。

10.1.4.3 情况表达式的规则挂起

推理引擎112可以查看测试组的情况表达式作为公共操作的可选资格。如果任何情况表达式产生真情况，则推理引擎112执行组操作。

如果情况表达式求值由于未知字段的引用而失败，则推理引擎112对其它的组的情况表达式进行求值以查找真情况。如果找不到一个，则推理引擎112以挂起状态终止规则。

作为该处理的结果，具有多个测试情况的测试组在语义上可以不等同于各自具有单个测试情况的多个测试组。例如，假定以下测试组：

case＜minimum

case＞maximum

case＞dangerous_range_start..＜dangerous_range_end

  do

    DoSomething()

  end

如果基本表达式的值落在危险范围内，即使最小和最大值是未知的，推理引擎112也触发规则。然而，假定以下表面上等同的测试组：

case＜minimum

  do

    DoSomething()

  end

case＞maximum

  do

    DoSomething()

  end

case＞dangerous_range_start..＜dangerous_range_end

  do

    DoSomething()

  end

如果最小值未知，则即使最大和/或范围值已知，推理引擎112也立即以挂起状态终止规则。

10.1.4.4 语句操作的规则挂起

当执行规则操作时，如果推理引擎112检测到对未知字段的引用，则推理引擎112立即以挂起状态终止规则。当重新启动规则时，推理引擎112恢复先前导致规则挂起的操作内的执行。

10.1.5 其它者虑

推理引擎112可以前向链接或后向链接决策树规则。在一个实施例中，虽然决策树规则可以创建动态实例(通过inst_make内部方法)，但是它不可访问动态实例。在本实施例中，它只能引用静态实例的字段和方法。

10.2 PatternMatching_Element

Rule_Element的该元素定义模式匹配规则，并且具有以下格式：

PatternMatching_Element

　　  ::＝(′pm_rule′PM_Attribs*)

　　    PMBindVars

　　    PMPremise_Element

　　    PMActions_Element

　　    [PMOrderBy_Element]

　　PM_Attribs

　　  ::＝PMOptions_Attrib  //可选(见下值)

　　  ::＝LocTag_Attrib     //可选

　　//对于PMOptions_Attrib：

　　PMOption

　　  ::＝′mostrecent′

　　  ::＝′singlefire′

该规则可以指定一个或多个选项作为字段。这些选项影响实例绑定(mostrecent-最近)的次序以及推理引擎112是否触发规则仅一次(对于首次绑定)或者多次(对于所有绑定)。缺省地，推理引擎112可以以先入先出的方式(least recent-最不近)对绑定进行排序，并且对所有绑定触发该规则。

当PM_Attribs指定多个选项时，这些选项可以是逗号分隔的，例如：

options＝″mostrecent，singlefire″

这些选项还可以任何次序指定。

PatternMatching_Element可以包括用于绑定变量声明(PMBindVars)、规则逻辑(PMPremise_Element、PMActions_Element)以及可选的排序指定(PMOrderBy_Element)的三个子元素。

来自样例规则库114的模式匹配规则的中缀代码例子可以是：

<rule name＝″Itemize_persons_without_any_siblings″>

 <！[CDATA[

   for

    any person p

  if

    //人从未有过任何同胞

    p.IsSiblingOf.@fld_isunknown()

    //人目前没有同胞

    or p.IsSiblingOf＝set()

  then

    var msg is string＝″No sibling for：″&p.@inst_getname()

    @engn_tracemsg(msg)

  end

  //按照年龄以升序对项目进行排序；

  //对于相等年龄，按照最近性进行排序(最近最先)

  options mostrecent

  orderby p.getage()

  ]]>

</rule>

该规则遍及Person的所有实例，并且逐项列举没有任何同胞的实例。结果按照年龄来排序。在年龄相同的情况下，更近的绑定居于更不近的绑定之前。

模式匹配规则可以是更动态的，并且自动地对在其它规则中执行的实例创建、修改和删除作出反应。例如，依靠自身(feed off of itself)，并由此计算所有同胞关系的单条规则可以是：

<rule name＝″Make_sibling_if_there_are_shared_siblings″>

  <！[CDATA[

    for

      any person p1，

      any person p2

    if

     //不同人

     p1＜＞p2

     //这两个人已经不是同胞

     and not p1.IsSiblingOf.@set_doesincludeval(p2)

     //这两个人共有同胞

     and p1.IsSiblingOf.@set_doesintersect(p2.IsSiblingOf)

    then

     //使这两个人为同胞

     p1.IsSiblingOf.@set_addval(p2)

    end

  ]]>

</rule>

如果动态标识符路径包括空值，则推理引擎112可以执行上面关于决策树规则所述的相同操作。

10.2.1 PMBindVars构造

该构造声明模式匹配规则的绑定变量，并且具有以下格式：

PMBindVars

　　  ::＝PMBindVarDcl_Element

　　  ::＝PMBindVarList_Element

　　PMBindVarDcl_Element
				
				<dp n="d67"/>
　　  ::＝(′bindvar_dcl′PMBindVarDcI_Attribs+)

　　   IdentifierSpec      //bindvar类

　　PMBindVarDcl_Attribs

　　  ::＝Name_Attrib      //必需

　　  ::＝LocTag_Attrib    //可选

　　PMBindVarList_Element

　　  ::＝(′bindList′[LocTag_Attrib])

　　     PMBindVarDcl_Element*

该构造可以声明一个或多个绑定变量。每个声明指定变量名(作为PMBindVarDcl_Attribs Name_Attrib)和类名。不同绑定变量可以与相同或不同类相关联。对于中缀代码声明：

any person p，

any duck d

所生成的规则定义语言代码可以是：

<bindlist>

  <bindvar_dcl name＝″p″loc_tag＝″Line#2″>

    <identifer name＝″person″/>

  </bindvar_dcl>

  <bindvar_dcl name＝″d″loc_tag＝″Line#3″>

    <identifer name＝″duck″/>

  </bindvar_dcl>

</bindlist>

如上所述，loc_tag字段表示推理引擎112可以在错误和跟踪消息中包括的字段。当执行推理操作时，loc_tag字段无需由推理引擎112处理。另外，loc_tag字段可以在规则定义语言中应用于在分级结构中较低的元素，除非该较低元素覆盖loc_tag值。结果，loc_tag字段可以用来将源输入行号附于XML元素。

10.2.2 PMPremise_Element

该元素定义规则的前提：

PMPremise_Element

  ::＝(′pm_premise′[LocTag_Attrib])

    GeneralExpr

GeneralExpr可以是引用为该规则声明的所有绑定变量的Boolean表达式。否则，服务器102可以用语法错误拒绝规则。

10.2.3 PMActions_Element

该元素定义规则的操作：

PMActions_Element

  ::＝(′pm_actions′[LocTag_Attrib])

     Statement^*

规则操作可以通过绑定变量引用一些字段值，但是服务器102可以不坚持要求这些引用。

10.2.4 PMOrderBy_Element

该元素指定用于对实例绑定进行排序的准则，并且具有以下格式：

PMOrderBy_Element

  ::＝(′orderby′[LocTag_Attrib])

      GeneralExpr^*    //Number(数字)或String(字符串)

该元素指定零个或更多Number或String表达式作为排序准则。推理引擎112可以首先通过第一表达式对绑定进行排序，然后通过第二表达式对匹配绑定进行排序，等等。如果在所有这些比较之后绑定仍然匹配，则推理引擎112可以根据mostrecent(最近)选项来决定排序。排序可以升序、降序或者其它适合次序来完成。如果对于Number表达式期望用降序，则用户可以对表达式取负，例如：

Orderby-p.getage()。

10.2.5其它考虑

在一个实施例中，推理引擎112可以前向链接而非后向链接模式匹配规则。在本实施例中，推理引擎112在后向链接期间可以忽略任何模式匹配规则。模式匹配规则也可与静态和动态实例或者两种类型的混合一起工作。该规则可以能够自由地修改静态实例，并且它们可以自由地创建、修改和删除动态实例。当计算模式匹配实例绑定时，推理引擎112可以省略inst_template内部实例。绑定变量可以与对象的超类相关联。例如，用户可能指定Bird绑定变量，并且推理引擎112可以在Duck、Robin和Hawk的实例上以多态方式进行模式匹配。

11.语句构造

该构造定义规则定义语言的逻辑语句元素，并且具有以下格式：

Statement

  ::＝VarDclStmt_Element

  ::＝AssignmentStmt_Element

  ::＝MethodCall_Element

  ::＝ReturnStmt_Element

11.1 VarDclStmt_Element

该Statement元素声明局部变量，并且具有以下格式：

VarDclStmt_Element

  ::＝(′var_dcl′VarDcl_Attribs+)

     DataType_Element

     GeneralExpr       //初始化值

VarDcl_Attribs

  ::＝Name_Attrib      //必需

  ::＝LocTag_Attrib    //可选

该语句可以由规则和方法逻辑两者指定。它可以位于该逻辑内的任何地方，但是其位置可影响其范围可见性。局部变量可以为任何数据类型，包括集合和关联实例。该语句可以为局部变量指定初始化值。GeneralExpr定义类型兼容的初始化值。该表达式无需是常数表达式。

来自样例规则库114的中缀代码例子可以是：

var result is boolean＝true   //以乐观方式并且对应的规则定义语言代码可以是：

<var_dcl name＝″result″loc_tag＝″Line#2″>

   <datatype coll_type＝″none″type＝″boolean″/>

   <literal_constant value＝″true″/>

</var_dcl>

11.2 AssignmentStmt_Element

该Statement元素定义赋值语句，并且具有以下格式：

AssignmentStmt_Element

  ::＝(′assign_stmt′[LocTag_Attrib])

     IdentifierSpec    //目的(字段)

    GeneralExpr        //源

该元素可以由规则和方法逻辑两者指定。推理引擎112对GeneralExpr进行求值，并且将其值赋给类型兼容的指定目的对象。目的对象可以是字段或局部变量。如果是字段，则推理引擎112可以在完成赋值之前首先调用约束检查。

当操作数为Number类型时，推理引擎112比较操作数精度。如果GeneralExpr精度小于目的对象的精度，则推理引擎112可以对GeneralExpr值进行零扩展，以匹配目的精度，然后执行赋值。否则，推理引擎112在必要时舍入GeneralExpr值，以匹配目的精度。

来自样例规则库114的中缀代码例子可以是：

Fact1＝true

并且对应的规则定义语言代码可以是：

<assign_stmt loc_tag＝″Line#3″>

   <identifier name＝″Fact1″/>

   <literal_constant value＝″true″/>

</assign_stmt>

11.3 MethodCall_Element

Statement的该元素定义方法调用语句，并且具有以下格式：

MethodCall_Element

  ::＝(′method_call′[LocTag_Attrib])

      IdentifierSpec   //方法

      [MethodArgList_Element]

MethodArgList_Element

  ::＝(′arg_list′[LocTag_Attrib])

      GeneralExpr^*

该元素可以由规则和方法逻辑两者指定。推理引擎112可以调用带有任何指定自变量的指定方法。该元素可作为独立语句和表达式中的项(如果所调用的方法返回值)来应用。调用可以包括零个或更多自变量表达式。自变量数目可以等于目标方法所预期的参数数目，并且每个自变量与其对应方法参数可以是类型兼容的。如果方法参数是输出参数，则自变量可以是字段或局部变量的标识符。

当自变量和参数为Number类型时，则推理引擎112比较它们的精度。如果source-object(源对象)(输入参数的自变量；输出参数的参数)精度小于目的对象(输入参数的参数；输出参数的自变量)，则推理引擎112对源值进行零扩展，以匹配目的精度，然后传递值。否则，推理引擎112在必要时舍入源值，以匹配目的精度。类似的考虑可以应用于Number类型的方法返回值。推理引擎112可以在将返回值赋给目的对象之前调整或舍入返回值。

来自样例规则库114中的模式匹配规则的中缀代码例子可以是：

//关联人和鸭子

p.AssignDuck(d)

并且对应的规则定义语言代码可以是：

<method_call loc_tag＝″Line#13″>

  <identifier_path>

    <identifier name＝″p″/>

    <identifier name＝″AssignDuck″/>

  </identifier_path>

  <arg_list>

    <identifier name＝″d″/>

  </arg_list>

</method_call>

11.4 ReturnStmt_Element

该元素定义方法返回语句，并且具有以下格式：

RetumStmt_Element

  ::＝(′return_stmt′[LocTag_Attrib])

     [GeneralExpr]

在一个实施例中，该语句可以仅由方法逻辑而非规则逻辑指定。如果在规则逻辑内指定，则服务器102可以用语法错误拒绝该语句。当执行该语句时，推理引擎112可以终止方法执行，并且返回控制给调用该方法的代码。如果该语句指定GeneralExpr，则当前方法可以被定义为返回值，并且所声明的返回数据类型与该语句的GeneralExpr可以是类型兼容的。如同对MethodCall_Element描述的一样，推理引擎112可以调整或舍入Number类型的返回值。

来自样例规则库114的中缀代码例子可以是：

return Symptoms.@Set_DoesIncludeVal(symp1)

  and not Symptoms.@set_DoesINcludeVal(symp2)并且对应的规则定义语言代码可以是：

<return_stmt loc_tag＝″Line#1″>

     <and_op loc_tag＝″Line#2″>

       <method_call>

         <identifier intrinsic＝″true″name＝″set_doesincludeval″/>

         <arg_list>

           <identifier name＝″Symptoms″/>

           <identifier name＝″symp1″/>

         </arg_list>

    </method_call>

    <not_op>

     <method_call>

         <identifier intrinsic＝″true″name＝″set_doesincludeval″/>

         <arg_list>

         <identifier name＝″Symptoms″/>

         <identifier name＝″symp2″/>

       </arg_list>

    </method_call>

    </not_op>

  </and_op>

</return_stmt>

12.GeneralExpr构造

GeneralExpr构造定义从规则定义语言逻辑引用的表达式，并且具有以下格式：

GeneralExpr

　　  ::＝SimpleTerm

　　  ::＝RelationalTerm

　　     //一元操作符

　　  ::＝UnaryPlusExpr_Element

　　  ::＝UnaryMinusExpr_Element

　　  ::＝UnaryNotExpr_Element

　　     //二元操作符

　　  ::＝ORed_Element

　　  ::＝ANDed_Element

　　  ::＝Addition_Element

　　  ::＝Subtraction_Element

　　  ::＝Concatenation_Element

　　  ::＝Multiplication_Element

　　  ::＝Division_Element

GeneralExpr支持项和操作符的预期集合。如前所述，表达式求值不可产生任何副作用。同样地，由表达式调用的任何方法不可产生任何副作用。称作函数方法的这些方法在上面ClassMethodDef_Element章节中作了进一步的描述。

在一个实施例中，该语法不试图区分数据类型兼容操作与不兼容操作。例如，该语法可建议可以从String值中减去Boolean值。在本实施例中，由执行类型检查和常量合并(constant folding)的服务器102执行类型兼容性强制。

设法包括项和操作符的大部分类型的示例中缀代码语句可以是：

var IsHappy is Boolean＝

      Is Wealthy

   Or(

     age＞0..＜＝200

     and not IsTooTall

     and QualityIndex(

      (income+savings-debts)/12，

      firstname&″″&lastname，

      some_random_number)

  ＞+100

)

该语句的对应规则定义语言代码可以是：

<var_dcl loc_tag＝″Line#1″name＝″IsHappy″>

  <datatype coll_type＝″none″type＝″Boolean″/>

  <or_op loc_tag＝″Line#3″>

    <identifier name＝″IsWealthy″/>

    <and_op loc_tag＝″Line#6″>

      <and_op loc_tag＝″Line#5″>

        <range_op>

          <identifier name＝″age″/>

          <part_gt_op>

            <literal_constant value＝″0″/>

          </part_gt_op>

          <part_lteq_op>

            <literal_constant value＝″200″/>

          </part_lteq_op>

        </range_op>

        <not_op>

          <identifier name＝″IsTooTall″/>

        </not_op>

    </and_op>

    <gt_op>

        <method_call>

          <identifier name＝″QualityIndex″/>

            <arg_list>

              <div_op>

                <subt_op>

               <add_op>

                 <identifier name＝″income″/>

                 <identifier name＝″savings″/>

               </add_op>

               <identifier name＝″debts″/>

             </subt_op>

             <literal_constant value＝″12″/>

           </div_op>

           <concat_op>

             <concat_op>

               <identifier name＝″firstname″/>

               <literal_constant value＝″&quot；&quot；″>

             </concat_op>

             <identifier name＝″lastname″/>

           </concat_op>

           <identifier name＝″some_random_number″/>

         </arg_list>

      </method_call>

      <uplus_op>

         <literal_constant value＝″100″/>

      </uplus_op>

    </gt_op>

  </and_op>

  </or_op>

</var_dcl>

12.1 SimpleTerm构造

GeneralExpr的SimpleTerm可以具有以下格式：

SimpleTerm

  ::＝LiteralConstant_Element

  ::＝SetConstant_Element

::＝IdentifierSpec     //对象名称

::＝MethodCall_Element

在此描述LiteralConstant_Element和SetConstant_Element。IdentifierSpec在本文的后面进行描述，而MethodCall_Element在上面已作过描述。

12.1.1 LiteralConstant_Element

LiteralConstant_Element具有以下格式：

LiteralConstant_Element

  ::＝(′literal_constant′LiteralConstant_Attribs+)

LiteralConstant_Attribs

  ::＝Value_Attrib     //必需

  ::＝LocTag_Attrib    //可选

Value_Attrib常量值表示为字符串。服务器102可以检查该值(以不区分大小写的方式)以便确定常量的数据类型。如果值为“TRUE”或“FALSE”，则服务器102识别该常量为Boolean常量。如果值为“NULL”，则服务器102识别该常量为关联实例常量(表示缺乏关联实例)。如果值的第一字符是双引号字符，则服务器102识别该常量为String常量，并且验证该值的最后字符也为双引号字符。否则，服务器102假定该常量是Number常量，并且相应地解析它。推理引擎112通过检查小数点右边的位数来确定该常量的精度。如果该常量采用科学表示法来表达，则精度也对指数值加以考虑。

字面常量的中缀代码例子可以是：

method1(false，null，″abc″，″″，123.456)并且对应的规则定义语言代码可以是：

<method_call loc_tag＝″Line#1″>

  <identifier name＝″method1″/>

  <arg_list>

    <literal_constant value＝″false″/>

    <literal_constant value＝″null″/>

    <literal_constant value＝″&quot；abc&quot；″/>

    <literal_constant value＝″&quot；&quot；″/>

    <literal_constant valtue＝″123.456″/>

  </arg_list>

</method_call>

12.1.2 SetConstant_Element

SetConstant_Element具有以下格式：

SetConstant_Element

  ::＝(′set_constant′[LocTag_Attrib])

      SetMember^*

SetMember

  ::＝LiteralConstant_Element

  ::＝IdentifierSpec   //实例名称

  ::＝UnaryExpr        //只带LiteralConstant_Element

集合包含零个或更多成员。在一个实施例中，集合的所有成员都应具有相同数据类型。成员(若有的话)的数据类型为集合常量的数据类型。成员可以是字面常量、IdentifierSpec(用于关联实例集合)或者对字面常量的一元操作符。在对字面常量的一元操作符的情况下，字面常量可以是Number或Boolean常量。对于Number的集合常量，尽管其成员具有精度，但集合本身不具有精度。同样地，实例的集合常量不绑定于任何特定关联。

集合常量的中缀代码例子可以是：

set1＝set(123)

set2＝set(″abc″，″def″)

set3＝set(duck1，duck2)

set4＝set(-123，0)

set5＝set()            //空集合并且对应的规则定义语言代码可以是：

<assign_stmt loc_tag＝″Line#1″>

  <identifier name＝″set1″/>

  <set_constant>

   <literal_constant value＝″123″/>

  </set_constant>

</assign_stmt>

<assign_stmt loc_tag＝″Line#2″>

  <identifier name＝″set2″/>

  <set_constant>

    <literal_constant value＝″&quot；abc&quot；″/>

    <literal_constant value＝″&quot；def&quot；″/>

  </set_constant>

</assign_stmt>

<assign_stmt loc_tag＝″Line#3″>

  <identifier name＝″set3″/>

  <set_constant>

    <identifier name＝″duck1″/>

    <identifier name＝″duck2″/>

  </set_constant>

</assign_stmt>

<assign_stmt loc_tag＝″Line#4″>

    <identifier name＝″set4″/>

    <set_constant>

      <uminus_op>

        <literal_constant value＝″123″/>

      </uminus_op>

        <literal_constant value＝″0″/>

    </set_constant>

</assign_stmt>

<assign_stmt loc_tag＝″Line#5″>

    <identifier name＝″set5″/>

    <set_constant/>

</assign_stmt>

12.2 RelationalTerm构造

RelationalTerm定义值比较，并且具有以下格式：

RelationalTerm

  ::＝Fullcomp_EQ_Element

::＝Fullcomp_NE_Element

::＝Fullcomp_LT_Element

::＝Fullcomp_LTEQ_Element

::＝Fullcomp_GT_Element

::＝Fullcomp_GTEQ_Element

::＝Fullcomp_Range_Element

值比较可包括上面描述的完全比较和部分比较。

12.2.1 完全比较构造

完全比较可以包括二元操作或者涉及值范围的三元操作。示例二元操作可以是：

IsLessThan＝fld1＜123

而示例三元操作可以是：

IsInRange＝fld1＞＝100..＜200

//上面语句在语义上等价于下面语句

//(但是更高效)：

IsInRange＝fld1＞＝100 and fld1＜200

在任何情况下，该表达式返回表示比较结果的Boolean值。

对应于上述三个中缀语句的规则定义语言代码可以是：

<assign_stmt loc_tag＝″Line#1″>

  <identifier name＝″IsLessThan″/>

  <lt_op>

    <identifier name＝″fld1″/>

    <literal_constant value＝″123″/>

  </lt_op>

</assign_stmt>

<assign_stmt loc_tag＝″Line#2″>

  <identifier name＝″IsInRange″/>

  <range_op>

    <identifier name＝″fld1″/>

    <part_gteq_op>

      <literal_constant value＝″100″/>

    </part_gteq_op>

    <part_lt_op>

      <literal_constant value＝″200″/>

    </part_lt_op>

  </range_op>

</assign_stmt>

<assign_stmt loc_tag＝″Line#5″>

  <identifier name＝″IsInRange″/>

  <and_op loc_tag＝″Line#5″>

    <gteq_op>

      <identifier name＝″fld1″/>

      <literal_constant value＝″100″/>

    </gteq_op>

    <lt_op>

      <identifier name＝″fld1″/>

      <literal_constant value＝″200″/>

    </lt_op>

  </and_op>

</assign_stmt>

完全比较元素可以具有以下格式：

Fullcomp_EQ_Element    //GeneralExpr＝GeneralExpr

　　  ::＝(′eq_op′Comp_Attribs*)

　　     GeneralExpr

　　     GeneralExpr

　　Fullcomp_NE_Element    //GeneralExpr＜＞GeneralExpr

　　  ::＝(′neq_op′Comp_Attribs*)

　　     GeneralExpr

　　     GeneralExpr

　　Fullcomp_LT_Element    //GeneralExpr＜GeneralExpr

　　  ::＝(′lt_op′Comp_Attribs*)

　　     GeneralExpr
				
				<dp n="d81"/>
　　     GeneralExpr

　　Fullcomp_LTEQ_Element  //GeneralExpr＜＝GeneralExpr

　　  ::＝(′lteq_op′Comp_Attribs*)

　　     GeneralExpr

　　     GeneralExpr

　　Fullcomp_GT_Element    //GeneralExpr＞GeneralExpr

　　  ::＝(′gt_op′Comp_Attribs*)

　　     GeneralExpr

　　     GeneralExpr

　　Fullcomp_GTEQ_Element  //GeneralExpr＞＝GeneralExpr

　　  ::＝(′gteq_op′Comp_Attribs*)

　　     GeneralExpr

　　     GeneralExpr

　　Fullcomp_Range_Element

　　     //GeneralExpr在范围以内：(GeneralExpr1..GeneralExpr2)

　　  ::＝(′range_op′[LocTag_Attrib])

　　     GeneralExpr

　　     RangeStartComp

　　     RangeStopComp
　　
　　RangeStartComp

　　  ::＝PartComp_GT_Element

　　  ::＝PartComp_GTEQ_Element

　　RangeStopComp

　　  ::＝PartComp_LT_Element

　　  ::＝PartComp_LTEQ_Element

对于所有这些元素，GeneralExpr可以全都为相同数据类型。然而，一些操作符仅支持特定数据类型。例如，相等和不等的比较支持所有数据类型和值的集合。不等集合可以或不可以相交。幅值的比较可以只支持Number和String表达式，但是也可应用于集合。对于集合，结果表示子集关系。当比较Number值时，推理引擎112首先将任何较低精度的操作数零扩展至另一个操作数的精度，然后执行比较。

对于所有元素，可以采用以下格式指定Comp_Attribs：

Comp_Attribs

  ::＝CaseSensitivity_Attrib  //可选

  ::＝LocTag_Attrib           //可选

可以指定CaseSensitivity(区分大小写)_Attrib来表示区分大小写的String比较。缺省地，String比较可以是不区分大小写或者区分大小写的。对于其它数据类型的比较，可以忽略该设置。

12.2.2 部分比较构造

范围比较依赖于部分比较构造、或者仅指定完全比较的“右手侧”的构造。部分比较构造具有以下格式：

PartComp_EQ_Element           //＝GeneralExpr

　　  ::＝(′part_eq_op′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_NE_Element           //＜＞GeneralExpr

　　  ::＝(′part_neq_op′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_LT_Element           //＜GeneralExpr

　　  ::＝(′part_lt_op′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_LTEQ_Element         //＜＝GeneralExpr

　　  ::＝(′part_lteq_op′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_GT_Element           //＞GeneralExpr

　　  ::＝(′part_gtop′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_GTEQ_Element         //＞＝GeneralExpr

　　  ::＝(′part_qteq_op′Comp_Attribs*)

　　     GeneralExpr

　　PartComp_Range_Element

　　                 //在范围以内：(GeneralExpr1..GeneralExpr2)

　　  ::＝(′part_range_op′[LocTag_Attrib])
				
				<dp n="d83"/>
　　    RangeStartComp

　　    RangeStopComp

这些构造也可以由决策树元素使用，其指定一个GeneralExpr(或者对于范围，指定二个)。它们也适用与完全比较相同的数据类型和区分大小写考虑。

12.3 一元操作符元素

GeneralExpr的一元操作符包括UnaryPlusExpr_Element、UnaryMinusExpr_Element和UnaryNotExpr_Element。

12.3.1 UnaryPlusExpr_Element

GeneralExpr的UnaryPlusEXpr_Element具有以下格式：

UnaryPlusExpr_Element

  ::＝(′uplus_op′[LocTag_Attrib])

     GeneralExpr

该操作在本质上返回GeneralExpr的值。包括它是为了“可表达性”的目的，例如：

If this_value＞＝-100..＜＝+100 then...end

GeneralExpr可以是Number表达式，并且该操作返回Number值。

12.3.2 UnaryMinusExpr_Element

UnaryMinusExpr_Element具有以下格式：

UnaryMinusExpr_Element

  ::＝(′uminus_op′[LocTag_Attrib])

      GeneralExpr

该操作取反GeneralExpr值的算术正负号。正值变成负值以及相反。GeneralExpr可以是Number表达式，但是该操作返回Number值。

12.3.3 UnaryNotExpr_Element

UnaryNotExpr_Element具有以下格式：

UnaryNotExpr_Element

  ::＝(′not_op′[LocTag_Attrib])

     GeneralExpr

该操作取反GeneralExpr的Boolean值。TRUE值变成FALSE以及相反。GeneralExpr可以是Boolean表达式，并且该操作返回Boolean值。

12.4 二元操作符元素

二元操作符包括ORed_Element、ANDed_Element、Addition_Element、Substraction_Element、Concatenation_Element、Multiplication_Element、以及Division_Element。

12.4.1 ORed_Element

ORed_Element支持OR(或)操作，并且具有以下格式：

ORed_Element

  ::＝(′or_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作对子元素执行逻辑OR(或)操作。如果任一子元素为TRUE，则结果为TRUE。否则，结果为FALSE。GeneralExpr可以都是Boolean表达式，并且该操作返回Boolean值。

在运行时，推理引擎112可以仅对GeneralExpr之一进行求值，例如，对于中缀代码表达式：

fld1＜100 or fld2＞＝200

如果fld1的值为50，则推理引擎112无需烦扰测试fld2，因为总结果已知为TRUE。然而，如果fld1未知，则推理引擎112可以测试fld2，以便如果fld2具有足够大的值如250，则推理引擎112可以避免挂起规则。类似地，推理引擎112还可确定任何带有中间实例引用字段的标识符路径是否具有空值。例如，对于中缀代码表达式：

Father.pDog.age＜5 or Child.pFriend.age＞10

Father可能没有任何狗(pDog＝null)。然而，如果Child(孩子)的朋友年龄足够大，则推理引擎112可以将该表达式求值为真。

虽然ORed_Element被描述为二元操作符，但是它也可容纳任意数目的操作数。例如，ORed_Element可以处理一个或多个操作数的“列表”。如果规则由于ORed_Element中的一个或多个操作数而被挂起，则推理引擎112可以以先前挂起的这些操作数(并且只是这些操作数)重新启动推理。

12.4.2 ANDed_Element

ANDed_Element支持AND(与)操作，并且具有以下格式：

ANDed_Element

  ::＝(′and_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作对子元素执行逻辑AND(与)操作。如果子元素都为TRUE，则结果为TRUE。否则，结果为FALSE。GeneralExpr可以都是Booleau表达式，并且该操作返回Booleau值。在运行时，推理引擎112可以仅对GeneralExpr之一进行求值，例如，对于中缀代码表达式：

Fld1＞＝100 and fld2＜200

如果fld1的值为50，则推理引擎112无需烦扰测试fld2，因为总结果已知为FALSE。然而，如果fld1未知，则推理引擎112可以测试fld2，以便如果fld2具有足够大的值如250，则推理引擎112可避免挂起规则。类似地，推理引擎112还可确定任何带有中间实例引用字段的标识符路径是否具有空值。例如，对于中缀代码表达式：

Father.pDog.age＜5 and Child.pFriend.age＞10

Father可能没有任何狗(pDog＝null)。然而，如果Child的朋友年龄不足够大，则推理引擎112可以将该表达式求值为假。

虽然ANDed_Element被描述为二元操作符，但是它也可容纳任意数目的操作数。例如，ANDed_Element可以处理一个或多个操作数的“列表”。如果规则由于ANDed_Element中的一个或多个操作数而被挂起，则推理引擎112可以用先前挂起的这些操作数(并且只是这些操作数)重新启动推理。

12.4.3 Addition_Element

Addition_Element支持加法操作，并且具有以下格式：

Addition_Element

  ::＝(′add_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作执行子元素的算术加法。该操作返回将第二子元素加到第一子元素的结果。GeneralExpr可以都是Number表达式，并且该操作返回Number值。当相加对象时，在算术操作之前，可以将较小精度的对象零扩展至另一个对象的精度。该结果可以反映较大的精度。

12.4.4 Subtraction_Element

Subtraction_Element支持减法操作，并且具有以下格式：

Subtraction_Element

  ::＝(′subt_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作执行子元素的算术减法。该操作返回从第一子元素减去第二子元素的结果。GeneralExpr可以都是Number表达式，并且该操作返回Number值。当使对象相减时，在算术操作之前，可以将较小精度的对象零扩展至另一个对象的精度。该结果可以反映较大的精度。

12.4.5 Concatenation_Flement

Concatenation_Element支持串接操作，并且具有以下格式：

Concatenation_Element

  ::＝(′concat_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作将一个String值附加到另一个String值。该操作返回将第二子元素附加到第一子元素的结果。GeneralExpr可以是任何数据类型，并且任一或全部两个表达式可以是Set(集合)表达式。在执行附加操作之前，推理引擎112可以将非String表达式自动转换成String值。可以没有用于控制非String值的格式化的选项。该操作返回String值。

12.4.6 Multiplication_Element

Multiplication_Element支持加法操作，并且具有以下格式：

Multiplication_Element

  ::＝(′mult_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作执行子元素的算术乘法。该操作返回将第一子元素乘以第二子元素的结果。GeneralExpr可以都是Number表达式，并且该操作返回Number值。当使对象相乘时，可以没有精度调整，并且乘积可以反映作为操作数精度之和的精度。

12.4.7 Division_Element

Division_Element支持加法操作，并且具有以下格式：

Division_Element

  ::＝(′div_op′[LocTag_Attrib])

    GeneralExpr

    GeneralExpr

该操作执行子元素的算术除法。该操作返回将第一子元素除以第二子元素的结果。除以零可以用错误终止推理。GeneralExpr可以两个都是Number表达式，并且该操作返回Number值。当使对象相除时，可以没有精度调整，并且商可以反映被除数值的精度，并且必要时可以进行舍入。

13.DataType_Element

本说明书频繁地引用DataType_Element。DataType_Element具有以下格式：

DataType_Element

      ::＝DataTypeNumber_Element

      ::＝DataTypeBoolean_Element

　　  ::＝DataTypeString_Element

　　  ::＝DataTypeInstRef_Element

　　//------------------------------------------------

　　DataTypeNumber_Element

　　  ::＝(′datatype′NumberType_Attribs+)

　　NumberType_Attribs

　　  ::＝DataType_Attrib         //″数字″(必需)

　　  ::＝Collection_Attrib       //可选

　　  ::＝Precision_Attrib        //可选

　　  ::＝LocTag_Attrib           //可选

　　//------------------------------------------------

　　DataTypeBoolean_Element

　　  ::＝(′datatype′BooleanType_Attribs+)

　　BooleanType_Attribs

　　  ::＝DataType_Attrib         //″布尔″(必需)

　　  ::＝Collection_Attrib       //可选

　　  ::＝LocTag_Attrib           //可选
				
				<dp n="d88"/>
　　//------------------------------------------------

　　DataTypeString_Element

　　  ::＝(′datatype′StringType_Attribs+)

　　StringType_Attribs

　　  ::＝DataType_Attrib         //″字符串″(必需)

　　  ::＝Collection_Attrib       //可选

　　  ::＝LocTag_Attrib           //可选

　　//------------------------------------------------

　　DataTypeInstRef_Element

　　  ::＝(′datatype′InstRefType_Attribs+)

　　    IdentifierSpec            //实例的类

　　InstRefType_Attribs

　　  ::＝DataType_Attrib         //″inst_ref″(必需)

　　  ::＝Collection_Attrib       //可选

　　  ::＝LocTag_Attrib           //可选

规则定义语言支持上面示出的四种“原子”数据类型。对于每种原子数据类型，还可以存在Datatype(数据类型)_Element的变体。

DataType_Attrib和Collection(收集)_Attrib属性公共于所有数据类型。DataType_Attrib表示相关数据类型。Collection_Attrib表示该数据类型是值的收集，如集合，还是简单的原子值。

对于DataTypeNumber(数据类型数)_Element，用户可以可选地指定“精度”，其按照小数点右边的十进制位数来表达。如果未指定，服务器102假定该值为零精度的整数。

对于DataTypeAssocInst_Element，用户可以指定两个子元素。这些分别标识数据类型的关联角色和关联名称。例如，对于涉及类Person和Duck的Ownership关联，Duck类可能定义作为用于Ownership关联中的角色Person的关联实例而声明的字段(IsOwnedBy)，例如：

<field name＝″IsOwnedBy″>

  <datatype coll_type＝″none″type＝″assoc_instance″>

   <identifier name＝″Person″/>

   <identifier name＝″Ownership″/>

  </datatype>

</field>

对于DataTypeInstRef_Element，用户指定标识与实例引用相关联的类的子元素。例如，Duck类可以通过以下代码定义作为Person类的实例而声明的IsOwnedBy字段：

<field name＝″IsOwnedBy″>

  <datatype coll_type＝″none″type＝″inst_ref″>

    <identifier name＝″Person″/>

  </datatype>

<field>

14.标识符

在一个实施例中，标识符名称可以是区分大小写的。在特定实施例中，规则定义语言禁止标识符名称包括双引号、句号、逗号、冒号或括号(开或闭)。服务器102可以例如通过保留字或者施加一些次序限制来施加附加限制。

14.1 IdentifierSpec-Identifier_Element、IdentifierPath_Element

IdentifierSpec元素具有以下格式：

IdentifierSpec

　　  ::＝Identifier_Element

　　  ::＝IdentifierPath_Element

　　Identifier_Element

　　  ::＝(′identifier′Identifier_Attribs+)

　　Identifier_Attribs

　　  ::＝Name_Attrib             //必需

　　  ::＝Intrinsic_Attrib        //可选

　　  ::＝LocTag_Attrib           //可选

　　IdentifierPath_Element

　　  ::＝(′identifier_path′[LocTag_Attrib])

　　    Identifier_Element+

标识符指定可包括单个标识符、或者多个标识符的“路径”。例如，中缀语言支持使用“.”操作符的路径，例如：

Class1.Instance1.Fld1＝3

14.2 内部(Intrinsic)标识符

对于每个Identifier(标识符)_Element，用户可以可选地指定标识符是内部标识符(Intrinsic_Attrib)或者内置于规则定义语言的标识符。服务器102可以检查这些标识符，并且将它们与其内部名称表进行比较。可能存在匹配，如不区分大小写的匹配。否则，服务器102可以作为语法错误拒绝该使用。

中缀语言可以要求每个内部标识符以“@”前缀指定。另外，中缀语言可以支持内部使用的可选形式。例如，下面的语句对在语义上可以是等价的，并且产生相同的规则定义语言代码：

@inst_reset(duck.@inst_template)

duck.@inst_template.@inst_reset()

@dmn_push(DomainX)

DomainX.@dmn_push()

If@fld_isunknown(instance1.fld1)then...end

If instance1.fld1.@fld_isunknown()then...end

If@set_doesincludeval(set1，123)then...end

If set1.@set_doesincludeval(123)then...end

另外，服务器102可以选择采用不同于由本文定义的名称暴露内部标识符。例如，服务器102可以选择更简单地作为“template”暴露inst_template，并且使后一名称为其语言中的保留字。

14.3 标识符解析

规则定义语言将标识符与规则库对象，如类、域、实例和字段相关联。服务器102因而解析对这些对象的名称引用。

14.3.1 标识符范围

用户可以以分级方式定义对象，例如：

●规则库全局对象

    ○类特定对象

       ■方法特定局部变量

    ○域特定对象

    ■类特定对象

         ●方法特定局部变量

    ■规则集特定对象

         ●类特定对象

               ○方法特定局部变量

         ●规则特定局部变量

对象在该分级结构中的位置确定其对对象引用的范围(可见性)。处于规则库级别的对象在整个规则库内可见于处于规则库级别和更低级别的对象。处于域级别的对象在其域内可见于处于域级别和更低级别的对象，但是这些对象不可见于其域之外。处于规则集级别的对象在该规则集内可见于处于规则集级别和更低级别的对象，但是这些对象不可见于该规则集之外。处于更低级别的对象“隐藏”处于更高级别的具有相同名称的对象。因此，名称为Age的局部变量可以隐藏名称为Age的类字段。

14.3.2 标识符限定

用户一般无需进行完全对象引用。用户可以只需指定足够的限定符来消除引用的歧义。因此，如果标识符Age唯一标识类Person的实例Father中的字段，则用户可简单地指定：

age。

如果存在Person的多个静态实例，则用户可以将标识符进一步限定为：

father.age。

如果多个同范围(in-scope)类定义Father对象，则用户可以将该标识符更完全限定为：

person.father.age。

如果在代码块的范围内的多处定义Age，则代码块可以通过指定适当的限定符来引用每一个对象。

14.4 静态和动态IdentifierSpec元素

14.4.1 静态指定(specification)

静态IdentifierSpec的值在推理之前就可被求解，例如：

age

father.age

person.father.age

domain1.ruleset1.duck.donald.age。

在一个实施例中，IdentifierSpec可以在允许IdentifierSpec的规则库内的任何地方被指定为静态的。在特定实施例中，路径不可包括多于五个标识符，并且路径长度影响其解释。例如，具有五个标识符的字段路径可以假定为采用以下格式：

<domain_name>.<ruleset_name>.<class_name>.<instance_name>.<field_name>，而三个标识符的字段路径假定为采用以下格式：

<class_name>.<instance_name>.<field_name>。

14.4.2 动态指定

动态IdentifierSpec的值在推理期间被求解，例如：

//名称为Father的Person实例的配偶的年龄

  person.father.spouse.age

//名称为Donald的Duck实例的拥有者的年龄

  domain1.ruleset1.duck.donald.owner.age

在一个实施例中，IdentifierSpec可以在规则或方法逻辑内被指定为动态的。在特定实施例中，这些指定可以为任意长，例如：

//Employee1(雇员)的管理者的配偶的管理者的配偶的年龄

employee1.manager.spouse.manager.spouse.age＝32

路径的“尾部”指定两个或更多字段名称。在一个实施例中，除了最后字段名称之外的所有字段名称标识作为实例引用字段而声明的字段。在上面例子中，标识符Manager和Spouse命名实例引用字段。

14.4.2.1 推理行为

当推理引擎112对动态指定中的各个字段进行求值时，推理引擎112可能遇到未知或空字段值。

14.4.2.1.1 未知字段值的处理

如果推理引擎112检测到未知值，则推理引擎112挂起当前执行的规则。

14.4.2.1.2 空字段值的处理

如果推理引擎112检测到具有空值的中间字段，则结果可能依赖于当前上下文。如果当前上下文是比较，例如：

employee1.manager(管理者).age＜32//其中employee1.manager＝NULL(无管理者)则推理引擎112可以将比较结果强制为假。如果推理引擎112在比较上下文之外检测到空值，则推理引擎112以错误异常终止推理。在本实施例中，如果Employee1没有管理者(Employee1.Manager＝NULL)，则推理引擎112将所有下面比较求值为假：

employee1.manager.age＜32

employee1.manager.age＞＝32

employee1.manager.age＜＞32

employee1.manager.age＝32

15.规则库合并

规则库合并是来自参与规则库114或子规则库的元素和字段的混合。在一些情况下，合并涉及相同规则库内具有相同名称的对象。规则库构建器110通过在规则库级别、约束设置级别、类级别、域级别和规则集级别比较对象名称来合并规则库元素。

在给定级别不存在重叠(不存在任何具有相同名称的元素)的情况下，结果简单地是处于那个级别的合并对象的聚合。从而如果一个规则库114仅定义名称为Class1的规则库级类，并且另一个规则库114仅定义名称为Class2的规则库级类，则合并结果将反映Class1和Class2两者。

在存在重叠的情况下，结果将依赖于所合并的元素和字段。在一些情况下，将存在元素和字段的混合。在其它情况下，仅存在规则库114之间的一致性检查。在任何情况下，下面准则可以适用。首先，合并结果仅反映由规则库构建器110识别的元素和字段，并且可能不包括具有名称空间前缀或未被识别的元素/字段。第二，可能不试图合并规则库逻辑。对于方法，这意味着只有一个规则库元素可定义该方法的实现逻辑。对于规则，这意味着只有一个规则库元素可指定规则的实现逻辑。对于约束，这意味着只有一个规则库元素可指定约束Boolean表达式。第三，对于给定元素，合并仅反映所发现的第一LocTag_Attrib。从而，如果第一规则库元素指定LocTag_Attrib，则合并结果反映该字段。否则，结果将反映第二规则库元素的LocTag_Attrib(若有的话)。下面章节提供可以如何合并规则库元素的附加详细信息。

15.1 IdentifierSpec元素的合并

当合并这些元素时，一个元素的指定应相同于其它元素，否则是其右侧子路径。例如，一个元素可能指定Person.Father.Name，并且其它元素可以指定Person.Father.Name、Father.Name或Name。如果指定不相同，则合并结果可以反映最特定(最长)指定。

15.2 DataType_Element的合并

当合并这些元素时，每个元素的属性和子元素应当与其它元素一致。对于DataTypeNumber_Element，如果Precision_Attrib不同，则合并结果可以反映两个精度中的较大者。

15.3 Rulebase_Element的合并

合并结果反映第一元素的Name_Attrib。

15.4 InitMethodDef_Element的合并(在任何级别)

合并结果可以保留多个InitMethodDef_Element，从而如果每个规则库元素在给定级别定义一个InitMethodDef_Element，则在那个级别，结果将为两个InitMethodDef_Element。每个元素保留其自己的字段和子元素，并且合并的元素应当具有不同的名称。如果合并的元素具有相同名称，则至多一个元素可指定InitMethodBody(方法实现)。

15.5 具有相同名称的Assoc_Element的合并(在任何级别)

IdentifierSpec元素可以相互一致。

15.6 具有相同名称的ConstraintSet_Element的合并(在任何级别)

规则库构建器110可以组合Constraint_Elements。对于具有相同名称的Constraint_Elements，只有一个元素可指定GeneralExpr。

15.7 具有相同名称的Class_Elements的合并(在任何级别)

如果多个元素指定Parent_Element，则这些指定应当相互一致。如果任一元素指定Parent_Element，则合并结果将反映父元素。

对于具有相同名称的FieldDcl_Elements，ResolutionType_Attribs和DataType_Elements应当相同。如果一个元素指定“final valued”，但是其它元素未指定，则该元素将为“first valued”。规则库构建器110可以组合ConstrainerList_Elements的列表。如果两个元素都指定ConstraintViolation_Elements，则规则库构建器110可以选择最受限制的一个(中止元素优先于恢复元素)。

对于具有相同名称的ClassMethodDef_Elements，方法签名(除了参数名之外)应当一致，但是最多一个元素可指定ClassMethodBody_Element(方法实现)。

对于具有相同名称的StaticInstDef_Elements，规则库构建器110可以组合LastChanceValue_Elements的任何列表。对于具有相同名称标识符的元素，规则库构建器110可以仅保留首先找到的LastChanceValue(最后机会值)。规则库构建器110对FieldDcl_Elements处理约束。

15.8 具有相同名称的Domain_Elements的合并

如果任一元素与客户端应用程序122共享，则结果将被共享。否则，结果将不被共享。如果两个元素都指定DomainGoal_Element，则目标应当具有一致值。如果任一元素指定目标，则合并结果反映该目标。

如果任一元素指定DomainAppSharedFlds_Element，则结果可以反映DomainAppSharedFlds_Element。如果两个都指定一个，则可以合并子元素，但是相同标识符不应当最终既作为DomainPreConditionList_Element又作为DomainPostConditionList_Element。

对于具有相同名称的Ruleset_Elements，如果一个元素指定Post_Attrib为“conditional(有条件的)”但是另一个未指定，则该元素将是“unconditional(无条件的)”。如果任一元素与应用程序共享，则结果将被共享。否则，结果将不被共享。规则库构建器110组合Rule_Element子元素，但是可以禁止具有相同名称的Rule_Elements。

16.内部标识符

规则定义语言引用内部标识符。下面是采用中缀语言给出的内部标识符的例子。在这些例子中，中缀语言要求每个内部标识符以“@”前缀指定。

16.1 符号引用

16.1.1 scope(范围)global(全局)

该标识符是对规则库范围级别的符号引用。例如，它可以有用于区分规则库级Class1与域级Class1。该标识符可例如通过下列代码被指定为标识符路径内的第一标识符：

@scope_global.class1.instance1.fld1＝3。

16.1.2 scope_currclass

该标识符是对执行方法的当前类的符号引用。例如，它可以有用于区分实例xyz与局部变量xyz。该标识符可在方法逻辑而非规则逻辑内、例如通过下列代码被指定为标识符路径内的第一标识符：

@scope_currclass.xyz.fld1＝3

16.1.3 scope_currinstance

该标识符是对执行方法的当前实例的符号引用。例如，它可以有用于区分字段xyz与局部变量xyz。该标识符可在方法逻辑而非规则逻辑内、例如通过下列代码被指定为标识符路径内的第一标识符，例如：

@scope_currinstance.xyz＝3

16.1.4 candidate(候选)value

该标识符是对字段的建议新值的符号引用。该标识符可在约束Boolean表达式内、例如通过下列代码指定：

@candiate_value＞＝0 or@candidate_value＜＝max_age

16.2 内部对象

16.2.1 inst_template

该标识符是对与所有类相关联的内部实例的引用。它用作动态实例创建的模型。规则或方法初始化模板字段，以反映新动态实例的期望字段。模板实例是具有受限使用的实例的特殊形式，因为它们是只写实例。规则库逻辑可以仅为模板字段设置值，但是不通过模板实例读取模板字段或调用方法。同样地，模板实例可以不具有任何推理作用，例如用于模式匹配。一个示例使用是：

//创建Duck

@inst_reset(duck.@inst_template)  //将字段复位为未知状态

//初始化模板字段

duck.@inst_template.age＝4

...//初始化附加字段

//创建新实例

@inst_make(duck)

16.3引擎级方法

16.3.1 engn_startchain

该标识符是初始化(或重新启动)当前域上下文的推理的内部方法。一个例子是：

rcInfer＝@engn_startchain()

如果推理引擎112已经在当前域上推理，则推理引擎112可以用错误中止该操作。该方法返回代码表示engn_stopchain()返回代码(若有的话)。如果推理正常终止(没有engn_stopchain执行)，则返回代码为零。

16.3.2 engn_stopchain

该标识符是立即中止当前域上下文的推理的内部方法。如果推理引擎112当前不在当前域上推理，则推理引擎112可以用错误中止该操作。该标识符还指定将作为推理返回代码而返回的数值。按照惯例，该值可以为非零，因为当推理正常终止时，推理引擎112返回零。在任何情况下，推理可以立即终止而不完成当前规则操作。如果该操作调用了方法，并且它们之一调用engn_stopchain()，则那个方法和所有动态前辈方法也立即终止。一个示例使用是：

@engn_stopchain(-123)

16.3.2 engn_tracemsg

该标识符是将文本消息发送到应用程序的MessageHandler(消息处理程序)或MessageArray(消息数组)对象(若有的话)的内部方法。如果客户端应用程序122没有定义任何这些对象，则推理引擎112可以忽略engn_tracemsg()的调用。一个示例使用是：

@engn_tracemsg(″In Rule1；father age＝″& father.age)

16.4 域级方法

16.4.1 dmn_push

该标识符是装载指定子推理域的内部方法。如果指定域已经被装载(推入)，则推理引擎112可以用错误中止该操作。一个示例使用是：

@dmn_push(DomainX)

16.4.2 dmn_pop

该标识符是卸载当前子推理域的内部方法。如果当前没有装载任何域，则推理引擎112可以用错误中止该操作。一个示例使用是：

@dmn_pop()

16.5 实例级方法

16.5.1 inst_make

该标识符是从实例模板创建动态实例的内部方法。它根据模板实例的当前字段值创建实例。规则库逻辑可以通过以由所有实例共享的字段值初始化模板实例一次然后调用inst_make()多次，从而创建多个类似的实例，其中每次修改实例特定差异的模板字段值。

16.5.2 inst_reset

该标识符是将指定实例的所有字段复位为未知状态的内部方法。一个示例使用是：

@inst_reset(class1.instance1)

16.5.3 inst_delete

该标识符是删除指定动态实例的内部方法。在一个实施例中，任何种类的规则可创建动态实例，但是只有模式匹配规则可删除它们。一个示例使用是：

for

  any duck d

if

  //鸭子是老鸭子

  d.getage()＞＝100

then

  @inst_delete(d)

end

16.5.4 inst_getname

该标识符是返回指定实例的名称的内部方法。对于静态实例，返回名称是带“.”分隔符的完全限定名称，例如：

“Domain1.Ruleset1.Person.Father”

对于动态实例，实例标识符反映索引值，例如：

“Domain1.Ruleset1.Person(23)”

一个示例使用是：

strName＝@inst_getname(person1.spouse)

16.6字段级方法(所有字段)

16.6.1 fld_isknown

该标识符是测试指定字段的可知性状态的内部方法。如果该字段目前处于KNOWN(已知)状态，该方法返回BooleanTRUE值。否则，当前活动规则将挂起，直到该字段达到已知状态。一个示例使用是：

if@fld_sknown(instance1.fld1)then...end

16.6.2 fld_isunknown

该标识符是测试指定字段的可知性状态的内部方法。如果该字段目前处于已知状态，该方法返回Boolean FALSE值。否则，该方法返回Boolean TRUE值。一个示例使用是：

if@fld_isunknown(instance1.fld1)then...end

16.6.3 fld_reset

该标识符是将指定字段复位为UNKNOWN(未知)状态的内部方法。一个示例使用是：

@fld_reset(class1.instance1.fld1)

16.7字段级方法(特定于集合)

16.7.1 set_addval

该标识符是将指定值添加到集合的内部方法。如果集合已经包含该值，则该操作没有任何效果。指定值与集合可以是类型兼容的。一个示例使用是：

@set_addval(set1，123)

16.7.2 set_doesincludeval

该标识符是测试Set(集合)是否已经包含指定值的内部方法。如果集合确实包含该值，则该方法返回Boolean TRUE值。否则，它返回Boolean FALSE值。指定值与集合可以是类型兼容的。一个示例使用是：

if@set_doesincludeval(set1，123)then...end

16.7.3 set_removeval

该标识符是从集合中删除指定值的内部方法。结果，集合保持不变，变成本身的子集，或者变成空集合。指定值与集合可以是类型兼容的。一个示例使用是：

@set_removeval(set1，123)

16.7.4 set_mergeset

该标识符是合并指定集合与基本集合的内部方法。如果指定集合为空，则该操作没有任何效果。指定集合与基本集合可以是类型兼容的。一个示例使用是：

@set_mergeset(set1，set2)//将set2合并到set1中

16.7.5 set_excludeset

该标识符是从基本集合中删除指定集合值的内部方法。结果，基本集合保持不变，变成本身的子集，或者变成空集合。指定集合与基本集合可以是类型兼容的。一个示例使用是：

@set_excludeset(set1，set(123，456))/从set1中删除值

16.7.6 set_intersect

该标识符是对指定集合与基本集合求交集的内部方法。结果，基本集合保持不变，变成本身的子集，或者变成空集合。指定集合与基本集合可以是类型兼容的。一个示例使用是：

@set_intersect(set1，set(123，456))//可能修改set1

16.7.7 set_doesintersect

该标识符是测试指定集合是否与基本集合存在交集的内部方法。如果集合共享任何值，则该方法返回Boolean TRUE值。否则，它返回Boolean FALSE值。指定集合与基本集合可以是类型兼容的。一个示例使用是：

if@set_doesintersect(set1，set2)then...end

16.7.8 set_getsize

该标识符是返回表示集合中的元素数的Number值的内部方法。如果集合为空，则该方法返回零。一个示例使用是：

var cElements is number＝@set_getsize(set1)

16.8字段级方法(特定于String)

16.8.1 string_getlength

该标识符是返回表示String长度的Number值的内部方法。如果String为空，则该方法返回零。一个示例使用是：

var cChars is number＝@string_getlength(string1)

16.9 规则集级方法

16.9.1 rulseset_postrules

该标识符是将指定规则集的规则张贴到当前域上下文的议程的内部方法。指定规则集可以具有“conditional”的Post_Attrib值。一个示例使用是：

@ruleset_postrules(domain1.ruleset1)

虽然本发明是按照优选实施例和一般关联方法来描述的，但是优选实施例和方法的变更和置换对于本领域的技术人员而言将是明显的。因此，上面对优选示例性实施例的描述不限定或约束本发明。在不脱离由所附权利要求限定的本发明的精神和范围的情况下，还可以进行其它改变、替换和变更。

Claims (56)

1.一种用于提供推理服务的方法，包括：

接收指定域的多条规则；

识别至少一个与这些规则相关联的前置条件，每个前置条件表示用于执行规则的输入；

识别至少一个与这些规则相关联的后置条件，每个后置条件表示来自规则执行的输出；

接收对应于所识别前置条件的输入值；以及

使用输入值执行这些规则的至少一部分，以产生输出值，该输出值对应于所识别的后置条件。

2.如权利要求1所述的方法，其中：

这些规则包括第一规则；并且

第一规则之一通过从补充规则库装载第二域来调用子推理，其中第二域的规则上的推理在第一规则的执行恢复之前结束。

3.如权利要求1所述的方法，其中：

这些规则包括第一规则；并且

第一规则之一通过从第一规则库装载第二域来调用子推理，其中第二域的规则上的推理在第一规则的执行恢复之前结束。

4.如权利要求1所述的方法，其中这些规则包括第一规则；并且

还包括在第一规则的执行结束之后执行多条第二规则，其中第二规则的执行使用来自第一规则的输出值，作为第二规则的输入值。

5.如权利要求1所述的方法，还包括：

将字段标识为可撤消字段；

将不可撤消值赋给该可撤消字段；

将一个或多个可撤消值赋给该可撤消字段；以及

将该可撤消字段撤消回到该不可撤消值。

6.如权利要求1所述的方法，还包括：

在规则执行开始之后，使用第一通信处理程序接收第二输入值；以及

在规则执行结束之前，使用第二通信处理程序传送输出值。

7.如权利要求1所述的方法，还包括：

接收标识第一字段的信息；

识别将最终值赋给第一字段的第一规则；

识别导致第一规则触发的第二字段；以及

识别将最终值赋给第二字段的第二规则。

8.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：确定是触发、舍弃还是挂起决策树规则。

9.如权利要求8所述的方法，其中挂起决策树规则包括：识别导致决策树规则挂起的二进制语句；并且

还包括：使决策树规则解除挂起，并且在导致决策树规则挂起的二进制语句处重新启动执行。

10.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：当执行规则时实施单调推理。

11.如权利要求1所述的方法，其中这些规则影响最终定值字段，其中可将多个值赋给最终定值字段。

12.如权利要求1所述的方法，还包括：

将包含规则的规则库的只读映像存储在存储器中；以及

将输入和输出值存储在存储器内的客户端特定信息块中。

13.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：确定由于没有特定字段的第二输入值而不能完成执行；并且

还包括：使用初始化处理程序和包含规则的规则库中的至少之一接收第二输入值，初始化处理程序用于从用户或应用程序接收第二输入值，规则库用于识别特定字段的最后机会值。

14.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：确定赋给字段的值是否违反约束；并且

还包括：如果赋给该字段的值违反约束，则执行由该字段定义的违例操作。

15.如权利要求14所述的方法，其中违例操作包括终止规则执行、将替换值赋给该字段、和使用初始化处理程序请求替代值中的至少之一。

16.如权利要求1所述的方法，其中这些规则形成二进制规则库中的指定域的至少一部分，该域标识前置条件和后置条件。

17.如权利要求16所述的方法，其中规则库包括一个或多个定义规则的编译XML文档。

18.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：前向链接或后向链接这些规则。

19.如权利要求1所述的方法，还包括生成规则快照，规则快照标识规则之一的当前状态以及导致该规则挂起的、与该规则相关联的任何字段。

20.如权利要求1所述的方法，其中执行这些规则的至少一部分包括：使用推理引擎对象执行这些规则的至少一部分。

21.如权利要求20所述的方法，其中推理引擎对象包括无状态推理引擎对象或有状态推理引擎对象。

22.如权利要求1所述的方法，其中接收多条规则包括：

接收与这些规则相关联的位置；

访问该位置；以及

从所访问的位置检索规则。

23.一种用于提供推理服务的系统，包括：

存储器，用于存储指定域的多条规则；以及

一个或多个处理器，共同用于：

识别与这些规则相关联的前置条件，前置条件表示用于执行规则的输入；

识别与这些规则相关联的后置条件，后置条件表示来自规则执行的输出；

接收对应于前置条件的输入值；以及

使用输入值执行这些规则的至少一部分以产生输出值，输出值对应于后置条件。

24.如权利要求23所述的系统，其中：

这些规则包括形成第一规则库的至少一部分的第一规则；

第一规则之一通过从补充规则库装载第二域来调用子推理，其中第二域的规则上的推理在第一规则的执行恢复之前结束。

25.如权利要求23所述的系统，其中：

这些规则包括第一规则；并且

第一规则之一通过从第一规则库装载第二域来调用子推理，其中第二域的规则上的推理在第一规则的执行恢复之前结束。

26.如权利要求23所述的系统，其中：

这些规则包括第一规则；并且

所述一个或多个处理器还共同用于在第一规则的执行结束之后执行多条第二规则，其中第二规则的执行使用来自第一规则的输出值作为第二规则的输入值。

27.如权利要求23所述的系统，其中所述一个或多个处理器还共同用于：

将字段标识为可撤消字段；

将不可撤消值赋给该可撤消字段；

将一个或多个可撤消值赋给该可撤消字段；以及

将该可撤消字段撤消回到该不可撤消值。

28.如权利要求23所述的系统，其中所述一个或多个处理器还共同用于：

接收标识第一字段的信息；

识别将最终值赋给第一字段的第一规则；

识别导致第一规则触发的第二字段；以及

识别将最终值赋给第二字段的第二规则。

29.如权利要求23所述的系统，其中所述一个或多个处理器还共同用于通过以下操作执行这些规则的至少一部分：

确定是触发、舍弃还是挂起决策树规则，其中挂起决策树规则包括：识别导致决策树规则挂起的二进制语句；以及

使决策树规则解除挂起，并且在导致决策树规则挂起的二进制语句处重新启动执行。

30.如权利要求23所述的系统，其中：

所述一个或多个处理器共同用于：通过确定由于没有特定字段的第二输入值而不能完成执行，来执行这些规则的至少一部分；并且

所述一个或多个处理器还共同用于：使用初始化处理程序和包含规则的规则库中的至少之一接收第二输入值，初始化处理程序用于从用户或应用程序接收第二输入值，规则库用于识别特定字段的最后机会值。

31如权利要求23所述的系统，其中：

所述一个或多个处理器共同用于：通过确定赋给字段的值是否违反约束来执行这些规则的至少一部分；并且

所述一个或多个处理器还共同用于：如果赋给该字段的值违反约束，则执行由该字段定义的违例操作。

32.如权利要求23所述的系统，其中所述一个或多个处理器还共同用于生成规则快照，规则快照标识规则之一的当前状态以及导致该规则挂起的、与该规则相关联的任何字段。

33.一种包含在至少一个计算机可读介质上的逻辑，在执行时用于：

识别与指定域的多条规则相关联的前置条件，前置条件表示用于执行规则的输入；

识别与这些规则相关联的后置条件，后置条件表示来自规则执行的输出；

接收对应于前置条件的输入值；以及

使用输入值执行这些规则的至少一部分以产生输出值，输出值对应于后置条件。

34.一种用于提供推理服务的系统，包括：

用于识别与指定域的多条规则相关联的前置条件的装置，其中前置条件表示用于执行规则的输入；

用于识别与这些规则相关联的后置条件的装置，其中后置条件表示来自规则执行的输出；

用于接收对应于前置条件的输入值的装置；以及

用于使用输入值执行这些规则的至少一部分以产生输出值的装置，其中输出值对应于后置条件。

35.一种用于提供推理服务的方法，包括：

将指定域的多条规则传送到推理引擎，这些规则与前置条件和后置条件相关联，前置条件表示在执行规则中由推理引擎使用的输入，后置条件表示来自规则执行的输出；

将对应于前置条件的输入值传送到推理引擎；以及

从推理引擎接收输出值，输出值对应于后置条件。

36.如权利要求35所述的方法，其中将多条规则传送到推理引擎包括：将二进制规则库和规则库位置的至少之一传送到推理引擎。

37.如权利要求36所述的方法，其中规则库位置包括统一资源定位符(URL)。

38.如权利要求35所述的方法，其中：

输出值包括多个输出值之一；

推理引擎包括无状态推理引擎；并且

还包括将控制对象传送到推理引擎，控制对象标识推理引擎是否生成各自标识输出值之一的多个输出消息、标识所有输出值的输出文档、以及规则快照的至少之一，规则快照标识规则之一的当前状态以及导致该规则挂起的、与该规则相关联的任何字段。

39.如权利要求35所述的方法，其中：

输出值包括多个输出值之一；

推理引擎包括有状态推理引擎；并且

还包括调用推理引擎中的至少一个函数，该至少一个函数用于以下项的至少之一：识别输出值之一，识别所有输出值，生成规则快照，识别求解出输出值之一的规则，将可撤消值赋给由规则使用的字段，将不可撤消值赋给由规则使用的字段，以及撤消由规则使用的字段的值，其中规则快照标识规则之一的当前状态以及导致该规则挂起的、与该规则相关联的任何字段。

40.一种用于提供推理服务的方法，包括：

接收指定域的多条第一规则，这些规则包括第一规则库的至少一部分；

将第一规则装载到存储器中；

接收包括第二规则的补充规则库；

在存储器中组合第二规则与第一规则；以及

执行第一和第二规则的至少一部分，以产生输出值。

41.如权利要求40所述的方法，还包括：

接收包括第三规则的第二补充规则库；

在存储器中组合第三规则与第一规则；以及

执行第一和第三规则的至少一部分，以产生第二输出值。

42.如权利要求40所述的方法，其中第二规则仅在由第一规则库定义的数据对象上操作。

43.如权利要求40所述的方法，其中当第二规则与第一规则冲突时，第一规则库识别是否能使用第二规则。

44.如权利要求40所述的方法，其中第一规则库和补充规则库包括二进制规则库。

45.一种用于提供推理服务的系统，包括：

存储器，用于存储指定域的多条第一规则，该多条第一规则包括第一规则库的至少一部分；以及

一个或多个处理器，共同用于：

接收包括第二规则的补充规则库；

在存储器中组合第二规则与第一规则；以及

执行第一和第二规则的至少一部分，以产生输出值。

46.如权利要求45所述的系统，其中第二规则仅在由第一规则库定义的数据对象上操作。

47.如权利要求45所述的系统，其中当第二规则与第一规则冲突时，第一规则库识别是否能使用第二规则。

48.如权利要求45所述的系统，其中第一规则库和补充规则库包括二进制规则库。

49.一种包含在至少一个计算机可读介质上的逻辑，在执行时用于：

接收指定域的多条第一规则，该多条第一规则包括第一规则库的至少一部分；

将第一规则装载到存储器中；

接收包括第二规则的补充规则库；

在存储器中组合第二规则与第一规则；以及

执行第一和第二规则的至少一部分，以产生输出值。

50.一种用于提供推理服务的方法，包括：

将指定域的多条第一规则传送到推理引擎，该多条第一规则包括第一规则库的至少一部分；

将包括第二规则的补充规则库传送到推理引擎；

使推理引擎在存储器中组合第二规则与第一规则；以及

从推理引擎接收输出值，推理引擎用于执行第一和第二规则的至少一部分以产生输出值。

51.如权利要求50所述的方法，其中将多条第一规则传送到推理引擎包括：将包含第一规则的二进制规则库和包含第一规则的规则库的位置的至少之一传送到推理引擎。

52.一种用于提供推理服务的方法，包括：

执行指定域的多条规则中的至少一部分，这些规则的至少之一包括表达式；

当求解这些规则之一中的表达式所需的字段具有未知值时，挂起该规则；

识别与导致决策树规则挂起的表达式相关联的二进制语句；

将已知值赋给导致该规则挂起的字段；

使该规则解除挂起；以及

在识别出的二进制语句处重新启动该规则的执行。

53.如权利要求52所述的方法，其中这些规则的至少之一包括决策树规则，决策树规则中的表达式将决策树规则分成至少两个子树。

54.一种用于提供推理服务的系统，包括：

存储器，用于存储指定域的多条规则，这些规则的至少之一包括表达式；以及

一个或多个处理器，共同用于：

执行这些规则的至少一部分；

当求解这些规则之一中的表达式所需的字段具有未知值时，挂起该规则；

识别与导致决策树规则挂起的表达式相关联的二进制语句；

将已知值赋给导致该规则挂起的字段；

使该规则解除挂起；以及

在识别出的二进制语句处重新启动该规则的执行。

55.如权利要求54所述的系统，其中这些规则的至少之一包括决策树规则，决策树规则中的表达式将决策树规则分成至少两个子树。

56.一种包含在至少一个计算机可读介质上的逻辑，在执行时用于：

执行指定域的多条规则中的至少一部分，这些规则的至少之一包括表达式；

当求解这些规则之一中的表达式所需的字段具有未知值时，挂起该规则；

识别与导致决策树规则挂起的表达式相关联的二进制语句；

将已知值赋给导致该规则挂起的字段；

使该规则解除挂起；以及

在识别出的二进制语句处重新启动该规则的执行。

Images