score = probs[idx] - lambda_penalty * pen

evidence[lab] = {"p_nn": probs[idx], "penalty": pen, "score": score, "violations": vio}

def neuro_symbolic_predict(x, lambda_penalty=1.0, verbose=True):

rules = [
    Rule("dog",  lambda f: (f["legs"] == 4) and (not f["has_wings"]) and (not f["habitat_water"]),
         penalty=0.40, description="dogなら4脚・翼なし・水生でないはず"),
    Rule("dog",  lambda f: f["bark"] and (not f["meow"]),
         penalty=0.25, description="dogなら吠える傾向・猫鳴きでない"),

# -*- coding: utf-8 -*-
import numpy as np
np.random.seed(42)

labels = ["dog", "cat", "bird", "fish"]

def make_sample(legs, has_wings, can_fly, habitat_water, bark, meow, y):
    return np.array([legs, has_wings, can_fly, habitat_water, bark, meow], dtype=float), int(y)

# ---------- 合成データ ----------
features_list = []
labels_list   = []

for legs, has_wings, can_fly, habitat_water, bark, meow, y in [
    (4,0,0,0,1,0,0),
    (4,0,0,0,1,0,0),
    (4,0,0,0,0,1,1),
    (4,0,0,0,0,1,1),
    (2,1,1,0,0,0,2),
    (2,1,1,0,0,0,2),
    (0,0,0,1,0,0,3),
    (0,0,0,1,0,0,3),
]:
    x, label = make_sample(legs, has_wings, can_fly, habitat_water, bark, meow, y)
    features_list.append(x)
    labels_list.append(label)

X_train = np.array(features_list, dtype=float)
y_train = np.array(labels_list, dtype=int)

# ---------- ニューラル部 ----------
n_features = X_train.shape[1]
n_classes  = len(labels)

W = np.random.randn(n_features, n_classes) * 0.01
b = np.zeros((1, n_classes))

def softmax(z):
    z = z - z.max(axis=1, keepdims=True)
    exp = np.exp(z)
    return exp / exp.sum(axis=1, keepdims=True)

def forward(X):
    z = X.dot(W) + b
    return softmax(z)

def one_hot(y, n):
    y = y.astype(int) 
    oh = np.zeros((y.size, n))
    oh[np.arange(y.size), y] = 1
    return oh

def train(X, y, lr=0.1, epochs=500):
    global W, b
    Y = one_hot(y, n_classes)
    for e in range(epochs):
        P = forward(X)
        loss = -np.mean(np.sum(Y*np.log(P+1e-12), axis=1))
        grad = (P - Y) / X.shape[0]
        dW = X.T.dot(grad)
        db = np.sum(grad, axis=0, keepdims=True)
        W -= lr * dW
        b -= lr * db
        if e % 100 == 0:
            print(f"[epoch {e}] loss={loss:.4f}")

train(X_train, y_train, lr=0.2, epochs=600)

# ---------- シンボリック部 ----------
class Rule:
    def __init__(self, target_label, condition_fn, penalty, description):
        self.target_label = target_label
        self.condition_fn = condition_fn
        self.penalty      = float(penalty)
        self.description  = description

def feature_dict(x):
    return {
        "legs": int(x[0]),
        "has_wings": bool(int(x[1])),
        "can_fly": bool(int(x[2])),
        "habitat_water": bool(int(x[3])),
        "bark": bool(int(x[4])),
        "meow": bool(int(x[5])),
    }

rules = [
    Rule("dog",  lambda f: (f["legs"] == 4) and (not f["has_wings"]) and (not f["habitat_water"]),
         penalty=0.40, description="dogなら4脚・翼なし・水生でないはず"),
    Rule("dog",  lambda f: f["bark"] and (not f["meow"]),
         penalty=0.25, description="dogなら吠える傾向・猫鳴きでない"),

    Rule("cat",  lambda f: (f["legs"] == 4) and (not f["has_wings"]) and (not f["habitat_water"]),
         penalty=0.40, description="catなら4脚・翼なし・水生でないはず"),
    Rule("cat",  lambda f: f["meow"] and (not f["bark"]),
         penalty=0.25, description="catならニャーで吠えない傾向"),

    Rule("bird", lambda f: (f["legs"] in (2, 1)) and f["has_wings"],
         penalty=0.40, description="birdなら翼があり脚は2本が多い"),
    Rule("bird", lambda f: f["can_fly"] or f["has_wings"],
         penalty=0.20, description="birdなら多くは飛べるか少なくとも翼あり"),

    Rule("fish", lambda f: (f["legs"] == 0) and f["habitat_water"] and (not f["has_wings"]) and (not f["can_fly"]),
         penalty=0.50, description="fishなら脚なし・水生・翼なし・飛ばない"),
]

rules_by_label = {}
for r in rules:
    rules_by_label.setdefault(r.target_label, []).append(r)

def symbolic_penalty(label_str, x):
    f = feature_dict(x)
    penalty_sum = 0.0
    violated = []
    for r in rules_by_label.get(label_str, []):
        ok = r.condition_fn(f)
        if not ok:
            penalty_sum += r.penalty
            violated.append(r.description)
    return penalty_sum, violated

# -----------------------------
# 4) 統合推論: ニューラル確率 - シンボリックペナルティ
# -----------------------------
def neuro_symbolic_predict(x, lambda_penalty=1.0, verbose=True):
    """
    ニューラル確率 P(y|x) と symbolic ペナルティの重みつき差を最大化するラベルを選択。
    P_adj(label) = P_nn(label) - lambda * penalty(label, x)
    """
    x = x.reshape(1, -1)
    probs = forward(x)[0]  # (C,)
    best_score = -1e9
    best_label = None
    evidence = {}
    for idx, lab in enumerate(labels):
        pen, vio = symbolic_penalty(lab, x[0])
        score = probs[idx] - lambda_penalty * pen
        evidence[lab] = {"p_nn": probs[idx], "penalty": pen, "score": score, "violations": vio}
        if score > best_score:
            best_score = score
            best_label = lab

    if verbose:
        print("\n=== 統合推論レポート ===")
        print("入力特徴:", feature_dict(x[0]))
        for lab in labels:
            e = evidence[lab]
            print(f"  [{lab}] P_nn={e['p_nn']:.3f}  penalty={e['penalty']:.3f}  score={e['score']:.3f}")
            if e["violations"]:
                for v in e["violations"]:
                    print(f"     - ルール違反: {v}")
        print(f">>> 最終予測: {best_label}  (score={best_score:.3f})")
    return best_label, evidence

# -----------------------------
# 5) テスト: いくつかの入力で挙動を確認
# -----------------------------
def sample_and_predict(legs, has_wings, can_fly, habitat_water, bark, meow, lambda_penalty=1.0):
    x = np.array([legs, has_wings, can_fly, habitat_water, bark, meow], dtype=float)
    return neuro_symbolic_predict(x, lambda_penalty=lambda_penalty, verbose=True)

# 例1: 0脚・水生 → fishが有力。ニューラルが誤る場合もルールで補正
print("\n### 例1: 0脚/水生/飛行なし")
sample_and_predict(legs=0, has_wings=0, can_fly=0, habitat_water=1, bark=0, meow=0)

# 例2: 4脚・吠える → dog寄りだが、もし水生=1なら dog ルール違反
print("\n### 例2: 4脚/吠える/水生=1 (dogっぽいが水生)")
sample_and_predict(legs=4, has_wings=0, can_fly=0, habitat_water=1, bark=1, meow=0)

# 例3: 4脚・ニャー → catが有力。ただし吠えるも1にするとルールが衝突
print("\n### 例3: 4脚/ニャー/吠える=1 (catっぽさとdogっぽさの衝突)")
sample_and_predict(legs=4, has_wings=0, can_fly=0, habitat_water=0, bark=1, meow=1, lambda_penalty=0.8)