# 认知建模示例：模拟人类问题解决的产生式系统
# 产生式系统是人类认知的一种经典计算模型

class ProductionSystem:
    def __init__(self):
        self.working_memory = {}
        self.rules = []

    def add_rule(self, condition, action):
        self.rules.append((condition, action))

    def match(self, rule_condition):
        for key, value in rule_condition.items():
            if key not in self.working_memory or self.working_memory[key] != value:
                return False
        return True

    def fire(self):
        for condition, action in self.rules:
            if self.match(condition):
                action(self.working_memory)
                return True
        return False

    def run(self, max_steps=10):
        for step in range(max_steps):
            if not self.fire():
                break

# 模拟简单的算术认知过程
ps = ProductionSystem()
ps.working_memory = {'operand1': 3, 'operand2': 5, 'operation': 'add'}

ps.add_rule(
    {'operation': 'add'},
    lambda wm: wm.update({'result': wm['operand1'] + wm['operand2'], 'operation': 'done'})
)

ps.run()
print(ps.working_memory)

# 简化的图灵测试评估框架
class TuringTestEvaluator:
    def __init__(self):
        self.conversations = []
        self.judgments = []

    def conduct_conversation(self, participant, questions):
        responses = []
        for q in questions:
            response = participant.respond(q)
            responses.append(response)
        return responses

    def evaluate(self, human_responses, machine_responses):
        correct_identifications = 0
        total = len(human_responses)
        for h_resp, m_resp in zip(human_responses, machine_responses):
            if self.judge_is_human(h_resp, m_resp):
                correct_identifications += 1
        return correct_identifications / total

    def judge_is_human(self, resp_a, resp_b):
        return False

    def is_passed(self, threshold=0.5):
        avg_accuracy = sum(self.judgments) / len(self.judgments) if self.judgments else 0
        return avg_accuracy <= threshold

# 命题逻辑推理的简单实现
class PropositionalLogic:
    def __init__(self):
        self.knowledge_base = []

    def add(self, proposition):
        self.knowledge_base.append(proposition)

    def evaluate(self, proposition, model):
        if isinstance(proposition, str):
            return model.get(proposition, False)
        if proposition[0] == 'NOT':
            return not self.evaluate(proposition[1], model)
        if proposition[0] == 'AND':
            return all(self.evaluate(p, model) for p in proposition[1:])
        if proposition[0] == 'OR':
            return any(self.evaluate(p, model) for p in proposition[1:])
        if proposition[0] == 'IMPLIES':
            return not self.evaluate(proposition[1], model) or self.evaluate(proposition[2], model)
        return False

    def entails(self, query):
        symbols = self._extract_symbols()
        for model in self._all_models(symbols):
            if all(self.evaluate(kb, model) for kb in self.knowledge_base):
                if not self.evaluate(query, model):
                    return False
        return True

    def _extract_symbols(self):
        symbols = set()
        for prop in self.knowledge_base:
            self._collect_symbols(prop, symbols)
        return list(symbols)

    def _collect_symbols(self, prop, symbols):
        if isinstance(prop, str):
            symbols.add(prop)
        elif isinstance(prop, tuple):
            for p in prop[1:]:
                self._collect_symbols(p, symbols)

    def _all_models(self, symbols):
        if not symbols:
            return [{}]
        rest = self._all_models(symbols[1:])
        return [{symbols[0]: True, **m} for m in rest] + [{symbols[0]: False, **m} for m in rest]

# 经典三段论示例
logic = PropositionalLogic()
logic.add(('IMPLIES', 'Socrates_is_Man', 'Mortal'))
logic.add('Socrates_is_Man')
print(logic.entails('Mortal'))

# 理性智能体的基本框架
import random

class RationalAgent:
    def __init__(self, performance_measure):
        self.performance_measure = performance_measure
        self.beliefs = {}
        self.desires = []
        self.intentions = []

    def perceive(self, percept):
        self.beliefs.update(percept)

    def decide(self, possible_actions):
        best_action = None
        best_utility = float('-inf')
        for action in possible_actions:
            expected_utility = self._compute_expected_utility(action)
            if expected_utility > best_utility:
                best_utility = expected_utility
                best_action = action
        self.intentions.append(best_action)
        return best_action

    def act(self, action):
        return action

    def _compute_expected_utility(self, action):
        total = 0.0
        for outcome in action.possible_outcomes:
            total += outcome.probability * self.performance_measure(outcome.state)
        return total

class Outcome:
    def __init__(self, state, probability):
        self.state = state
        self.probability = probability

class Action:
    def __init__(self, name, possible_outcomes):
        self.name = name
        self.possible_outcomes = possible_outcomes

# 示例：简单的投资决策智能体
def investment_performance(state):
    returns = {'high': 100, 'medium': 50, 'low': -20, 'crash': -100}
    return returns.get(state, 0)

agent = RationalAgent(investment_performance)

action_stocks = Action('stocks', [
    Outcome('high', 0.3), Outcome('medium', 0.4),
    Outcome('low', 0.2), Outcome('crash', 0.1)
])
action_bonds = Action('bonds', [
    Outcome('medium', 0.7), Outcome('low', 0.3)
])

best = agent.decide([action_stocks, action_bonds])
print(f"理性选择: {best.name}")

