一、什么是产生式

       要理解什么是产生式，首先要区分它和谓词逻辑中的蕴含式，以下为产生式的严格定义，即巴克斯范式（BNF）：

<产生式>::=<前提>→<结论>

<前提>::=<简单条件>|<复合条件>

<结论>::=<事实>|<操作>

<复合条件>::=<简单条件>AND<简单条件>[AND<简单条件>...]

                        |<简单条件>OR<简单条件>[OR<简单条件>...]

<操作>::=<操作名>[<变元>,...]

（PS：符号“ ::= ”表示“定义为”；符号“ | ”表示“或者是”；符号“ [ ] ”表示“可省略”）

        先说结论：蕴含式是一种特殊的产生式。①蕴含式仅仅描绘了两个命题之间的蕴含关系，而产生式则是描述了事物之间的各种对应关系，比如因果关系，时序关系等。②蕴含式只能描绘确定性的知识，产生式还可以描绘不确定的知识。③产生式的结论（后件）不仅可以是一个命题，也可以是一种操作。

        以下是确定性知识的产生式表示：

IF        P        THEN        Q

或者

P→Q

        以下是不确定性知识的产生式表示：

IF        P        THEN        Q（置信度）

或者

P→Q（置信度）

        确定性事实一般用三元组表示：

（对象，属性，值）

或

（关系，对象1，对象2）

        不确定性知识一般用四元组表示：

（对象，属性，值，置信度）

或

（关系，对象1，对象2，置信度）

        总结，产生式是人工智能领域应用较多的一种知识表示模型，

二、产生式系统

        把一组产生式放在一起，让它们相互配合，协同作用，一个产生式系统生成的结论可以作为另一个产生式的已知事实，这样的系统称为产生式系统。

        以下是产生式系统的结构图：

        规则库储存着现有的静态知识，综合数据库储存着推理过程中产生的动态知识，推理机负责控制系统的运行和推理。

三、产生式系统实践

1.实验内容：

        现在有以下规则，实现一个小型动物识别系统，能识别虎、金钱豹、斑马、长颈鹿、鸵鸟、企鹅、信天翁等七种动物的产生式系统。

r1： IF 该动物有毛发 THEN 该动物是哺乳动物

r2： IF 该动物有奶 THEN 该动物是哺乳动物

r3： IF 该动物有羽毛 THEN 该动物是鸟

r4： IF 该动物会飞 AND 会下蛋 THEN 该动物是鸟

r5： IF 该动物吃肉 THEN 该动物是食肉动物

r6： IF 该动物有犬齿 AND 有爪 AND 眼盯前方

THEN 该动物是食肉动物

r7： IF 该动物是哺乳动物 AND 有蹄

THEN 该动物是有蹄类动物

r8： IF 该动物是哺乳动物 AND 是反刍动物

THEN 该动物是有蹄类动物

r9： IF 该动物是哺乳动物 AND 是食肉动物 AND 是黄褐色AND 身上有暗斑点

THEN 该动物是金钱豹

r10：IF 该动物是哺乳动物 AND 是食肉动物 AND 是黄褐色 AND 身上有黑色条纹

THEN 该动物是虎

r11： IF 该动物是有蹄类动物 AND 有长脖子 AND 有长腿 AND 身上有暗斑点

THEN 该动物是长颈鹿

r12：IF 该动物有蹄类动物 AND 身上有黑色条纹

THEN 该动物是斑马

r13：IF 该动物是鸟 AND 有长脖子 AND 有长腿 AND 不会飞 AND 有黑白二色

THEN 该动物是鸵鸟

r14： IF 该动物是鸟 AND 会游泳 AND 不会飞

AND 有黑白二色

THEN 该动物是企鹅

r15： IF 该动物是鸟 AND 善飞

THEN 该动物是信天翁

2.Python实现：

        循环控制代码实现（代码来自网络）：

#动物识别系统
#自定义函数，判断有无重复元素
def judge_repeat(value,list=[]):
    for i in range(0,len(list)):
        if(list[i]==value):
            return 1
        else:
            if(i!=len(list)-1):
                continue
            else:
                return 0
