Upload ChatIPC.cpp

ChatIPC.cpp

@@ -1,5 +1,3 @@
-// ChatIPC := Chat Incremental Pattern Constructor
-
 #include <algorithm>
 #include <atomic>
 #include <cctype>
@@ -18,8 +16,6 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
-#include <cmath>
-#include <limits>
 
 #ifdef _OPENMP
 #include <omp.h>
@@ -28,16 +24,14 @@ inline int omp_get_max_threads(){ return 1; }
 inline int omp_get_thread_num(){ return 0; }
 #endif
 
-extern unsigned char dictionary_json[];      // provide dictionary.cpp to embed dictionary JSON bytes
+extern unsigned char dictionary_json[];
 extern unsigned int dictionary_json_len;
 
-// --------------------------- Short utility functions ----------------------
 
 static inline bool is_space(char c){ return std::isspace(static_cast<unsigned char>(c)) != 0; }
 static inline char to_low(char c){ return static_cast<char>(std::tolower(static_cast<unsigned char>(c))); }
 static inline void safe_flush(std::ostream &os){ os.flush(); }
 
-// NEW: dictionary model, normalization, and English-rule helpers.
 struct DictionaryEntry {
     std::string pos;
     std::string word;
@@ -263,7 +257,6 @@ static double english_rule_bonus(const std::string &context_tok, const std::stri
     return bonus;
 }
 
-// Tokenize by whitespace
 static std::vector<std::string> tokenize_whitespace(const std::string &s){
     std::istringstream iss(s);
     std::vector<std::string> out;
@@ -272,7 +265,6 @@ static std::vector<std::string> tokenize_whitespace(const std::string &s){
     return out;
 }
 
-// Tokenize by non-alphanumeric characters (for definitions)
 static std::vector<std::string> tokenize_non_alnum(const std::string &s){
     std::vector<std::string> out; std::string cur;
     for (char ch : s){
@@ -286,572 +278,6 @@ static std::vector<std::string> tokenize_non_alnum(const std::string &s){
     return out;
 }
 
-// ---------------- Math feature: iterative only ----------------
-
-enum class MathOp {
-    Unknown,
-    Add,
-    Sub,
-    Mul,
-    Div,
-    Lt,
-    Le,
-    Gt,
-    Ge,
-    Eq
-};
-
-struct MathValue {
-    bool valid = false;
-    bool is_bool = false;
-    double number = 0.0;
-    bool boolean = false;
-};
-
-static inline std::string lower_copy_str(const std::string &s) {
-    std::string out;
-    out.reserve(s.size());
-    for (char c : s) out.push_back(to_low(c));
-    return out;
-}
-
-static inline std::string trim_math_surface(const std::string &s) {
-    size_t b = 0, e = s.size();
-    while (b < e && std::isspace(static_cast<unsigned char>(s[b]))) ++b;
-    while (e > b && std::isspace(static_cast<unsigned char>(s[e - 1]))) --e;
-
-    while (b < e) {
-        unsigned char uc = static_cast<unsigned char>(s[b]);
-        char c = s[b];
-        if (!std::ispunct(uc) || c == '<' || c == '>' || c == '=' || c == '+' ||
-            c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
-            break;
-        ++b;
-    }
-    while (e > b) {
-        unsigned char uc = static_cast<unsigned char>(s[e - 1]);
-        char c = s[e - 1];
-        if (!std::ispunct(uc) || c == '<' || c == '>' || c == '=' || c == '+' ||
-            c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
-            break;
-        --e;
-    }
-
-    std::string out;
-    out.reserve(e - b);
-    for (size_t i = b; i < e; ++i) out.push_back(to_low(s[i]));
-    return out;
-}
-
-static inline bool is_number_surface(const std::string &s, double &value) {
-    if (s.empty()) return false;
-    bool has_digit = false;
-    bool has_dot = false;
-
-    for (char c : s) {
-        if (std::isdigit(static_cast<unsigned char>(c))) {
-            has_digit = true;
-            continue;
-        }
-        if (c == '.' && !has_dot) {
-            has_dot = true;
-            continue;
-        }
-        if ((c == '+' || c == '-') && &c == &s.front()) continue;
-        return false;
-    }
-    if (!has_digit) return false;
-
-    try {
-        size_t idx = 0;
-        value = std::stod(s, &idx);
-        return idx == s.size();
-    } catch (...) {
-        return false;
-    }
-}
-
-static inline bool is_sentence_break_token(const std::string &raw) {
-    if (raw.empty()) return false;
-    const char c = raw.back();
-    return c == '.' || c == '?' || c == '!' || c == ';' || c == ':';
-}
-
-static inline bool is_logic_token(const std::string &t) {
-    return t == "and" || t == "or" || t == "not";
-}
-
-static inline bool is_comparison_surface(const std::string &t) {
-    return t == "<" || t == "<=" || t == ">" || t == ">=" || t == "=" || t == "==";
-}
-
-static inline bool is_reversal_marker(const std::string &t) {
-    return t == "from" || t == "than" || t == "by";
-}
-
-static inline bool is_add_seed(const std::string &t) {
-    return t == "add" || t == "plus" || t == "sum";
-}
-
-static inline bool is_sub_seed(const std::string &t) {
-    return t == "subtract" || t == "minus" || t == "difference";
-}
-
-static inline bool is_mul_seed(const std::string &t) {
-    return t == "multiply" || t == "times" || t == "product";
-}
-
-static inline bool is_div_seed(const std::string &t) {
-    return t == "divide" || t == "quotient" || t == "over";
-}
-
-static inline bool is_lt_seed(const std::string &t) {
-    return t == "less" || t == "smaller" || t == "lower";
-}
-
-static inline bool is_gt_seed(const std::string &t) {
-    return t == "greater" || t == "larger" || t == "higher" || t == "more";
-}
-
-static inline bool is_le_seed(const std::string &t) {
-    return t == "atmost" || t == "at" || t == "no";
-}
-
-static inline bool is_ge_seed(const std::string &t) {
-    return t == "atleast";
-}
-
-static inline bool is_eq_seed(const std::string &t) {
-    return t == "equal" || t == "equals" || t == "same";
-}
-
-// Minimal bootstrap seeds only; dictionary closure does the expansion.
-static const std::vector<std::string> &op_seed_lexicon(MathOp op) {
-    static const std::vector<std::string> add = {"add", "plus", "sum"};
-    static const std::vector<std::string> sub = {"subtract", "minus", "difference"};
-    static const std::vector<std::string> mul = {"multiply", "times", "product"};
-    static const std::vector<std::string> div = {"divide", "quotient", "over"};
-    static const std::vector<std::string> lt  = {"less", "smaller", "lower"};
-    static const std::vector<std::string> le  = {"at", "most", "no"};
-    static const std::vector<std::string> gt  = {"greater", "larger", "higher", "more"};
-    static const std::vector<std::string> ge  = {"at", "least", "no"};
-    static const std::vector<std::string> eq  = {"equal", "equals", "same"};
-
-    switch (op) {
-        case MathOp::Add: return add;
-        case MathOp::Sub: return sub;
-        case MathOp::Mul: return mul;
-        case MathOp::Div: return div;
-        case MathOp::Lt:  return lt;
-        case MathOp::Le:  return le;
-        case MathOp::Gt:  return gt;
-        case MathOp::Ge:  return ge;
-        case MathOp::Eq:  return eq;
-        default:          return eq;
-    }
-}
-
-static std::unordered_set<std::string>
-closure_set_from_tokens(const std::vector<std::string> &toks, int depth) {
-    std::unordered_set<std::string> acc;
-    std::unordered_set<std::string> frontier;
-
-    acc.reserve(toks.size() * 4 + 16);
-    frontier.reserve(toks.size() * 2 + 8);
-
-    for (const auto &tok : toks) {
-        const std::string k = normalize_dictionary_key(tok);
-        if (!k.empty() && acc.insert(k).second) frontier.insert(k);
-    }
-
-    for (int d = 0; d < depth && !frontier.empty(); ++d) {
-        std::unordered_set<std::string> next;
-        next.reserve(frontier.size() * 4 + 8);
-
-        for (const auto &k : frontier) {
-            auto it = global_def_tokens_cache.find(k);
-            if (it == global_def_tokens_cache.end()) continue;
-
-            for (const auto &w : it->second) {
-                const std::string kw = normalize_dictionary_key(w);
-                if (!kw.empty() && acc.insert(kw).second) next.insert(kw);
-            }
-        }
-        frontier.swap(next);
-    }
-    return acc;
-}
-
-static double jaccard_sets(const std::unordered_set<std::string> &a,
-                           const std::unordered_set<std::string> &b) {
-    if (a.empty() && b.empty()) return 0.0;
-
-    const std::unordered_set<std::string> *sm = &a, *lg = &b;
-    if (a.size() > b.size()) std::swap(sm, lg);
-
-    size_t inter = 0;
-    for (const auto &x : *sm) {
-        if (lg->find(x) != lg->end()) ++inter;
-    }
-    const size_t uni = a.size() + b.size() - inter;
-    return uni ? static_cast<double>(inter) / static_cast<double>(uni) : 0.0;
-}
-
-static double score_operator(const std::vector<std::string> &segment,
-                             MathOp op,
-                             int def_depth) {
-    const auto prompt_closure = closure_set_from_tokens(segment, def_depth);
-    const auto seed_closure = closure_set_from_tokens(op_seed_lexicon(op), def_depth);
-
-    double s = jaccard_sets(prompt_closure, seed_closure);
-
-    for (const auto &raw : segment) {
-        const std::string t = normalize_dictionary_key(raw);
-
-        if (op == MathOp::Add && is_add_seed(t)) s += 0.12;
-        if (op == MathOp::Sub && is_sub_seed(t)) s += 0.12;
-        if (op == MathOp::Mul && is_mul_seed(t)) s += 0.12;
-        if (op == MathOp::Div && is_div_seed(t)) s += 0.12;
-        if (op == MathOp::Lt  && is_lt_seed(t))  s += 0.12;
-        if (op == MathOp::Le  && is_le_seed(t))  s += 0.12;
-        if (op == MathOp::Gt  && is_gt_seed(t))  s += 0.12;
-        if (op == MathOp::Ge  && is_ge_seed(t))  s += 0.12;
-        if (op == MathOp::Eq  && is_eq_seed(t))  s += 0.12;
-    }
-    return s;
-}
-
-static MathOp infer_dominant_operator(const std::vector<std::string> &segment, int def_depth) {
-    const double sa = score_operator(segment, MathOp::Add, def_depth);
-    const double ss = score_operator(segment, MathOp::Sub, def_depth);
-    const double sm = score_operator(segment, MathOp::Mul, def_depth);
-    const double sd = score_operator(segment, MathOp::Div, def_depth);
-    const double sl = score_operator(segment, MathOp::Lt,  def_depth);
-    const double sle = score_operator(segment, MathOp::Le, def_depth);
-    const double sg = score_operator(segment, MathOp::Gt,  def_depth);
-    const double sge = score_operator(segment, MathOp::Ge, def_depth);
-    const double se = score_operator(segment, MathOp::Eq,  def_depth);
-
-    MathOp best = MathOp::Unknown;
-    double bestv = -1.0;
-
-    const std::pair<MathOp, double> arr[] = {
-        {MathOp::Add, sa}, {MathOp::Sub, ss}, {MathOp::Mul, sm}, {MathOp::Div, sd},
-        {MathOp::Lt, sl}, {MathOp::Le, sle}, {MathOp::Gt, sg}, {MathOp::Ge, sge},
-        {MathOp::Eq, se}
-    };
-
-    for (const auto &p : arr) {
-        if (p.second > bestv) {
-            bestv = p.second;
-            best = p.first;
-        }
-    }
-    return best;
-}
-
-
-static bool has_any_logic_token(const std::vector<std::string> &segment) {
-    for (const auto &raw : segment) {
-        if (is_logic_token(normalize_dictionary_key(raw))) return true;
-    }
-    return false;
-}
-
-static double fold_numbers_iterative(const std::vector<double> &nums, MathOp op, bool reverse_sub) {
-    if (nums.empty()) return 0.0;
-    if (nums.size() == 1) return nums[0];
-
-    if (op == MathOp::Add) {
-        double acc = 0.0;
-        for (double x : nums) acc += x;
-        return acc;
-    }
-
-    if (op == MathOp::Mul) {
-        double acc = 1.0;
-        for (double x : nums) acc *= x;
-        return acc;
-    }
-
-    if (op == MathOp::Div) {
-        double acc = nums[0];
-        for (size_t i = 1; i < nums.size(); ++i) {
-            if (nums[i] == 0.0) return std::numeric_limits<double>::quiet_NaN();
-            acc /= nums[i];
-        }
-        return acc;
-    }
-
-    if (op == MathOp::Sub) {
-        if (reverse_sub && nums.size() >= 2) {
-            double acc = nums.back();
-            for (size_t i = nums.size() - 1; i-- > 0;) {
-                acc -= nums[i];
-            }
-            return acc;
-        } else {
-            double acc = nums[0];
-            for (size_t i = 1; i < nums.size(); ++i) acc -= nums[i];
-            return acc;
-        }
-    }
-
-    // Default arithmetic fallback: sum.
-    double acc = 0.0;
-    for (double x : nums) acc += x;
-    return acc;
-}
-
-static std::optional<double>
-evaluate_numeric_segment(const std::vector<std::string> &segment, int def_depth) {
-    std::vector<double> nums;
-    nums.reserve(segment.size());
-
-    for (const auto &raw : segment) {
-        const std::string surf = trim_math_surface(raw);
-        double v = 0.0;
-        if (is_number_surface(surf, v)) nums.push_back(v);
-    }
-
-    if (nums.empty()) return std::nullopt;
-    if (nums.size() == 1) return nums[0];
-
-    const MathOp op = infer_dominant_operator(segment, def_depth);
-
-    bool reverse_sub = false;
-    for (const auto &raw : segment) {
-        const std::string t = normalize_dictionary_key(raw);
-        if (is_reversal_marker(t)) {
-            reverse_sub = true;
-            break;
-        }
-    }
-
-    if (op == MathOp::Unknown) {
-        // Best-effort fallback: if there are multiple numerals and no clear cue,
-        // addition is the conservative default for many count/total prompts.
-        return fold_numbers_iterative(nums, MathOp::Add, false);
-    }
-
-    if (op == MathOp::Sub) return fold_numbers_iterative(nums, MathOp::Sub, reverse_sub);
-    if (op == MathOp::Add) return fold_numbers_iterative(nums, MathOp::Add, false);
-    if (op == MathOp::Mul) return fold_numbers_iterative(nums, MathOp::Mul, false);
-    if (op == MathOp::Div) return fold_numbers_iterative(nums, MathOp::Div, false);
-
-    // Numeric segment for comparison-like clauses: use the arithmetic value.
-    return fold_numbers_iterative(nums, MathOp::Add, false);
-}
-
-static std::optional<bool>
-evaluate_comparison_segment(const std::vector<std::string> &segment, int def_depth) {
-    size_t cue_pos = std::numeric_limits<size_t>::max();
-    MathOp cmp = MathOp::Unknown;
-    double best = -1.0;
-
-    for (size_t i = 0; i < segment.size(); ++i) {
-        const std::string t = trim_math_surface(segment[i]);
-
-        MathOp cand = MathOp::Unknown;
-        if (t == "<") cand = MathOp::Lt;
-        else if (t == "<=") cand = MathOp::Le;
-        else if (t == ">") cand = MathOp::Gt;
-        else if (t == ">=") cand = MathOp::Ge;
-        else if (t == "=" || t == "==") cand = MathOp::Eq;
-        else if (normalize_dictionary_key(segment[i]) == "less") cand = MathOp::Lt;
-        else if (normalize_dictionary_key(segment[i]) == "greater") cand = MathOp::Gt;
-        else if (normalize_dictionary_key(segment[i]) == "equal" || normalize_dictionary_key(segment[i]) == "equals")
-            cand = MathOp::Eq;
-
-        if (cand != MathOp::Unknown) {
-            const double s = score_operator(segment, cand, def_depth);
-            if (s > best) {
-                best = s;
-                cmp = cand;
-                cue_pos = i;
-            }
-        }
-    }
-
-    if (cmp == MathOp::Unknown || cue_pos == std::numeric_limits<size_t>::max()) return std::nullopt;
-
-    std::vector<std::string> left(segment.begin(), segment.begin() + static_cast<std::ptrdiff_t>(cue_pos));
-    std::vector<std::string> right(segment.begin() + static_cast<std::ptrdiff_t>(cue_pos) + 1, segment.end());
-
-    auto lv = evaluate_numeric_segment(left, def_depth);
-    auto rv = evaluate_numeric_segment(right, def_depth);
-    if (!lv.has_value() || !rv.has_value()) return std::nullopt;
-
-    switch (cmp) {
-        case MathOp::Lt: return *lv < *rv;
-        case MathOp::Le: return *lv <= *rv;
-        case MathOp::Gt: return *lv > *rv;
-        case MathOp::Ge: return *lv >= *rv;
-        case MathOp::Eq: return std::fabs(*lv - *rv) < 1e-12;
-        default: return std::nullopt;
-    }
-}
-
-static std::optional<bool>
-evaluate_logic_chain(const std::vector<std::vector<std::string>> &segments, int def_depth) {
-    if (segments.empty()) return std::nullopt;
-
-    std::vector<bool> vals;
-    vals.reserve(segments.size());
-    std::vector<std::string> ops;
-    ops.reserve(segments.size());
-
-    for (const auto &seg : segments) {
-        bool negate = false;
-        size_t first_sig = 0;
-        while (first_sig < seg.size() &&
-               normalize_dictionary_key(seg[first_sig]).empty()) {
-            ++first_sig;
-        }
-        if (first_sig < seg.size() && normalize_dictionary_key(seg[first_sig]) == "not") {
-            negate = true;
-        }
-
-        std::optional<bool> v = evaluate_comparison_segment(seg, def_depth);
-        if (!v.has_value()) {
-            auto n = evaluate_numeric_segment(seg, def_depth);
-            if (!n.has_value()) return std::nullopt;
-            v = (*n != 0.0);
-        }
-
-        bool b = *v;
-        if (negate) b = !b;
-        vals.push_back(b);
-    }
-
-    // If the original prompt had "and/or" tokens, combine them left-to-right.
-    // Otherwise, a single boolean clause is returned.
-    if (segments.size() == 1) return vals[0];
-
-    bool acc = vals[0];
-    size_t seg_idx = 1;
-    for (size_t i = 0; i < segments.size() - 1; ++i) {
-        // A simple left-to-right boolean fold. If the user wrote mixed logic,
-        // this is conservative and iterative.
-        const std::vector<std::string> &seg = segments[i];
-        bool saw_or = false;
-        bool saw_and = false;
-        for (const auto &raw : seg) {
-            const std::string t = normalize_dictionary_key(raw);
-            if (t == "or") saw_or = true;
-            if (t == "and") saw_and = true;
-        }
-        if (saw_or && !saw_and) acc = acc || vals[seg_idx++];
-        else acc = acc && vals[seg_idx++];
-    }
-
-    return acc;
-}
-
-static std::vector<std::vector<std::string>>
-split_into_math_segments(const std::vector<std::string> &prompt_toks) {
-    std::vector<std::vector<std::string>> segs;
-    std::vector<std::string> cur;
-    segs.reserve(8);
-
-    for (const auto &tok : prompt_toks) {
-        const std::string t = normalize_dictionary_key(tok);
-
-        if (is_sentence_break_token(tok)) {
-            if (!cur.empty()) {
-                segs.push_back(std::move(cur));
-                cur.clear();
-            }
-            continue;
-        }
-
-        if (t == "then" || t == "after" || t == "before") {
-            if (!cur.empty()) {
-                segs.push_back(std::move(cur));
-                cur.clear();
-            }
-            continue;
-        }
-
-        cur.push_back(tok);
-    }
-
-    if (!cur.empty()) segs.push_back(std::move(cur));
-    return segs;
-}
-
-static std::optional<std::string>
-try_math_branch(const std::vector<std::string> &prompt_toks, int def_depth) {
-    if (prompt_toks.empty()) return std::nullopt;
-
-    auto segments = split_into_math_segments(prompt_toks);
-    if (segments.empty()) return std::nullopt;
-
-    // If any segment contains logic/comparison language, try boolean evaluation.
-    bool has_logic = false;
-    bool has_cmp = false;
-    for (const auto &seg : segments) {
-        if (has_any_logic_token(seg)) has_logic = true;
-        if (evaluate_comparison_segment(seg, def_depth).has_value()) has_cmp = true;
-    }
-
-    if (has_logic || has_cmp) {
-        auto b = evaluate_logic_chain(segments, def_depth);
-        if (b.has_value()) {
-            const std::string out = *b ? "True" : "False";
-            std::cout << out << ' ' << std::flush;
-            return out;
-        }
-    }
-
-    // Otherwise choose the strongest arithmetic-looking segment.
-    double best_score = -1.0;
-    const std::vector<std::string> *best_seg = nullptr;
-
-    for (const auto &seg : segments) {
-        const MathOp op = infer_dominant_operator(seg, def_depth);
-        double s = score_operator(seg, op, def_depth);
-
-        // Numeric content increases confidence.
-        size_t num_count = 0;
-        for (const auto &raw : seg) {
-            double v = 0.0;
-            if (is_number_surface(trim_math_surface(raw), v)) ++num_count;
-        }
-        s += 0.03 * static_cast<double>(num_count);
-
-        if (s > best_score) {
-            best_score = s;
-            best_seg = &seg;
-        }
-    }
-
-    if (!best_seg || best_score < 0.12) return std::nullopt;
-
-    auto comp = evaluate_comparison_segment(*best_seg, def_depth);
-    if (comp.has_value()) return *comp ? std::string("True") : std::string("False");
-
-    auto num = evaluate_numeric_segment(*best_seg, def_depth);
-    if (num.has_value()) {
-        std::ostringstream oss;
-        const double rounded = std::round(*num);
-        if (std::fabs(*num - rounded) < 1e-12) oss << static_cast<long long>(rounded);
-        else oss << *num;
-
-        const std::string out = oss.str();
-        std::cout << out << ' ' << std::flush;
-        return out;
-    }
-
-    std::ostringstream oss;
-    const double rounded = std::round(*num);
-    if (std::fabs(*num - rounded) < 1e-12) oss << static_cast<long long>(rounded);
-    else oss << *num;
-    return oss.str();
-}
-
-// --------------------------- String interning (short methods) --------------
-
 using StrPtr = const std::string*;
 using TokenId = std::uint32_t;
 static constexpr TokenId TOKEN_ID_INVALID = 0xFFFFFFFFu;
@@ -925,7 +351,6 @@ static inline std::size_t bitset_intersection_count(const std::uint64_t *a, cons
     return total;
 }
 
-// ---------- Global parsed dictionary (populated once in main) ----------
 static void build_def_tokens_cache(){
     global_def_tokens_cache.clear();
     global_pos_cache.clear();
@@ -960,7 +385,6 @@ static void build_def_tokens_cache(){
     }
 }
 
-// --------------------------- Knowledge base (short methods) --------------
 struct PtrHash { size_t operator()(StrPtr p) const noexcept { return std::hash<StrPtr>()(p); } };
 struct PtrEq   { bool operator()(StrPtr a, StrPtr b) const noexcept { return a == b; } };
 
@@ -972,7 +396,6 @@ struct KnowledgeBase {
     std::unordered_map<std::string, StrPtr> next_key_index;
     mutable std::mutex m;
 
-    // def-index: for each interned word pointer -> list of interned tokens (definition expansion)
     std::unordered_map<StrPtr, std::vector<StrPtr>, PtrHash, PtrEq> def_index;
     mutable std::mutex def_m;
     int def_depth = 0;
@@ -985,7 +408,6 @@ struct KnowledgeBase {
         vec.push_back(v);
     }
 
-    // set def depth; if changed, drop previously computed def expansions
     void set_def_depth(int D){
         std::lock_guard<std::mutex> lk(def_m);
         if (D != def_depth){
@@ -1045,11 +467,10 @@ struct KnowledgeBase {
             def_index.emplace(wp, std::move(out));
         }
     }
-    // existing public add_pair but now ensure def-expansion is built immediately
+
     void add_pair(const std::string &k, const std::string &v){
         StrPtr kp = interner.intern(k);
         StrPtr vp = interner.intern(v);
-        // ensure definition expansion for both words as soon as they are seen
         ensure_def_for_interned(kp);
         ensure_def_for_interned(vp);
         add_pair_interned(kp, vp);
@@ -1081,8 +502,6 @@ intern_tokens(KnowledgeBase &kb, const std::vector<std::string> &tokens)
     return out;
 }
 
-// --------------------------- Small JSON parse helpers ----------------------
-
 static inline bool json_valid_index(size_t i, size_t n){ return i < n; }
 
 static std::string parse_quoted_string(const std::string &text, size_t &i){
@@ -1107,7 +526,6 @@ static void skip_spaces(const std::string &s, size_t &i){
     while (json_valid_index(i, s.size()) && is_space(s[i])) ++i;
 }
 
-// Very small JSON-like parser tailored to dictionary_json structure
 static void skip_json_value(const std::string &s, size_t &i);
 
 static std::vector<std::string> parse_json_string_array(const std::string &text, size_t &i){
@@ -1381,10 +799,6 @@ static std::vector<std::string> construct_response(KnowledgeBase &kb,
     std::vector<std::string> resp;
     if (prompt_toks.empty() || maxlen == 0) return resp;
 
-    if (auto math_out = try_math_branch(prompt_toks, static_cast<int>(kb.def_depth)); math_out.has_value()) {
-        return std::vector<std::string>{*math_out};
-    }
-
     auto prompt_ptrs = intern_tokens(kb, prompt_toks);
     std::vector<StrPtr> resp_ptrs;
     std::unordered_map<std::string,int> recent_counts;
@@ -1467,8 +881,6 @@ static std::vector<std::string> construct_response(KnowledgeBase &kb,
     return resp;
 }
 
-// --------------------------- Learning from files (short) -------------------
-
 static void learn_from_file(KnowledgeBase &kb, const std::string &fname){
     std::ifstream ifs(fname);
     if (!ifs) return;
@@ -1486,8 +898,7 @@ static void learn_files_parallel(KnowledgeBase &kb, const std::vector<std::strin
     for (ptrdiff_t i=0;i<static_cast<ptrdiff_t>(files.size());++i) learn_from_file(kb, files[(size_t)i]);
 }
 
-// --------------------------- Serialization (binary, versioned) --------------
-static constexpr std::uint64_t KB_MAGIC   = 0x434850434B535641ULL; // "CHPCKSVA"
+static constexpr std::uint64_t KB_MAGIC   = 0x434850434B535641ULL;
 static constexpr std::uint64_t KB_VERSION = 1ULL;
 
 static void write_u64(std::ostream &os, std::uint64_t v){
@@ -1679,7 +1090,6 @@ static void load_kb_binary(KnowledgeBase &kb, const std::string &fname, int cli_
         }
     }
 
-    // If the caller asks for a different dict depth, recompute with the current embedded dictionary.
     if (cli_dict_depth != static_cast<int>(file_def_depth)){
         kb.set_def_depth(cli_dict_depth);
 
@@ -1710,8 +1120,6 @@ static void load_kb_binary(KnowledgeBase &kb, const std::string &fname, int cli_
     }
 }
 
-// --------------------------- CLI + Interactive loop (shorters) -----------
-
 static void print_usage(const char *p){
     std::cout << "Usage: " << p << " [--maxlen N] [--save FILE] [--load-kb FILE] [--dict-depth D] [--learn f1 f2 ...] [--repeat-penalty P] [--help]\n";
     std::cout << "  --maxlen N          Maximum number of tokens constructed in a response.\n";
@@ -1755,13 +1163,10 @@ int main(int argc, char **argv){
 
     KnowledgeBase kb;
 
-    // parse the embedded dictionary once for use by per-word expansion
     global_dictionary_entries = parse_dictionary_json();
     build_def_tokens_cache();
-    // set KB def depth (clears any previous expansion)
     kb.set_def_depth(dict_depth);
 
-
     if (!load_kb.empty()){
         try { std::cerr << "Loading KB: " << load_kb << "\n";
         load_kb_binary(kb, load_kb, dict_depth); std::cerr << "Loaded KB: " << load_kb << "\n"; }
@@ -1781,11 +1186,7 @@ int main(int argc, char **argv){
         for (size_t i=1;i<prompt_toks.size();++i) kb.add_pair(prompt_toks[i-1], prompt_toks[i]);
         auto resp = construct_response(kb, prompt_toks, maxlen, repeat_penalty);
         std::cout << "\n";
-        if (!resp.empty()){
-            std::vector<std::string> combined = prompt_toks;
-            combined.insert(combined.end(), resp.begin(), resp.end());
-            for (size_t i=1;i<combined.size();++i) kb.add_pair(combined[i-1], combined[i]);
-        }
+        if (!resp.empty()){for (size_t i=1;i<resp.size();++i) kb.add_pair(resp[i-1], resp[i]);}
         if (!savefile.empty()){
             try { std::cerr << "Saving KB: " << savefile << "\n";
             save_kb_binary(kb, savefile); std::cerr << "Saved KB: " << savefile << "\n"; }