from dataclasses import dataclass
from typing import List, Tuple

# This example mirrors the document's NLP topics: embeddings/transformers,
# and supervised learning (labeled data -> classification).

@dataclass
class LabeledExample:
    text: str
    label: str  # e.g., "positive" or "negative"

def tokenize(text: str) -> List[str]:
    # Minimal tokenizer to keep the example runnable without external models.
    return [t.lower() for t in text.split() if t.strip()]

def build_vocab(examples: List[LabeledExample]) -> List[str]:
    # Vocabulary acts like a tiny stand-in for word embeddings inputs.
    vocab = set()
    for ex in examples:
        vocab.update(tokenize(ex.text))
    return sorted(vocab)

def featurize(text: str, vocab: List[str]) -> List[int]:
    # Bag-of-words features: a simple numeric representation.
    tokens = set(tokenize(text))
    return [1 if w in tokens else 0 for w in vocab]

def train_logreg(examples: List[LabeledExample], vocab: List[str], lr: float = 0.2, steps: int = 2000):
    # Logistic regression trained with gradient descent (local search).
    # This demonstrates supervised learning + optimization.
    labels = sorted({ex.label for ex in examples})
    if len(labels) != 2:
        raise ValueError("This demo expects exactly 2 labels")
    y_map = {labels[0]: 0, labels[1]: 1}

    # Initialize weights to zeros.
    w = [0.0] * len(vocab)
    b = 0.0

    def sigmoid(z: float) -> float:
        return 1.0 / (1.0 + __import__("math").exp(-z))

    for _ in range(steps):
        # Single pass gradient descent over all examples.
        dw = [0.0] * len(vocab)
        db = 0.0
        for ex in examples:
            x = featurize(ex.text, vocab)
            y = y_map[ex.label]
            z = sum(wi * xi for wi, xi in zip(w, x)) + b
            p = sigmoid(z)
            # Gradient for logistic loss.
            err = p - y
            for i in range(len(vocab)):
                dw[i] += err * x[i]
            db += err
        # Update parameters.
        n = len(examples)
        for i in range(len(vocab)):
            w[i] -= lr * (dw[i] / n)
        b -= lr * (db / n)

    return labels, w, b

def predict(text: str, vocab: List[str], labels: List[str], w: List[float], b: float) -> Tuple[str, float]:
    # Predict label and probability.
    import math
    x = featurize(text, vocab)
    z = sum(wi * xi for wi, xi in zip(w, x)) + b
    p = 1.0 / (1.0 + math.exp(-z))
    label = labels[1] if p >= 0.5 else labels[0]
    return label, p

# --- Usage: labeled sentiment-like classification ---
train = [
    LabeledExample("I love this product it is great", "positive"),
    LabeledExample("This is bad and terrible quality", "negative"),
    LabeledExample("Great value and excellent support", "positive"),
    LabeledExample("Worst experience ever very bad", "negative"),
]

vocab = build_vocab(train)
labels, w, b = train_logreg(train, vocab)

test_text = "excellent support and great value"
pred_label, prob = predict(test_text, vocab, labels, w, b)
print("Prediction:", pred_label, "prob=", round(prob, 3))

from dataclasses import dataclass
from typing import Dict, List, Tuple

# This example builds directly on the document's MDP concepts:
# transition model, reward function, and a policy mapping states to actions.

@dataclass(frozen=True)
class MDP:
    states: List[str]
    actions: List[str]
    # transitions[s][a] -> list of (next_state, probability)
    transitions: Dict[str, Dict[str, List[Tuple[str, float]]]]
    # rewards[s][a] -> reward value
    rewards: Dict[str, Dict[str, float]]
    gamma: float  # discount factor

def value_iteration(mdp: MDP, theta: float = 1e-6, max_iter: int = 10_000):
    # V[s] is the utility of being in state s.
    V = {s: 0.0 for s in mdp.states}

    for _ in range(max_iter):
        delta = 0.0
        for s in mdp.states:
            v_old = V[s]
            # Bellman optimality: choose action maximizing expected utility.
            best = float("-inf")
            for a in mdp.actions:
                exp = 0.0
                for s2, p in mdp.transitions[s][a]:
                    exp += p * (mdp.rewards[s][a] + mdp.gamma * V[s2])
                best = max(best, exp)
            V[s] = best
            delta = max(delta, abs(v_old - V[s]))
        if delta < theta:
            break

    # Derive a greedy policy from the learned value function.
    policy = {}
    for s in mdp.states:
        best_a = None
        best_q = float("-inf")
        for a in mdp.actions:
            q = 0.0
            for s2, p in mdp.transitions[s][a]:
                q += p * (mdp.rewards[s][a] + mdp.gamma * V[s2])
            if q > best_q:
                best_q = q
                best_a = a
        policy[s] = best_a

    return V, policy