#自定义函数，对已经整理好的综合数据库real_list进行最终的结果判断           
def judge_last(list):
    for i in list:
        if(i=='23'):
            for i in list:
                if(i=='12'):
                    for i in list:
                        if(i=='21'):
                            for i in list:
                                if(i=='13'):
                                     print("黄褐色，有斑点,哺乳类，食肉类->金钱豹\n")
                                     print("所识别的动物为金钱豹")
                                     return 0
                                elif(i=='14'):
                                    print("黄褐色，有黑色条纹，哺乳类，食肉类->虎\n")
                                    print("所识别的动物为虎")
                                    return 0
 
        
        elif(i=='14'):
            for i in list:
                if(i=='24'):
                    print("有黑色条纹，蹄类->斑马\n")
                    print("所识别的动物为斑马")
                    return 0   
        elif(i=='24'):
            for i in list:
                if(i=='13'):
                    for i in list:
                        if(i=='15'):
                            for i in list:
                                if(i=='16'):
                                    print("有斑点，有黑色条纹，长脖，蹄类->长颈鹿\n")
                                    print("所识别的动物为长颈鹿")
                                    return 0
        elif(i=='20'):
            for i in list:
                if(i=='22'):
                    print("善飞，鸟类->信天翁\n")
                    print("所识别的动物为信天翁")
                    return 0
 
        elif(i=='22'):
            for i in list:
                if(i=='4'):
                    for i in list:
                        if(i=='15'):
                            for i in list:
                                if(i=='16'):
                                    print("不会飞，长脖，长腿，鸟类->鸵鸟\n")
                                    print("所识别的动物为鸵鸟")
                                    return 0
        elif(i=='4'):
            for i in list:
                if(i=='22'):
                    for i in list:
                        if(i=='18'):
                            for i in list:
                                if(i=='19'):
                                    print("不会飞，会游泳，黑白二色，鸟类->企鹅\n")
                                    print("所识别的动物企鹅")
                                    return 0
                                
        else:
            if(list.index(i) != len(list)-1):
                continue
            else:
                print("\n根据所给条件无法判断为何种动物")
    
dict_before={'1':'有毛发','2':'产奶','3':'有羽毛','4':'不会飞','5':'会下蛋','6':'吃肉','7':'有犬齿',
             '8':'有爪','9':'眼盯前方','10':'有蹄','11':'反刍','12':'黄褐色','13':'有斑点','14':'有黑色条纹',
             '15':'长脖','16':'长腿','17':'不会飞','18':'会游泳','19':'黑白二色','20':'善飞','21':'哺乳类',
             '22':'鸟类','23':'食肉类','24':'蹄类','25':'金钱豹','26':'虎','27':'长颈鹿','28':'斑马',
             '29':'鸵鸟','30':'企鹅','31':'信天翁'}
print('''输入对应条件前面的数字:
                                *******************************************************
                                *1:有毛发  2:产奶  3:有羽毛  4:不会飞  5:会下蛋          *
                                *6:吃肉  7:有犬齿  8:有爪  9:眼盯前方  10:有蹄         *
                                *11:反刍  12:黄褐色  13:有斑点  14:有黑色条纹  15:长脖 *
                                *16:长腿  17:不会飞  18:会游泳  19:黑白二色  20:善飞   *
                                *21：哺乳类  22:鸟类  23:食肉类  24：蹄类              *
                                *******************************************************
                                *******************当输入数字0时!程序结束***************
     ''' )
#综合数据库
list_real=[]
while(1):
#循环输入前提条件所对应的字典中的键
    num_real=input("请输入：")
    list_real.append(num_real)
    if(num_real=='0'):
        break
print("\n")
print("前提条件为：")
#输出前提条件
for i in range(0,len(list_real)-1):
    print(dict_before[list_real[i]],end=" ")
print("\n")
print("推理过程如下：")
#遍历综合数据库list_real中的前提条件
for i in list_real:
    if(i=='1'):
        if(judge_repeat('21',list_real)==0):
            list_real.append('21')
            print("有毛发->哺乳类")
    elif(i=='2'):
        if(judge_repeat('21',list_real)==0):
            list_real.append('21')
            print("产奶->哺乳类")
    elif(i=='3'):
        if(judge_repeat('22',list_real)==0):
            list_real.append('22')
            print("有羽毛->鸟类")
    else:
        if(list_real.index(i) !=len(list_real)-1):
            continue
        else:
            break
for i in list_real:
    if(i=='4'):
        for i in list_real:
            if(i=='5'):
                if(judge_repeat('22',list_real)==0):
                    list_real.append('22')
                    print("不会飞，会下蛋->鸟类")
    elif(i=='6'):
        for i in list_real:
            if(i=='21'):
                if(judge_repeat('21',list_real)==0):
                    list_real.append('21')
                    print("食肉->哺乳类")
    elif(i=='7'):
        for i in list_real:
            if(i=='8'):
                for i in list_real:
                    if(i=='9'):
                        if(judge_repeat('23',list_real)==0):
                            list_real.append('23')
                            print("有犬齿,有爪,眼盯前方->食肉类")
    elif(i=='10'):
        for i in list_real:
            if(i=='21'):
                if(judge_repeat('24',list_real)==0):
                    list_real.append('24')
                    print("有蹄，哺乳类->蹄类")
                    
    elif(i=='11'):
        for i in list_real:
            if(i=='21'):
                if(judge_repeat('24',list_real)==0):
                    list_real.append('24')
                    print("反刍，哺乳类->哺乳类")
                    
    else:
        if(i !=len(list_real)-1):
            continue
        else:
            break
 
