술어 논리: 모든/존재 = every/some

명제 논리: 단일 참/거짓 (P, Q)
술어 논리: 변수에 대한 명제 (P(x), Q(x, y))


정량자 (Quantifier)
  ∀x P(x)  — "모든 x에 대해 P(x)가 참"  (전칭, universal)
  ∃x P(x)  — "P(x)가 참인 x가 존재"      (존재, existential)

// ∀x ∈ arr: P(x) === arr.every(P)
// ∃x ∈ arr: P(x) === arr.some(P)

const numbers = [2, 4, 6, 8, 10];

// 모든 수가 짝수? — 전칭 명제
const allEven = numbers.every(n => n % 2 === 0);
console.log(allEven);  // true (∀n ∈ numbers: n is even)

// 6이 존재하는가? — 존재 명제
const hasSix = numbers.some(n => n === 6);
console.log(hasSix);   // true (∃n ∈ numbers: n === 6)


// 빈 배열의 정량자
console.log([].every(() => false));  // true  (vacuous truth — 공허한 참)
console.log([].some(() => true));    // false (존재할 게 없음)
// 수학적으로도 동일:
//   ∀x ∈ ∅: P(x) ≡ T (반례가 없으므로 참)
//   ∃x ∈ ∅: P(x) ≡ F (존재가 없으므로 거짓)

numbers = [2, 4, 6, 8, 10]

all_even = all(n % 2 == 0 for n in numbers)
any_six = any(n == 6 for n in numbers)

print(all_even)  # True
print(any_six)   # True


# 술어 함수로 일반화
def is_positive(x):
    return x > 0

def has_quality(x):
    return x in {'gold', 'silver', 'bronze'}


users = [
    {'name': 'A', 'age': 30, 'tier': 'gold'},
    {'name': 'B', 'age': 25, 'tier': 'silver'},
    {'name': 'C', 'age': 28, 'tier': 'bronze'},
]

# ∀ user: user.age > 18
all_adult = all(u['age'] > 18 for u in users)
print(all_adult)  # True

# ∃ user: user.tier == 'gold'
has_gold = any(u['tier'] == 'gold' for u in users)
print(has_gold)   # True

¬(∀x P(x)) = ∃x ¬P(x)  — "모두 참이 아니다 = 거짓인 게 하나라도 있다"
¬(∃x P(x)) = ∀x ¬P(x)  — "존재하지 않는다 = 모두 거짓이다"

# ¬(∀x: x > 0) = ∃x: x ≤ 0
nums = [1, 2, -1, 3]

# 모두 양수가 아니다 = 음수/0이 있다
not_all_positive = not all(n > 0 for n in nums)
exists_non_positive = any(n <= 0 for n in nums)
print(not_all_positive == exists_non_positive)  # True


# ¬(∃x: x > 100) = ∀x: x ≤ 100
nums = [1, 50, 99]
not_exists_big = not any(n > 100 for n in nums)
all_small = all(n <= 100 for n in nums)
print(not_exists_big == all_small)  # True

def validate_form(data):
    """술어 논리로 명확하게 정의"""
    rules = {
        'username': lambda x: isinstance(x, str) and 3 <= len(x) <= 20,
        'email':    lambda x: isinstance(x, str) and '@' in x,
        'password': lambda x: isinstance(x, str) and len(x) >= 8,
        'age':      lambda x: isinstance(x, int) and 13 <= x <= 130,
    }

    # ∀ field ∈ rules: rules[field](data[field])
    return all(
        field in data and validator(data[field])
        for field, validator in rules.items()
    )


# 테스트
valid = {
    'username': 'alice',
    'email': 'alice@example.com',
    'password': 'secret123',
    'age': 25,
}
print(validate_form(valid))  # True

invalid = {**valid, 'age': 5}  # 너무 어림
print(validate_form(invalid))  # False

# ∀ permission ∈ required: user has permission
def has_all_permissions(user, required):
    return all(p in user.permissions for p in required)


# ∃ permission ∈ required: user has permission
def has_any_permission(user, required):
    return any(p in user.permissions for p in required)


class User:
    def __init__(self, perms):
        self.permissions = set(perms)


admin = User(['read', 'write', 'delete'])
guest = User(['read'])

# 모든 권한 필요한 액션 (예: 관리자 페이지)
print(has_all_permissions(admin, ['read', 'write']))  # True
print(has_all_permissions(guest, ['read', 'write']))  # False

# 어느 하나라도 있으면 OK (예: 로그인 페이지)
print(has_any_permission(guest, ['read', 'write']))   # True (read 있음)