# --- Usage: a tiny decision-making problem ---
# States represent a simplified environment: "clean" vs "dirty".
# Actions: "inspect" (costly but informative) vs "do_nothing".
# Transition uncertainty models unknown/unobservable dynamics.
states = ["clean", "dirty"]
actions = ["inspect", "do_nothing"]

transitions = {
    "clean": {
        "inspect": [("clean", 0.9), ("dirty", 0.1)],
        "do_nothing": [("clean", 0.7), ("dirty", 0.3)],
    },
    "dirty": {
        "inspect": [("clean", 0.6), ("dirty", 0.4)],
        "do_nothing": [("clean", 0.2), ("dirty", 0.8)],
    },
}

rewards = {
    "clean": {"inspect": -1.0, "do_nothing": 1.0},
    "dirty": {"inspect": -1.0, "do_nothing": -2.0},
}

mdp = MDP(states=states, actions=actions, transitions=transitions, rewards=rewards, gamma=0.9)
V, policy = value_iteration(mdp)

print("Utilities:")
for s in states:
    print(s, "V=", round(V[s], 3))
print("Policy:", policy)

from dataclasses import dataclass
from typing import Dict, List, Optional, Set, Tuple

# This example builds on the document's knowledge representation concepts:
# ontology, knowledge base, relations, and default reasoning.

@dataclass(frozen=True)
class Fact:
    subject: str
    relation: str
    obj: str

class KnowledgeBase:
    def __init__(self):
        self.facts: Set[Fact] = set()
        # Defaults: (subject, relation) -> default object
        self.defaults: Dict[Tuple[str, str], str] = {}

    def add_fact(self, subject: str, relation: str, obj: str):
        self.facts.add(Fact(subject, relation, obj))

    def add_default(self, subject: str, relation: str, default_obj: str):
        # Default reasoning: assume default_obj unless contradicted.
        self.defaults[(subject, relation)] = default_obj

    def query(self, subject: str, relation: str) -> Optional[str]:
        # If any explicit fact exists, return it.
        for f in self.facts:
            if f.subject == subject and f.relation == relation:
                return f.obj
        # Otherwise, fall back to default if present.
        return self.defaults.get((subject, relation))

    def explain(self, subject: str, relation: str) -> str:
        # Provide a trust-building explanation for why a conclusion was made.
        explicit = [f for f in self.facts if f.subject == subject and f.relation == relation]
        if explicit:
            return f"Used explicit fact: {subject} {relation} {explicit[0].obj}."
        d = self.defaults.get((subject, relation))
        if d is not None:
            return f"Used default reasoning: assumed {subject} {relation} {d}."
        return "No knowledge available."

# --- Usage: clinical-style decision support toy example ---
kb = KnowledgeBase()

# Ontology-like relations.
# Example: "has_condition" and "risk_level".
kb.add_fact("patient_1", "has_condition", "hypertension")

# Default reasoning: most patients with hypertension are "high" risk unless overridden.
kb.add_default("patient_1", "risk_level", "high")

# Contradiction override: later we learn patient_1 has a mitigating factor.
kb.add_fact("patient_1", "risk_level", "medium")

risk = kb.query("patient_1", "risk_level")
print("Risk level:", risk)
print(kb.explain("patient_1", "risk_level"))

# Another patient uses only defaults.
kb.add_default("patient_2", "risk_level", "high")
print("Risk level:", kb.query("patient_2", "risk_level"))
print(kb.explain("patient_2", "risk_level"))

from typing import List, Optional, Tuple

# This example builds on the document's adversarial search for game playing.
# We implement minimax over a tiny deterministic game.

# Game: 1D take-away. There are N tokens. Players alternate.
# On your turn, you take 1 or 2 tokens. Player who takes the last token wins.

def winner(state: int) -> Optional[str]:
    # Terminal test: if no tokens remain, previous player won.
    if state == 0:
        return "previous_wins"
    return None

def minimax(state: int, maximizing: bool, depth: int = 0) -> Tuple[int, Optional[int]]:
    # Returns (score, best_move) where best_move is tokens taken.
    # Score convention: +1 means current player can force a win, -1 means lose.
    term = winner(state)
    if term is not None:
        # If state==0, the player to move has lost.
        return (-1 if maximizing else 1), None

    # Generate legal moves.
    moves = [m for m in (1, 2) if m <= state]

    # If maximizing, choose move that maximizes score.
    best_score = -10 if maximizing else 10
    best_move = None

    for m in moves:
        next_state = state - m
        # After making a move, roles switch.
        score, _ = minimax(next_state, not maximizing, depth + 1)
        if maximizing:
            if score > best_score:
                best_score, best_move = score, m
        else:
            if score < best_score:
                best_score, best_move = score, m

    return best_score, best_move

def best_action(tokens: int) -> int:
    score, move = minimax(tokens, maximizing=True)
    # move is guaranteed for tokens>0.
    return move

# --- Usage: choose optimal action for a game-playing agent ---
for tokens in [1, 2, 3, 4, 5, 6]:
    move = best_action(tokens)
    print(f"tokens={tokens} -> take {move}")