# 模拟 ELIZA 的简单版本
class SimpleEliza:
    def __init__(self):
        self.rules = [
            (r'I need (.*)', lambda x: f"Why do you need {x}?"),
            (r'I feel (.*)', lambda x: f"Why do you feel {x}?"),
            (r'I am (.*)', lambda x: f"How long have you been {x}?"),
            (r'I think (.*)', lambda x: f"Do you doubt that {x}?"),
            (r'(.*)', lambda x: "Please tell me more.")
        ]

    def respond(self, user_input):
        import re
        for pattern, response_fn in self.rules:
            match = re.match(pattern, user_input, re.IGNORECASE)
            if match:
                arg = match.group(1) if match.lastindex else ""
                return response_fn(arg)
        return "I see."

eliza = SimpleEliza()
print(eliza.respond("I feel sad"))
print(eliza.respond("I need help"))

# 简单的专家系统规则引擎
class ExpertSystem:
    def __init__(self):
        self.rules = []
        self.facts = {}

    def add_rule(self, name, conditions, conclusion, confidence=1.0):
        self.rules.append({
            'name': name,
            'conditions': conditions,
            'conclusion': conclusion,
            'confidence': confidence
        })

    def add_fact(self, key, value):
        self.facts[key] = value

    def infer(self):
        conclusions = []
        changed = True
        while changed:
            changed = False
            for rule in self.rules:
                if all(self.facts.get(k) == v for k, v in rule['conditions'].items()):
                    conclusion = rule['conclusion']
                    if conclusion not in conclusions:
                        conclusions.append(conclusion)
                        self.facts[conclusion['key']] = conclusion['value']
                        changed = True
        return conclusions

# 简单的医疗诊断专家系统
medical_es = ExpertSystem()
medical_es.add_rule('fever_check',
    {'symptom': 'fever', 'duration': '>3days'},
    {'key': 'possible_infection', 'value': True}, 0.7)
medical_es.add_rule('infection_check',
    {'possible_infection': True, 'wbc': 'high'},
    {'key': 'diagnosis', 'value': 'bacterial_infection'}, 0.8)

medical_es.add_fact('symptom', 'fever')
medical_es.add_fact('duration', '>3days')
medical_es.add_fact('wbc', 'high')
print(medical_es.infer())

import random

class VacuumWorld:
    def __init__(self):
        self.rooms = {'A': random.choice(['clean', 'dirty']),
                      'B': random.choice(['clean', 'dirty'])}
        self.agent_pos = random.choice(['A', 'B'])
        self.step_count = 0
        self.total_reward = 0

    def get_percept(self):
        return (self.agent_pos, self.rooms[self.agent_pos])

    def apply_action(self, action):
        self.step_count += 1
        reward = -1
        if action == 'suck' and self.rooms[self.agent_pos] == 'dirty':
            self.rooms[self.agent_pos] = 'clean'
            reward = 10
        elif action == 'left' and self.agent_pos == 'B':
            self.agent_pos = 'A'
        elif action == 'right' and self.agent_pos == 'A':
            self.agent_pos = 'B'
        self.total_reward += reward
        return reward

    def is_done(self):
        return self.step_count >= 10

class RationalVacuumAgent:
    def __init__(self):
        self.history = []

    def choose_action(self, percept, world_state=None):
        position, room_status = percept
        if room_status == 'dirty':
            return 'suck'
        if position == 'A':
            return 'right'
        return 'left'

# 运行模拟
random.seed(42)
total_rewards = []
for _ in range(100):
    world = VacuumWorld()
    agent = RationalVacuumAgent()
    while not world.is_done():
        percept = world.get_percept()
        action = agent.choose_action(percept)
        world.apply_action(action)
    total_rewards.append(world.total_reward)

print(f"平均累计奖励: {sum(total_rewards)/len(total_rewards):.1f}")
print(f"最高累计奖励: {max(total_rewards)}")
print(f"最低累计奖励: {min(total_rewards)}")

class KnowledgeBase:
    def __init__(self):
        self.facts = set()
        self.rules = []

    def tell(self, fact):
        self.facts.add(fact)

    def add_rule(self, premises, conclusion):
        self.rules.append((premises, conclusion))

    def ask(self, query):
        return query in self.facts

    def forward_chain(self):
        changed = True
        while changed:
            changed = False
            for premises, conclusion in self.rules:
                if all(p in self.facts for p in premises):
                    if conclusion not in self.facts:
                        self.facts.add(conclusion)
                        changed = True

    def backward_chain(self, query, visited=None):
        if visited is None:
            visited = set()
        if query in self.facts:
            return True
        if query in visited:
            return False
        visited.add(query)
        for premises, conclusion in self.rules:
            if conclusion == query:
                if all(self.backward_chain(p, visited.copy()) for p in premises):
                    return True
        return False

# 示例：动物分类知识库
kb = KnowledgeBase()
kb.tell('has_hair(tweety)')
kb.tell('lays_eggs(tweety)')
kb.tell('can_fly(tweety)')

kb.add_rule(('has_hair(X)',), 'is_mammal(X)')
kb.add_rule(('is_mammal(X)', 'has_hair(X)'), 'is_warm_blooded(X)')
kb.add_rule(('lays_eggs(X)', 'is_warm_blooded(X)'), 'is_bird(X)')
kb.add_rule(('is_bird(X)', 'can_fly(X)'), 'can_sing(X)')

kb.forward_chain()
print(f"tweety 是鸟吗? {kb.ask('is_bird(tweety)')}")
print(f"tweety 会唱歌吗? {kb.ask('can_sing(tweety)')}")
print(f"所有推导出的事实: {kb.facts}")