judge_last(list_real)

        循环控制是最容易想到的控制方法，但是这样做一点也不优雅，每次想要添加新的规则时得更改一堆代码，以下是更加优雅的代码（借助Deepseek完成）：

database = set()

rules = [
    {'conditions': ['该动物有毛发'], 'conclusion': '该动物是哺乳动物'},
    {'conditions': ['该动物有奶'], 'conclusion': '该动物是哺乳动物'},
    {'conditions': ['该动物有羽毛'], 'conclusion': '该动物是鸟'},
    {'conditions': ['该动物会飞', '该动物会下蛋'], 'conclusion': '该动物是鸟'},
    {'conditions': ['该动物吃肉'], 'conclusion': '该动物是食肉动物'},
    {'conditions': ['该动物有犬齿', '该动物有爪', '该动物眼盯前方'], 'conclusion': '该动物是食肉动物'},
    {'conditions': ['该动物是哺乳动物', '该动物有蹄'], 'conclusion': '该动物是有蹄类动物'},
    {'conditions': ['该动物是哺乳动物', '该动物是反刍动物'], 'conclusion': '该动物是有蹄类动物'},
    {'conditions': ['该动物是哺乳动物', '该动物是食肉动物', '该动物是黄褐色', '该动物身上有暗斑点'], 'conclusion': '该动物是金钱豹'},
    {'conditions': ['该动物是哺乳动物', '该动物是食肉动物', '该动物是黄褐色', '该动物身上有黑色条纹'], 'conclusion': '该动物是虎'},
    {'conditions': ['该动物是有蹄类动物', '该动物有长脖子', '该动物有长腿', '该动物身上有暗斑点'], 'conclusion': '该动物是长颈鹿'},
    {'conditions': ['该动物是有蹄类动物', '该动物身上有黑色条纹'], 'conclusion': '该动物是斑马'},
    {'conditions': ['该动物是鸟', '该动物有长脖子', '该动物有长腿', '该动物不会飞', '该动物有黑白二色'], 'conclusion': '该动物是鸵鸟'},
    {'conditions': ['该动物是鸟', '该动物会游泳', '该动物不会飞', '该动物有黑白二色'], 'conclusion': '该动物是企鹅'},
    {'conditions': ['该动物是鸟', '该动物善飞'], 'conclusion': '该动物是信天翁'},
]

possible_inputs = [
    '该动物有毛发', '该动物有奶', '该动物有羽毛', '该动物会飞', '该动物会下蛋',
    '该动物吃肉', '该动物有犬齿', '该动物有爪', '该动物眼盯前方', '该动物有蹄',
    '该动物是反刍动物', '该动物是黄褐色', '该动物身上有暗斑点', '该动物身上有黑色条纹',
    '该动物有长脖子', '该动物有长腿', '该动物不会飞', '该动物有黑白二色',
    '该动物善飞', '该动物会游泳'
]

final_conclusions = {
    '该动物是金钱豹', '该动物是虎', '该动物是长颈鹿',
    '该动物是斑马', '该动物是鸵鸟', '该动物是企鹅', '该动物是信天翁'
}

while True:
    print("\n可输入事实（输入编号或内容，exit退出）:")
    for i, fact in enumerate(possible_inputs, 1):
        print(f"{i:2}. {fact}")

    user_input = input("> ").strip()
    if user_input.lower() == 'exit':
        break

    # 处理用户输入
    if user_input.isdigit():
        num = int(user_input)
        if not (1 <= num <= len(possible_inputs)):
            print("输入序号无效")
            continue
        fact = possible_inputs[num-1]
    else:
        fact = user_input if user_input in possible_inputs else None
    
    if not fact:
        print("输入内容无效")
        continue

    if fact in database:
        print("事实已存在")
        continue
    
    # 添加新事实并推理
    database.add(fact)
    print(f"添加事实: {fact}")

    # 正向推理循环
    updated = True
    while updated:
        updated = False
        for rule in rules:
            if all(cond in database for cond in rule['conditions']):
                conclusion = rule['conclusion']
                if conclusion not in database:
                    database.add(conclusion)
                    print(f"推理得到: {conclusion}")
                    updated = True
                    if conclusion in final_conclusions:
                        print(f"\n最终结论: {conclusion}")
                        exit()

    # 检查最终结论
    if database & final_conclusions:
        print(f"\n最终结论: {list(database & final_conclusions)[0]}")
        exit()

print("退出推理")