6강

논리에 의한 지식표현

---

1. 명제논리 (Propositional Logic)

● 명제

• 참(True)과 거짓(False)을 구분할 수 있는 문장
• 예: p = "영수는 한국인이다", q = "존은 미국인이다"

● 기본명제 vs 합성명제

• 기본명제: 더 이상 분해 불가능 (원소식)
• 합성명제: 논리 연산자를 이용해 결합된 문장 (p ∧ q, p ∨ q 등)

● 논리 연산자

• ~p : 부정 (NOT)
• p ∧ q: 논리곱 (AND)
• p ∨ q: 논리합 (OR)
• p → q: 조건 (IF-THEN)
• p ↔ q: 동치 (IF AND ONLY IF)

● 조건명제의 진리표

• p → q 는 ~p ∨ q 와 논리적으로 동치
• 진리표를 통해 참/거짓 판단 가능

---

2. 명제논리의 표준형

● 연언표준형 (CNF)

• 절(리터럴들의 OR)의 AND로 구성된 논리식
• 예: (p ∨ ~q) ∧ (r ∨ s ∨ t)

● 선언표준형 (DNF)

• 절(리터럴들의 AND)의 OR로 구성된 논리식
• 예: (~p ∧ r) ∨ (~q ∧ s ∧ t)

● 항진식 (Tautology)

• 항상 참인 논리식
• 예: p ∨ ~p

---

3. 추론 (Deduction)

● 긍정논법 (Modus Ponens)

• 전제: p, p → q → 결론: q

● 부정논법 (Modus Tollens)

• 전제: ~q, p → q → 결론: ~p

---

4. 술어논리 (Predicate Logic)

● 개념

• 객체 + 술어로 표현
• 예: Man(SOCRATES), Mortal(x)

● 전칭기호 (∀), 존재기호 (∃)

• ∀x P(x): 모든 x에 대해 P(x) 참
• ∃x P(x): 어떤 x는 P(x) 참

● 표현 예

• 모든 사람은 죽는다: ∀x Man(x) → Mortal(x)
• 소크라테스는 사람이다: Man(SOCRATES) → Mortal(SOCRATES)

---

5. 도출연역 (Resolution)

● 도출 방식

• ~P ∨ Q, ~Q ∨ R → ~P ∨ R
• P → Q, Q → R → P → R

● 단일화 (Unification)

• 변수 포함 논리식을 일치시키기 위해 변수 치환

● 절 분리 과정

• 조건문을 부정 논리합으로 변환
• 전칭기호 제거
• 변수 표준화
• 연언표준형으로 변환

---

6. 정리 증명 알고리즘

● 절차

1. 증명할 정리를 부정하여 공리에 추가
2. 모든 공리를 표준형으로 변환
3. 가능한 절 쌍을 선택해 도출
4. False 도출 시 증명 완료
5. 도출 실패 시 정리 증명 실패

---

✅ 요약

• 명제논리는 참/거짓 구분 문장 기반으로 지식 표현
• 술어논리는 객체와 속성을 포함하여 보다 정교한 표현 가능
• 도출연역은 절을 조합해 새로운 절을 도출하는 방식의 논리 추론
• 정리 증명은 도출 연산을 반복하여 거짓이 도출되는지를 확인함

코드

논리에 의한 지식표현 – 코드 예제 포함

---

✅ 명제 논리 추론: Modus Ponens 구현

# 전제: p, p → q → 결론: q

def modus_ponens(p: bool, implication: tuple):
    if implication[0] == p and p is True:
        return implication[1]
    return None

# 예시: p=True, (p → q)에서 q=True
result = modus_ponens(True, (True, True))
print("결론 q =", result)

---

✅ 부정 논법 (Modus Tollens) 구현

# 전제: ~q, p → q → 결론: ~p

def modus_tollens(q: bool, implication: tuple):
    if implication[1] == q and q is False:
        return not implication[0]
    return None

# 예시: q=False, (p → q)=(True → False)
result = modus_tollens(False, (True, False))
print("결론 ~p =", result)

---

✅ 술어 논리 표현 예제 (전칭, 존재 기호 포함)

people = ["소크라테스", "플라톤", "아리스토텔레스"]
man = lambda x: True  # 모든 사람은 사람(True)
mortal = lambda x: man(x)  # 사람은 모두 죽는다

# ∀x Man(x) → Mortal(x)
for person in people:
    print(f"{person}는 죽는다? →", mortal(person))

---

✅ 단일화(Unification) 예제

# 단순한 변수 치환을 통한 논리식 일치
def unify(x, y):
    if isinstance(x, str) and x.islower():
        return {x: y}
    elif x == y:
        return {}
    return None

# 예시: P(x) 와 P(SOCRATES)
print(unify("x", "SOCRATES"))  # {'x': 'SOCRATES'}

---

✅ 간단한 도출 연역 시뮬레이션

# 절: ~P ∨ Q, ~Q ∨ R → ~P ∨ R 도출

def resolve(clause1, clause2):
    resolved = set()
    for lit1 in clause1:
        for lit2 in clause2:
            if lit1 == f"~{lit2}" or f"~{lit1}" == lit2:
                temp = (set(clause1) | set(clause2)) - {lit1, lit2}
                resolved = resolved | temp
    return resolved

# 예제 절
c1 = {"~P", "Q"}
c2 = {"~Q", "R"}
result = resolve(c1, c2)
print("도출된 절:", result)  # {'~P', 'R'}

---

✅ 실전 활용 예: 전문가 시스템 룰 기반 추론기

rules = [
    {"if": ["열", "기침"], "then": "감기"},
    {"if": ["기침", "피로"], "then": "독감"},
]

facts = {"열", "기침"}

def rule_engine(rules, facts):
    conclusions = set()
    for rule in rules:
        if set(rule["if"]).issubset(facts):
            conclusions.add(rule["then"])
    return conclusions

print("결론:", rule_engine(rules, facts))  # 감기

---

✅ 요약

• 논리 기반 추론은 간단한 규칙 기반 코드로도 시뮬레이션 가능
• 명제 논리는 True/False 평가 기반으로 자동화 가능
• 술어 논리, 단일화, 해석 논리는 추론 엔진 기초로 사용됨
• 실제 활용: 전문가 시스템, 법률 추론, 질의 응답 시스템 등