카르노 맵: 논리식 최적화

변수: A, B
4칸 격자

      B=0   B=1
A=0 [  ?  |  ?  ]
A=1 [  ?  |  ?  ]


예: AND
      B=0   B=1
A=0 [  0  |  0  ]
A=1 [  0  |  1  ]   → AB (그대로)


예: OR
      B=0   B=1
A=0 [  0  |  1  ]   ← B만으로 묶음 (오른쪽 열)
A=1 [  1  |  1  ]   ← A만으로 묶음 (아래쪽 행)
                   → A + B

변수: A, B, C
8칸 격자 (2×4)

       BC=00  BC=01  BC=11  BC=10
A=0  [   ?  |   ?  |   ?  |   ?  ]
A=1  [   ?  |   ?  |   ?  |   ?  ]


⚠️ 그레이 코드 순서: 00, 01, 11, 10 (인접 칸은 1비트 차이)

       CD=00  CD=01  CD=11  CD=10
AB=00  [  ?  |   ?  |   ?  |   ?  ]
AB=01  [  ?  |   ?  |   ?  |   ?  ]
AB=11  [  ?  |   ?  |   ?  |   ?  ]
AB=10  [  ?  |   ?  |   ?  |   ?  ]

import itertools

def truth_table(f, n_vars):
    """함수 f의 진리표 생성 — 4변수면 16행"""
    table = []
    for combo in itertools.product([0, 1], repeat=n_vars):
        result = f(*combo)
        table.append((combo, int(result)))
    return table


# 예: F(A, B, C) = (A∧B) ∨ (B∧C) ∨ (A∧C) (다수결)
def majority(a, b, c):
    return (a and b) or (b and c) or (a and c)


for combo, result in truth_table(majority, 3):
    print(f"A={combo[0]} B={combo[1]} C={combo[2]} | F={result}")


# 카르노 맵 시각화
def kmap_3var(f):
    print("       BC=00  BC=01  BC=11  BC=10")
    for a in [0, 1]:
        row = f"A={a}    "
        for bc in [(0,0), (0,1), (1,1), (1,0)]:
            row += f"{f(a, bc[0], bc[1])}      "
        print(row)


print("\n다수결 함수의 카르노 맵:")
kmap_3var(majority)
# 결과:
#        BC=00  BC=01  BC=11  BC=10
# A=0    0      0      1      0
# A=1    0      1      1      1

# 인접한 1들을 묶으면:
# 1) A=1 row에서 BC=01,11 → A·B
# 2) A=1 row에서 BC=11,10 → A·C
# 3) BC=11 column 전체 → B·C
# 최소화: AB + AC + BC (그대로)

# 카르노 맵은 4변수까지만 시각적으로 가능
# 5변수 이상은 Quine-McCluskey 알고리즘 (자동화)

# Python: pyeda 라이브러리
# pip install pyeda

from pyeda.inter import exprvar, Or, And, Not, espresso_exprs

A, B, C, D = map(exprvar, 'ABCD')

# 복잡한 식
expr = And(A, B, Not(C)) | And(A, B, C) | And(B, C, D)
print(f"원본: {expr}")
# A·B·~C + A·B·C + B·C·D

# 최소화 (Espresso 알고리즘)
minimized, = espresso_exprs(expr.to_dnf())
print(f"최소화: {minimized}")
# A·B + B·C·D

# Before — 복잡한 조건
def access_decision(is_admin, is_owner, is_premium, is_blocked):
    if is_admin and not is_blocked:
        return True
    if is_owner and not is_blocked:
        return True
    if is_premium and not is_blocked and not is_owner:
        return True
    if is_admin and is_owner:
        return True
    return False


# 진리표 생성 → 카르노 맵 → 최소화
import itertools
print(f"{'admin':^6} {'owner':^6} {'prem':^6} {'block':^6} {'결과':^4}")
for combo in itertools.product([True, False], repeat=4):
    print(f"{str(combo[0]):^6} {str(combo[1]):^6} {str(combo[2]):^6} {str(combo[3]):^6} {str(access_decision(*combo)):^4}")


# After — 카르노 맵 분석으로 단순화
def access_decision_v2(is_admin, is_owner, is_premium, is_blocked):
    """is_blocked가 True면 무조건 거부 + 그 외는 admin/owner/premium 중 하나"""
    if is_blocked and not is_admin:  # admin은 block 우회
        return False
    return is_admin or is_owner or is_premium